Adapt tile collector test

Author: p-lr

Readme.md

@@ -75,7 +75,7 @@ There's an example in the demo app.
 
 Add this to your module's build.gradle
 ```groovy
-implementation 'ovh.plrapps:mapcompose:2.16.1'
+implementation 'ovh.plrapps:mapcompose:2.16.2'
 ```
 
 Starting with v.2.4.1, the library is using the 

mapcompose/src/test/java/ovh/plrapps/mapcompose/core/TileCollectorTest.kt

@@ -3,11 +3,16 @@ package ovh.plrapps.mapcompose.core
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.os.Build
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -17,7 +22,6 @@ import java.io.FileInputStream
 
 /**
  * Test the [TileCollector.collectTiles] engine. The following assertions are tested:
- * * The Bitmap flow should pick a [Bitmap] from the pool if possible
  * * If [TileSpec]s are send to the input channel, corresponding [Tile]s are received from the
  * output channel (from the [TileCollector.collectTiles] point of view).
  * * The [Bitmap] of the [Tile]s produced should be consistent with the output of the flow
@@ -42,7 +46,6 @@ class TileCollectorTest {
         }
     }
 
-    @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     fun fullTest() = runTest {
         assertNotNull(assetsDir)
@@ -53,73 +56,66 @@ class TileCollectorTest {
         val visibleTileLocationsChannel = Channel<TileSpec>(capacity = Channel.RENDEZVOUS)
         val tilesOutput = Channel<Tile>(capacity = Channel.RENDEZVOUS)
 
-        val pool = BitmapPool(Dispatchers.Default.limitedParallelism(1))
-
         val tileStreamProvider = TileStreamProvider { _, _, _ -> FileInputStream(imageFile) }
 
         val bitmapReference = try {
             val inputStream = FileInputStream(imageFile)
-            val bitmapLoadingOptions = BitmapFactory.Options().apply {
-                inPreferredConfig = Bitmap.Config.RGB_565
-            }
-            BitmapFactory.decodeStream(inputStream, null, bitmapLoadingOptions)
+            BitmapFactory.decodeStream(inputStream, null, null)
         } catch (e: Exception) {
             fail()
             error("Could not decode image")
         }
 
+
+        val layers = listOf(
+            Layer("default", tileStreamProvider)
+        )
+
+        /* Start collecting tiles */
+        val tileCollector = TileCollector(1, optimizeForLowEndDevices = false, tileSize)
+        val tileCollectorJob = launch {
+            tileCollector.collectTiles(visibleTileLocationsChannel, tilesOutput, layers)
+        }
+
         fun CoroutineScope.consumeTiles(tileChannel: ReceiveChannel<Tile>) = launch {
+            var receivedTiles = 0
             for (tile in tileChannel) {
                 println("received tile ${tile.zoom}-${tile.row}-${tile.col}")
-                val bitmap = tile.bitmap
                 assertTrue(tile.bitmap?.sameAs(bitmapReference) ?: false)
+                receivedTiles += 1
 
-                /* Add bitmap to the pool only if they are from level 0 */
-                if (tile.zoom == 0) {
-                    if (bitmap != null) {
-                        pool.put(bitmap)
-                    }
+                if (tile.zoom == 6 && tile.row == 6 && tile.col == 6) {
+                    println("received poison pill")
+                    assertEquals(7, receivedTiles)
+                    cancel()
+                    tileCollectorJob.cancel()
                 }
             }
         }
 
-        val layers = listOf(
-            Layer("default", tileStreamProvider)
-        )
-
         /* Start consuming tiles */
-        val tileConsumeJob = launch {
-            consumeTiles(tilesOutput)
-        }
-
-        /* Start collecting tiles */
-        val tileCollector = TileCollector(1, BitmapConfiguration(Bitmap.Config.RGB_565, 2), tileSize)
-        val tileCollectorJob = launch {
-            tileCollector.collectTiles(visibleTileLocationsChannel, tilesOutput, layers, pool)
-        }
+        consumeTiles(tilesOutput)
 
         launch {
             val locations1 = listOf(
-                    TileSpec(0, 0, 0),
-                    TileSpec(0, 1, 1),
-                    TileSpec(0, 2, 1)
+                TileSpec(0, 0, 0),
+                TileSpec(0, 1, 1),
+                TileSpec(0, 2, 1)
             )
             for (spec in locations1) {
                 visibleTileLocationsChannel.send(spec)
             }
 
             val locations2 = listOf(
-                    TileSpec(1, 0, 0),
-                    TileSpec(1, 1, 1),
-                    TileSpec(1, 2, 1)
+                TileSpec(1, 0, 0),
+                TileSpec(1, 1, 1),
+                TileSpec(1, 2, 1),
+                TileSpec(6, 6, 6),  // poison pill
             )
-            /* Bitmaps inside the pool should be used */
+
             for (spec in locations2) {
                 visibleTileLocationsChannel.send(spec)
             }
-
-            tileCollectorJob.cancel()
-            tileConsumeJob.cancel()
         }
         Unit
     }