react-native-audio-browser 0.2.0-next.12 → 0.2.0-next.14

package/android/src/test/java/com/audiobrowser/browser/InertStyleDiagnosticTest.kt

@@ -0,0 +1,277 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.browseTrack
+import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.sectionStyle
+import com.audiobrowser.TestFixtures.track
+import com.audiobrowser.TestFixtures.trackStyle
+import com.margelo.nitro.audiobrowser.ArtworkRendering
+import com.margelo.nitro.audiobrowser.CardImage
+import com.margelo.nitro.audiobrowser.GridTile
+import com.margelo.nitro.audiobrowser.ImageShape
+import com.margelo.nitro.audiobrowser.Section
+import com.margelo.nitro.audiobrowser.SectionStyle
+import com.margelo.nitro.audiobrowser.StyleDisplay
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * 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. Mirrors `ios/Tests/InertStyleDiagnosticTests.swift`.
+ */
+class InertStyleDiagnosticTest {
+
+  private fun findings(
+    sections: List<Section>,
+    page: SectionStyle? = null,
+    path: String = "/home",
+  ) = InertStyleDiagnostic.findings(path, page, sections)
+
+  // Container properties
+
+  @Test
+  fun `gridWrap on a list section is inert`() {
+    val found = findings(listOf(section(style = sectionStyle(gridWrap = false), title = "Recent")))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("section 'Recent'"))
+    assertTrue(found[0], found[0].contains("style.gridWrap"))
+    assertTrue(found[0], found[0].contains("display 'list'"))
+    assertTrue(found[0], found[0].contains("/home"))
+  }
+
+  @Test
+  fun `gridWrap in a grid is live`() {
+    val style = sectionStyle(gridWrap = false, display = StyleDisplay.GRID)
+    assertTrue(findings(listOf(section(style = style))).isEmpty())
+  }
+
+  @Test
+  fun `a section inherits the page's grid display`() {
+    // `display` resolves by scope override, so the page's grid makes the section's `gridWrap` live
+    // without the section restating it.
+    val found =
+      findings(
+        listOf(section(style = sectionStyle(gridWrap = false))),
+        page = sectionStyle(display = StyleDisplay.GRID),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `gridTile on a list section is inert`() {
+    val found = findings(listOf(section(style = sectionStyle(gridTile = GridTile.CARD))))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("style.gridTile"))
+    assertTrue(found[0], found[0].contains("section #1"))
+  }
+
+  // Item properties
+
+  @Test
+  fun `card properties need the card treatment`() {
+    val plainGrid =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        cardTint = "#1e3a8a",
+        cardImage = CardImage.BACKGROUND,
+      )
+    val found = findings(listOf(section(style = plainGrid, title = "Featured")))
+    assertEquals(2, found.size)
+    assertTrue(found.any { it.contains("style.cardTint") })
+    assertTrue(found.any { it.contains("style.cardImage") })
+    assertTrue(found.all { it.contains("display 'grid', gridTile 'plain'") })
+  }
+
+  @Test
+  fun `card properties in a card grid are live`() {
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        cardTint = "#1e3a8a",
+        cardImage = CardImage.BACKGROUND,
+      )
+    assertTrue(findings(listOf(section(style = cards))).isEmpty())
+  }
+
+  @Test
+  fun `imageShape needs a shaped tile`() {
+    val list = sectionStyle(imageShape = ImageShape.CIRCULAR)
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        imageShape = ImageShape.CIRCULAR,
+      )
+    val condensed =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CONDENSED,
+        imageShape = ImageShape.CIRCULAR,
+      )
+    assertEquals(1, findings(listOf(section(style = list))).size)
+    assertEquals(1, findings(listOf(section(style = cards))).size)
+    // Plain and condensed tiles both take a shape.
+    assertTrue(findings(listOf(section(style = condensed))).isEmpty())
+  }
+
+  @Test
+  fun `accessorySymbol is inert only on cards`() {
+    val rows = sectionStyle(accessorySymbol = "lock.fill")
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        accessorySymbol = "lock.fill",
+      )
+    // List rows draw accessories; card elements have no slot for one.
+    assertTrue(findings(listOf(section(style = rows))).isEmpty())
+    val found = findings(listOf(section(style = cards)))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("no accessory slot"))
+  }
+
+  @Test
+  fun `artworkRendering is never inert`() {
+    val stencilled =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        artworkRendering = ArtworkRendering.STENCIL,
+      )
+    assertTrue(findings(listOf(section(style = stencilled))).isEmpty())
+  }
+
+  // Track-level declarations
+
+  @Test
+  fun `track declarations are reported per section`() {
+    val results =
+      section(
+        style = sectionStyle(display = StyleDisplay.GRID),
+        title = "Results",
+        children =
+          arrayOf(
+            track(style = trackStyle(cardTint = "#111")),
+            track(src = "https://s/b.mp3", style = trackStyle(cardTint = "#222")),
+            track(src = "https://s/c.mp3"),
+          ),
+      )
+    val found = findings(listOf(results))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("2 tracks in section 'Results'"))
+    assertTrue(found[0], found[0].contains("style.cardTint"))
+  }
+
+  @Test
+  fun `a track's own shape is live in a plain grid`() {
+    val grid =
+      section(
+        style = sectionStyle(display = StyleDisplay.GRID),
+        children = arrayOf(track(style = trackStyle(imageShape = ImageShape.CIRCULAR))),
+      )
+    assertTrue(findings(listOf(grid)).isEmpty())
+  }
+
+  // The page block
+
+  @Test
+  fun `a page declaration live in one section is not reported`() {
+    // Card tint reaches both sections; one renders cards. Live is live.
+    val found =
+      findings(
+        listOf(
+          section(style = sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD)),
+          section(style = sectionStyle(display = StyleDisplay.GRID)),
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `a page declaration no section renders is reported once`() {
+    val found =
+      findings(
+        listOf(
+          section(style = sectionStyle(display = StyleDisplay.GRID), title = "A"),
+          section(title = "B"),
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("the page block"))
+    assertTrue(found[0], found[0].contains("no section that inherits it"))
+  }
+
+  @Test
+  fun `a section override shadows the page value`() {
+    // 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.
+    val found =
+      findings(
+        listOf(
+          section(
+            style =
+              sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD, cardTint = "#000")
+          )
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `a page-wide grid makes section declarations live`() {
+    val found =
+      findings(
+        listOf(section(style = sectionStyle(cardTint = "#111"))),
+        page = sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  // The positional `display`
+
+  @Test
+  fun `display on a playable track is inert`() {
+    val tracks =
+      section(
+        title = "Tracks",
+        children =
+          arrayOf(
+            track(style = trackStyle(display = StyleDisplay.GRID)),
+            browseTrack(style = trackStyle(display = StyleDisplay.GRID)),
+          ),
+      )
+    val found = findings(listOf(tracks))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("1 track in section 'Tracks'"))
+    assertTrue(found[0], found[0].contains("style.display"))
+    assertTrue(found[0], found[0].contains("opens none"))
+  }
+
+  @Test
+  fun `display on a section or page is never inert`() {
+    val found =
+      findings(
+        listOf(
+          section(
+            style = sectionStyle(display = StyleDisplay.LIST),
+            children = arrayOf(browseTrack()),
+          )
+        ),
+        page = sectionStyle(display = StyleDisplay.GRID),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `an unstyled page is silent`() {
+    assertTrue(findings(listOf(section(children = arrayOf(track(), browseTrack())))).isEmpty())
+    assertTrue(findings(emptyList()).isEmpty())
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/JsonStyleTest.kt

@@ -1,6 +1,9 @@
 package com.audiobrowser.browser
 
 import com.margelo.nitro.audiobrowser.ArtworkRendering
+import com.margelo.nitro.audiobrowser.CardImage
+import com.margelo.nitro.audiobrowser.GridTile
+import com.margelo.nitro.audiobrowser.ImageShape
 import com.margelo.nitro.audiobrowser.StyleDisplay
 import kotlinx.serialization.json.Json
 import org.junit.Assert.assertEquals
@@ -88,4 +91,57 @@ class JsonStyleTest {
     val track = json.decodeFromString<JsonTrack>("""{"title":"X","src":"s","disabled":true}""")
     assertEquals(true, track.toNitro().disabled)
   }
+
+  @Test
+  fun `decodes imageShape and accessorySymbol`() {
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"imageShape":"circular","accessorySymbol":"lock.fill"}}"""
+      )
+    val style = track.toNitro().style
+    assertEquals(ImageShape.CIRCULAR, style?.imageShape)
+    assertEquals("lock.fill", style?.accessorySymbol)
+  }
+
+  @Test
+  fun `accessorySymbol 'none' is a value - not emptiness`() {
+    // The inheritance-escape sentinel must survive the wire — collapsing it
+    // to "no declaration" would let the section value flow back in.
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","style":{"accessorySymbol":"none"}}""")
+    assertEquals("none", track.toNitro().style?.accessorySymbol)
+  }
+
+  @Test
+  fun `unknown imageShape decodes as no declaration`() {
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","style":{"imageShape":"hexagonal"}}""")
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `decodes the card family`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridTile":"card","cardTint":"#1e3a8a","cardImage":"background"},
+           "children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(GridTile.CARD, style?.gridTile)
+    assertEquals("#1e3a8a", style?.cardTint)
+    assertEquals(CardImage.BACKGROUND, style?.cardImage)
+  }
+
+  @Test
+  fun `unknown gridTile decodes as no declaration`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"gridTile":"hexagon"},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    assertNull(resolved.toNitro().sections?.first()?.style)
+  }
 }

package/android/src/test/java/com/audiobrowser/browser/SectionScopeTest.kt

@@ -2,8 +2,8 @@ package com.audiobrowser.browser
 
 import com.audiobrowser.TestFixtures.resolvedTrack
 import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.sectionStyle
 import com.audiobrowser.TestFixtures.track
-import com.margelo.nitro.audiobrowser.SectionStyle
 import com.margelo.nitro.audiobrowser.StyleDisplay
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
@@ -138,7 +138,7 @@ class SectionScopeTest {
     val page =
       resolvedTrack(
         style =
-          SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = false),
+          sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = false),
         sections = arrayOf(section(children = arrayOf(track(src = "a")))),
       )
 
@@ -153,12 +153,12 @@ class SectionScopeTest {
   fun `a section's own block overrides the page's in the fold`() {
     val page =
       resolvedTrack(
-        style = SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
+        style = sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
         sections =
           arrayOf(
             section(
               style =
-                SectionStyle(display = StyleDisplay.LIST, artworkRendering = null, gridWrap = null),
+                sectionStyle(display = StyleDisplay.LIST, artworkRendering = null, gridWrap = null),
               children = arrayOf(track(src = "a")),
             )
           ),

package/android/src/test/java/com/audiobrowser/browser/StyleResolverTest.kt

@@ -1,9 +1,12 @@
 package com.audiobrowser.browser
 
+import com.audiobrowser.TestFixtures.sectionStyle
+import com.audiobrowser.TestFixtures.trackStyle
 import com.margelo.nitro.audiobrowser.ArtworkRendering
-import com.margelo.nitro.audiobrowser.SectionStyle
+import com.margelo.nitro.audiobrowser.CardImage
+import com.margelo.nitro.audiobrowser.GridTile
+import com.margelo.nitro.audiobrowser.ImageShape
 import com.margelo.nitro.audiobrowser.StyleDisplay
-import com.margelo.nitro.audiobrowser.TrackStyle
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
@@ -20,9 +23,9 @@ class StyleResolverTest {
     val resolved =
       StyleResolver.sectionStyle(
         section =
-          SectionStyle(display = StyleDisplay.LIST, artworkRendering = null, gridWrap = null),
+          sectionStyle(display = StyleDisplay.LIST, artworkRendering = null, gridWrap = null),
         page =
-          SectionStyle(
+          sectionStyle(
             display = StyleDisplay.GRID,
             artworkRendering = ArtworkRendering.STENCIL,
             gridWrap = false,
@@ -39,7 +42,7 @@ class StyleResolverTest {
     val resolved =
       StyleResolver.sectionStyle(
         section = null,
-        page = SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = true),
+        page = sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = true),
       )
     assertEquals(StyleDisplay.GRID, resolved.display)
     assertEquals(true, resolved.gridWrap)
@@ -49,9 +52,9 @@ class StyleResolverTest {
   fun `track overrides the section per property`() {
     val resolved =
       StyleResolver.trackStyle(
-        track = TrackStyle(display = null, artworkRendering = ArtworkRendering.ORIGINAL),
+        track = trackStyle(display = null, artworkRendering = ArtworkRendering.ORIGINAL),
         section =
-          SectionStyle(
+          sectionStyle(
             display = StyleDisplay.GRID,
             artworkRendering = ArtworkRendering.STENCIL,
             gridWrap = null,
@@ -66,7 +69,7 @@ class StyleResolverTest {
       StyleResolver.trackStyle(
         track = null,
         section =
-          SectionStyle(display = null, artworkRendering = ArtworkRendering.STENCIL, gridWrap = null),
+          sectionStyle(display = null, artworkRendering = ArtworkRendering.STENCIL, gridWrap = null),
       )
     assertEquals(ArtworkRendering.STENCIL, resolved.artworkRendering)
   }
@@ -78,10 +81,74 @@ class StyleResolverTest {
     // item's resolved display.
     val resolved =
       StyleResolver.trackStyle(
-        track = TrackStyle(display = StyleDisplay.GRID, artworkRendering = null),
+        track = trackStyle(display = StyleDisplay.GRID, artworkRendering = null),
         section =
-          SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
+          sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
       )
     assertNull(resolved.display)
   }
+
+  @Test
+  fun `imageShape inherits and overrides per item`() {
+    // Section-wide circular (an artists shelf); one album overrides.
+    val inherited =
+      StyleResolver.trackStyle(
+        track = null,
+        section = sectionStyle(imageShape = ImageShape.CIRCULAR),
+      )
+    assertEquals(ImageShape.CIRCULAR, inherited.imageShape)
+    val overridden =
+      StyleResolver.trackStyle(
+        track = trackStyle(imageShape = ImageShape.ROUNDED_RECTANGLE),
+        section = sectionStyle(imageShape = ImageShape.CIRCULAR),
+      )
+    assertEquals(ImageShape.ROUNDED_RECTANGLE, overridden.imageShape)
+  }
+
+  @Test
+  fun `accessorySymbol inherits and 'none' resolves as a value`() {
+    val inherited =
+      StyleResolver.trackStyle(track = null, section = sectionStyle(accessorySymbol = "lock.fill"))
+    assertEquals("lock.fill", inherited.accessorySymbol)
+    // 'none' is the inheritance escape — it must survive resolution intact
+    // (the renderer, not the resolver, maps it to "no accessory").
+    val escaped =
+      StyleResolver.trackStyle(
+        track = trackStyle(accessorySymbol = "none"),
+        section = sectionStyle(accessorySymbol = "lock.fill"),
+      )
+    assertEquals("none", escaped.accessorySymbol)
+  }
+
+  @Test
+  fun `gridTile resolves by scope override`() {
+    // A page-wide card treatment; one section opts back to plain tiles.
+    val inherited =
+      StyleResolver.sectionStyle(section = null, page = sectionStyle(gridTile = GridTile.CARD))
+    assertEquals(GridTile.CARD, inherited.gridTile)
+    val overridden =
+      StyleResolver.sectionStyle(
+        section = sectionStyle(gridTile = GridTile.PLAIN),
+        page = sectionStyle(gridTile = GridTile.CARD),
+      )
+    assertEquals(GridTile.PLAIN, overridden.gridTile)
+  }
+
+  @Test
+  fun `card properties inherit and override per item`() {
+    val inherited =
+      StyleResolver.trackStyle(
+        track = null,
+        section = sectionStyle(cardTint = "#1e3a8a", cardImage = CardImage.BACKGROUND),
+      )
+    assertEquals("#1e3a8a", inherited.cardTint)
+    assertEquals(CardImage.BACKGROUND, inherited.cardImage)
+    val overridden =
+      StyleResolver.trackStyle(
+        track = trackStyle(cardImage = CardImage.NORMAL),
+        section = sectionStyle(cardTint = "#1e3a8a", cardImage = CardImage.BACKGROUND),
+      )
+    assertEquals(CardImage.NORMAL, overridden.cardImage)
+    assertEquals("#1e3a8a", overridden.cardTint)
+  }
 }

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

@@ -1,9 +1,9 @@
 package com.audiobrowser.player
 
 import com.audiobrowser.TestFixtures
+import com.audiobrowser.TestFixtures.trackStyle
 import com.margelo.nitro.audiobrowser.ArtworkRendering
 import com.margelo.nitro.audiobrowser.StyleDisplay
-import com.margelo.nitro.audiobrowser.TrackStyle
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
@@ -25,7 +25,7 @@ class PlaybackStateStoreTrackJsonTest {
       TestFixtures.track(title = "Night Mix", src = "https://s/a.mp3", disabled = true)
         .copy(
           style =
-            TrackStyle(display = StyleDisplay.GRID, artworkRendering = ArtworkRendering.STENCIL)
+            trackStyle(display = StyleDisplay.GRID, artworkRendering = ArtworkRendering.STENCIL)
         )
 
     val restored = PlaybackStateStore.trackFromJson(PlaybackStateStore.trackToJson(track))

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

@@ -0,0 +1,79 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Media3's `ShuffleOrder.cloneAndSet(insertionCount, startIndex)` discards the start index (the
+ * interface default clears and re-inserts from 0, and `DefaultShuffleOrder` does not override it),
+ * so `setMediaItems(items, startIndex, …)` leaves the starting track at a random shuffle position —
+ * last, for a 1-in-N share of queues, which reads as end-of-queue from the very first track.
+ */
+class ShuffleOrderLedByTest {
+  @Test
+  fun `the start index leads the order`() {
+    for (start in 0 until 6) {
+      val order = shuffleOrderLedBy(startIndex = start, count = 6)
+      assertEquals("start index must be at shuffle position 0", start, order.firstIndex)
+      assertNotEquals(
+        "a queue of 6 must have somewhere to advance to from its start track",
+        C.INDEX_UNSET.toLong(),
+        order.getNextIndex(start).toLong(),
+      )
+    }
+  }
+
+  @Test
+  fun `every index appears exactly once`() {
+    val order = shuffleOrderLedBy(startIndex = 3, count = 8)
+    assertEquals(8, order.length)
+    val seen = mutableListOf<Int>()
+    var index = order.firstIndex
+    while (index != C.INDEX_UNSET) {
+      seen.add(index)
+      index = order.getNextIndex(index)
+    }
+    assertEquals((0 until 8).toList(), seen.sorted())
+  }
+
+  @Test
+  fun `a single-track queue leads with its only track and ends there`() {
+    val order = shuffleOrderLedBy(startIndex = 0, count = 1)
+    assertEquals(0, order.firstIndex)
+    assertEquals(C.INDEX_UNSET, order.getNextIndex(0))
+  }
+
+  @Test
+  fun `an out-of-range start index is clamped rather than throwing`() {
+    assertEquals(4, shuffleOrderLedBy(startIndex = 99, count = 5).firstIndex)
+    assertEquals(0, shuffleOrderLedBy(startIndex = -3, count = 5).firstIndex)
+  }
+
+  @Test
+  fun `an empty queue produces an empty order`() {
+    assertEquals(0, shuffleOrderLedBy(startIndex = 0, count = 0).length)
+  }
+
+  @Test
+  fun `the tail is actually shuffled`() {
+    // Not a strict guarantee of any single draw — but across many draws an
+    // unshuffled tail would be impossible to miss.
+    val tails =
+      (0 until 50)
+        .map { shuffleOrderLedBy(startIndex = 0, count = 8) }
+        .map { order ->
+          buildList {
+            var index = order.getNextIndex(order.firstIndex)
+            while (index != C.INDEX_UNSET) {
+              add(index)
+              index = order.getNextIndex(index)
+            }
+          }
+        }
+        .toSet()
+    assertTrue("50 draws produced one identical tail — the order is not shuffled", tails.size > 1)
+  }
+}

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

@@ -2,10 +2,10 @@ package com.audiobrowser.util
 
 import androidx.media.utils.MediaConstants
 import com.audiobrowser.TestFixtures
+import com.audiobrowser.TestFixtures.sectionStyle
+import com.audiobrowser.TestFixtures.trackStyle
 import com.audiobrowser.browser.styleResolvedSections
-import com.margelo.nitro.audiobrowser.SectionStyle
 import com.margelo.nitro.audiobrowser.StyleDisplay
-import com.margelo.nitro.audiobrowser.TrackStyle
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Test
@@ -23,7 +23,7 @@ class MediaExtrasBuilderTest {
   private val track = TestFixtures.track()
 
   private fun sectionStyle(display: StyleDisplay?) =
-    SectionStyle(display = display, artworkRendering = null, gridWrap = null)
+    sectionStyle(display = display, artworkRendering = null, gridWrap = null)
 
   @Test
   fun `owning section title stamps the group-title hint`() {
@@ -65,7 +65,7 @@ class MediaExtrasBuilderTest {
   @Test
   fun `a track's own display never sets its item hint - display is positional`() {
     val gridPromiseTrack =
-      track.copy(style = TrackStyle(display = StyleDisplay.GRID, artworkRendering = null))
+      track.copy(style = trackStyle(display = StyleDisplay.GRID, artworkRendering = null))
     val section = TestFixtures.section(arrayOf(gridPromiseTrack), style = null)
     val extras = MediaExtrasBuilder.build(gridPromiseTrack, section)
     assertFalse(extras.containsKey(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_SINGLE_ITEM))
@@ -75,7 +75,7 @@ class MediaExtrasBuilderTest {
   fun `a browsable track's declared display emits the parent-level promise`() {
     val handle =
       TestFixtures.browseTrack()
-        .copy(style = TrackStyle(display = StyleDisplay.GRID, artworkRendering = null))
+        .copy(style = trackStyle(display = StyleDisplay.GRID, artworkRendering = null))
     val extras = MediaExtrasBuilder.build(handle)
     val expected = MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM
     assertEquals(
@@ -99,7 +99,7 @@ class MediaExtrasBuilderTest {
   @Test
   fun `a playable track's display is inert - playables open no page`() {
     val playable =
-      track.copy(style = TrackStyle(display = StyleDisplay.GRID, artworkRendering = null))
+      track.copy(style = trackStyle(display = StyleDisplay.GRID, artworkRendering = null))
     val extras = MediaExtrasBuilder.build(playable)
     assertFalse(extras.containsKey(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_BROWSABLE))
     assertFalse(extras.containsKey(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_PLAYABLE))
@@ -128,10 +128,11 @@ class MediaExtrasBuilderTest {
         arrayOf(track),
         title = "Popular",
         path = "/popular",
-        style = SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = false),
+        style = sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = false),
       )
-    val navigation = TrackFactory.navigationTrack(section)
+    val navigation = TrackFactory.navigationTrack(section, "View more")
     assertEquals(StyleDisplay.GRID, navigation.style?.display)
+    assertEquals("View more", navigation.title)
 
     val extras = MediaExtrasBuilder.build(navigation)
     assertEquals(
@@ -147,7 +148,7 @@ class MediaExtrasBuilderTest {
     // narrower unit test stays green while the page tier goes dark.
     val page =
       TestFixtures.resolvedTrack(
-        style = SectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
+        style = sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
         sections = arrayOf(TestFixtures.section(arrayOf(track))),
       )