diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/IndicatorLocationLayerRendererTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/IndicatorLocationLayerRendererTest.kt index 210a8b834..0ab7b8e98 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/IndicatorLocationLayerRendererTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/IndicatorLocationLayerRendererTest.kt @@ -18,310 +18,310 @@ import org.junit.Test class IndicatorLocationLayerRendererTest { - private val style: Style = mockk(relaxUnitFun = true) - private val layerSourceProvider: LayerSourceProvider = mockk(relaxUnitFun = true) - private val layer: Layer = mockk(relaxUnitFun = true) + private val style: Style = mockk(relaxUnitFun = true) + private val layerSourceProvider: LayerSourceProvider = mockk(relaxUnitFun = true) + private val layer: Layer = mockk(relaxUnitFun = true) - private lateinit var locationLayerRenderer: IndicatorLocationLayerRenderer + private lateinit var locationLayerRenderer: IndicatorLocationLayerRenderer - @Before - fun setup() { - every { style.removeLayer(any()) } returns true - locationLayerRenderer = IndicatorLocationLayerRenderer(layerSourceProvider) - every { layerSourceProvider.generateLocationComponentLayer() } returns layer - locationLayerRenderer.initializeComponents(style) - } - - @Test - fun sanity() { - Assert.assertNotNull(locationLayerRenderer) - } - - @Test - fun initializeComponents_withLocation() { - val newLayer: Layer = mockk(relaxUnitFun = true) - every { layerSourceProvider.generateLocationComponentLayer() } returns newLayer - val latLng = LatLng(10.0, 20.0) - val bearing = 11f - val accuracy = 65f - locationLayerRenderer.setLatLng(latLng) - locationLayerRenderer.setGpsBearing(bearing) - locationLayerRenderer.setAccuracyRadius(accuracy) - - locationLayerRenderer.initializeComponents(mockk()) - - verify { newLayer.setProperties(LocationPropertyFactory.location(latLng.toLocationArray())) } - verify { newLayer.setProperties(LocationPropertyFactory.bearing(bearing.toDouble())) } - verify { newLayer.setProperties(LocationPropertyFactory.accuracyRadius(accuracy)) } - } - - @Test - fun addLayers() { - val positionManager: LocationComponentPositionManager = mockk(relaxUnitFun = true) - - locationLayerRenderer.addLayers(positionManager) - - verify { positionManager.addLayerToMap(layer) } - } - - @Test - fun removeLayers() { - locationLayerRenderer.removeLayers() - - verify { style.removeLayer(layer) } - } - - @Test - fun hide() { - locationLayerRenderer.hide() - - verify { layer.setProperties(LocationPropertyFactory.visibility(Property.NONE)) } - } - - @Test - fun show() { - locationLayerRenderer.show(RenderMode.NORMAL, false) - - verify { layer.setProperties(LocationPropertyFactory.visibility(Property.VISIBLE)) } - } - - @Test - fun show_normal_notStale() { - locationLayerRenderer.show(RenderMode.NORMAL, false) - - verify { - layer.setProperties( - LocationPropertyFactory.topImage(FOREGROUND_ICON), - LocationPropertyFactory.bearingImage(BACKGROUND_ICON), - LocationPropertyFactory.shadowImage(SHADOW_ICON) - ) + @Before + fun setup() { + every { style.removeLayer(any()) } returns true + locationLayerRenderer = IndicatorLocationLayerRenderer(layerSourceProvider) + every { layerSourceProvider.generateLocationComponentLayer() } returns layer + locationLayerRenderer.initializeComponents(style) } - } - @Test - fun show_compass_notStale() { - locationLayerRenderer.show(RenderMode.COMPASS, false) - - verify { - layer.setProperties( - LocationPropertyFactory.topImage(FOREGROUND_ICON), - LocationPropertyFactory.bearingImage(BEARING_ICON), - LocationPropertyFactory.shadowImage(SHADOW_ICON) - ) + @Test + fun sanity() { + Assert.assertNotNull(locationLayerRenderer) } - } - @Test - fun show_gps_notStale() { - locationLayerRenderer.show(RenderMode.GPS, false) + @Test + fun initializeComponents_withLocation() { + val newLayer: Layer = mockk(relaxUnitFun = true) + every { layerSourceProvider.generateLocationComponentLayer() } returns newLayer + val latLng = LatLng(10.0, 20.0) + val bearing = 11f + val accuracy = 65f + locationLayerRenderer.setLatLng(latLng) + locationLayerRenderer.setGpsBearing(bearing) + locationLayerRenderer.setAccuracyRadius(accuracy) - verify { - layer.setProperties( - LocationPropertyFactory.topImage(""), - LocationPropertyFactory.bearingImage(FOREGROUND_ICON), - LocationPropertyFactory.shadowImage(BACKGROUND_ICON) - ) + locationLayerRenderer.initializeComponents(mockk()) + + verify { newLayer.setProperties(LocationPropertyFactory.location(latLng.toLocationArray())) } + verify { newLayer.setProperties(LocationPropertyFactory.bearing(bearing.toDouble())) } + verify { newLayer.setProperties(LocationPropertyFactory.accuracyRadius(accuracy)) } } - verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(0f)) } - } - @Test - fun show_normal_stale() { - locationLayerRenderer.show(RenderMode.NORMAL, true) + @Test + fun addLayers() { + val positionManager: LocationComponentPositionManager = mockk(relaxUnitFun = true) - verify { - layer.setProperties( - LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), - LocationPropertyFactory.bearingImage(BACKGROUND_STALE_ICON), - LocationPropertyFactory.shadowImage(SHADOW_ICON) - ) + locationLayerRenderer.addLayers(positionManager) + + verify { positionManager.addLayerToMap(layer) } } - } - @Test - fun show_compass_stale() { - locationLayerRenderer.show(RenderMode.COMPASS, true) + @Test + fun removeLayers() { + locationLayerRenderer.removeLayers() - verify { - layer.setProperties( - LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), - LocationPropertyFactory.bearingImage(BEARING_STALE_ICON), - LocationPropertyFactory.shadowImage(SHADOW_ICON) - ) + verify { style.removeLayer(layer) } } - } - @Test - fun show_gps_stale() { - locationLayerRenderer.show(RenderMode.GPS, true) + @Test + fun hide() { + locationLayerRenderer.hide() - verify { - layer.setProperties( - LocationPropertyFactory.topImage(""), - LocationPropertyFactory.bearingImage(FOREGROUND_STALE_ICON), - LocationPropertyFactory.shadowImage(BACKGROUND_STALE_ICON) - ) + verify { layer.setProperties(LocationPropertyFactory.visibility(Property.NONE)) } } - verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(0f)) } - } - @Test - fun styleAccuracy() { - val colorArray = ColorUtils.colorToRgbaArray(Color.RED) - val exp = Expression.rgba(colorArray[0], colorArray[1], colorArray[2], 0.7f) + @Test + fun show() { + locationLayerRenderer.show(RenderMode.NORMAL, false) - locationLayerRenderer.styleAccuracy(0.7f, Color.RED) - - verify { - layer.setProperties( - LocationPropertyFactory.accuracyRadiusColor(exp), - LocationPropertyFactory.accuracyRadiusBorderColor(exp) - ) + verify { layer.setProperties(LocationPropertyFactory.visibility(Property.VISIBLE)) } } - } - @Test - fun setLatLng() { - val latLng = LatLng(10.0, 20.0) - locationLayerRenderer.setLatLng(latLng) + @Test + fun show_normal_notStale() { + locationLayerRenderer.show(RenderMode.NORMAL, false) - verify { layer.setProperties(LocationPropertyFactory.location(latLng.toLocationArray())) } - } - - @Test - fun setGpsBearing() { - val bearing = 30.0 - locationLayerRenderer.setGpsBearing(bearing.toFloat()) - - verify { layer.setProperties(LocationPropertyFactory.bearing(bearing)) } - } - - @Test - fun setCompassBearing() { - val bearing = 30.0 - locationLayerRenderer.setCompassBearing(bearing.toFloat()) - - verify { layer.setProperties(LocationPropertyFactory.bearing(bearing)) } - } - - @Test - fun setAccuracyRadius() { - val radius = 40f - locationLayerRenderer.setAccuracyRadius(radius) - - verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(radius)) } - } - - @Test - fun styleScaling() { - val exp = Expression.literal("") - locationLayerRenderer.styleScaling(exp) - - verify { - layer.setProperties( - LocationPropertyFactory.shadowImageSize(exp), - LocationPropertyFactory.bearingImageSize(exp), - LocationPropertyFactory.topImageSize(exp) - ) + verify { + layer.setProperties( + LocationPropertyFactory.topImage(FOREGROUND_ICON), + LocationPropertyFactory.bearingImage(BACKGROUND_ICON), + LocationPropertyFactory.shadowImage(SHADOW_ICON) + ) + } } - } - @Test - fun setLocationStale() { - locationLayerRenderer.setLocationStale(true, RenderMode.NORMAL) + @Test + fun show_compass_notStale() { + locationLayerRenderer.show(RenderMode.COMPASS, false) - verify { - layer.setProperties( - LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), - LocationPropertyFactory.bearingImage(BACKGROUND_STALE_ICON), - LocationPropertyFactory.shadowImage(SHADOW_ICON) - ) + verify { + layer.setProperties( + LocationPropertyFactory.topImage(FOREGROUND_ICON), + LocationPropertyFactory.bearingImage(BEARING_ICON), + LocationPropertyFactory.shadowImage(SHADOW_ICON) + ) + } } - } - @Test - fun addBitmaps_shadow() { - addBitmaps(withShadow = true, renderMode = RenderMode.NORMAL) + @Test + fun show_gps_notStale() { + locationLayerRenderer.show(RenderMode.GPS, false) - verify { style.addImage(SHADOW_ICON, shadowBitmap) } - } + verify { + layer.setProperties( + LocationPropertyFactory.topImage(""), + LocationPropertyFactory.bearingImage(FOREGROUND_ICON), + LocationPropertyFactory.shadowImage(BACKGROUND_ICON) + ) + } + verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(0f)) } + } - @Test - fun addBitmaps_noShadow() { - addBitmaps(withShadow = false, renderMode = RenderMode.NORMAL) + @Test + fun show_normal_stale() { + locationLayerRenderer.show(RenderMode.NORMAL, true) - verify { style.removeImage(SHADOW_ICON) } - } + verify { + layer.setProperties( + LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), + LocationPropertyFactory.bearingImage(BACKGROUND_STALE_ICON), + LocationPropertyFactory.shadowImage(SHADOW_ICON) + ) + } + } - @Test - fun addBitmaps_normal() { - addBitmaps(withShadow = true, renderMode = RenderMode.NORMAL) + @Test + fun show_compass_stale() { + locationLayerRenderer.show(RenderMode.COMPASS, true) - verify { style.addImage(FOREGROUND_ICON, foregroundBitmap) } - verify { style.addImage(FOREGROUND_STALE_ICON, foregroundStaleBitmap) } - verify { style.addImage(BACKGROUND_ICON, backgroundBitmap) } - verify { style.addImage(BACKGROUND_STALE_ICON, backgroundStaleBitmap) } - verify { style.addImage(BEARING_ICON, bearingBitmap) } - } + verify { + layer.setProperties( + LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), + LocationPropertyFactory.bearingImage(BEARING_STALE_ICON), + LocationPropertyFactory.shadowImage(SHADOW_ICON) + ) + } + } - @Test - fun addBitmaps_compass() { - every { bearingBitmap.width } returns 40 - every { bearingBitmap.height } returns 40 - every { bearingBitmap.config } returns mockk() - every { backgroundBitmap.width } returns 20 - every { backgroundBitmap.height } returns 10 + @Test + fun show_gps_stale() { + locationLayerRenderer.show(RenderMode.GPS, true) - val mergedBitmap = mockk() - mockkStatic(BitmapUtils::class) - every { BitmapUtils.mergeBitmap(bearingBitmap, backgroundBitmap, 10f, 15f) } returns mergedBitmap + verify { + layer.setProperties( + LocationPropertyFactory.topImage(""), + LocationPropertyFactory.bearingImage(FOREGROUND_STALE_ICON), + LocationPropertyFactory.shadowImage(BACKGROUND_STALE_ICON) + ) + } + verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(0f)) } + } - every { bearingBitmap.width } returns 40 - every { bearingBitmap.height } returns 40 - every { bearingBitmap.config } returns mockk() - every { backgroundStaleBitmap.width } returns 30 - every { backgroundStaleBitmap.height } returns 10 + @Test + fun styleAccuracy() { + val colorArray = ColorUtils.colorToRgbaArray(Color.RED) + val exp = Expression.rgba(colorArray[0], colorArray[1], colorArray[2], 0.7f) - val mergedStaleBitmap = mockk() - every { BitmapUtils.mergeBitmap(bearingBitmap, backgroundStaleBitmap, 5f, 15f) } returns mergedStaleBitmap + locationLayerRenderer.styleAccuracy(0.7f, Color.RED) - addBitmaps(withShadow = true, renderMode = RenderMode.COMPASS) + verify { + layer.setProperties( + LocationPropertyFactory.accuracyRadiusColor(exp), + LocationPropertyFactory.accuracyRadiusBorderColor(exp) + ) + } + } - verify { style.addImage(BEARING_ICON, mergedBitmap) } - verify { style.addImage(BEARING_STALE_ICON, mergedStaleBitmap) } + @Test + fun setLatLng() { + val latLng = LatLng(10.0, 20.0) + locationLayerRenderer.setLatLng(latLng) - unmockkStatic(BitmapUtils::class) - } + verify { layer.setProperties(LocationPropertyFactory.location(latLng.toLocationArray())) } + } - @Test - fun addBitmaps_gps() { - addBitmaps(withShadow = true, renderMode = RenderMode.GPS) + @Test + fun setGpsBearing() { + val bearing = 30.0 + locationLayerRenderer.setGpsBearing(bearing.toFloat()) - verify { style.addImage(FOREGROUND_ICON, foregroundBitmap) } - verify { style.addImage(FOREGROUND_STALE_ICON, foregroundStaleBitmap) } - verify { style.addImage(BACKGROUND_ICON, backgroundBitmap) } - verify { style.addImage(BACKGROUND_STALE_ICON, backgroundStaleBitmap) } - verify { style.addImage(BEARING_ICON, bearingBitmap) } - } + verify { layer.setProperties(LocationPropertyFactory.bearing(bearing)) } + } - private val shadowBitmap = mockk() - private val backgroundBitmap = mockk() - private val backgroundStaleBitmap = mockk() - private val bearingBitmap = mockk() - private val foregroundBitmap = mockk() - private val foregroundStaleBitmap = mockk() + @Test + fun setCompassBearing() { + val bearing = 30.0 + locationLayerRenderer.setCompassBearing(bearing.toFloat()) - private fun addBitmaps(withShadow: Boolean, @RenderMode.Mode renderMode: Int) { - locationLayerRenderer.addBitmaps( - renderMode, - if (withShadow) shadowBitmap else null, - backgroundBitmap, - backgroundStaleBitmap, - bearingBitmap, - foregroundBitmap, - foregroundStaleBitmap - ) - } + verify { layer.setProperties(LocationPropertyFactory.bearing(bearing)) } + } - private fun LatLng.toLocationArray() = arrayOf(latitude, longitude, 0.0) -} \ No newline at end of file + @Test + fun setAccuracyRadius() { + val radius = 40f + locationLayerRenderer.setAccuracyRadius(radius) + + verify { layer.setProperties(LocationPropertyFactory.accuracyRadius(radius)) } + } + + @Test + fun styleScaling() { + val exp = Expression.literal("") + locationLayerRenderer.styleScaling(exp) + + verify { + layer.setProperties( + LocationPropertyFactory.shadowImageSize(exp), + LocationPropertyFactory.bearingImageSize(exp), + LocationPropertyFactory.topImageSize(exp) + ) + } + } + + @Test + fun setLocationStale() { + locationLayerRenderer.setLocationStale(true, RenderMode.NORMAL) + + verify { + layer.setProperties( + LocationPropertyFactory.topImage(FOREGROUND_STALE_ICON), + LocationPropertyFactory.bearingImage(BACKGROUND_STALE_ICON), + LocationPropertyFactory.shadowImage(SHADOW_ICON) + ) + } + } + + @Test + fun addBitmaps_shadow() { + addBitmaps(withShadow = true, renderMode = RenderMode.NORMAL) + + verify { style.addImage(SHADOW_ICON, shadowBitmap) } + } + + @Test + fun addBitmaps_noShadow() { + addBitmaps(withShadow = false, renderMode = RenderMode.NORMAL) + + verify { style.removeImage(SHADOW_ICON) } + } + + @Test + fun addBitmaps_normal() { + addBitmaps(withShadow = true, renderMode = RenderMode.NORMAL) + + verify { style.addImage(FOREGROUND_ICON, foregroundBitmap) } + verify { style.addImage(FOREGROUND_STALE_ICON, foregroundStaleBitmap) } + verify { style.addImage(BACKGROUND_ICON, backgroundBitmap) } + verify { style.addImage(BACKGROUND_STALE_ICON, backgroundStaleBitmap) } + verify { style.addImage(BEARING_ICON, bearingBitmap) } + } + + @Test + fun addBitmaps_compass() { + every { bearingBitmap.width } returns 40 + every { bearingBitmap.height } returns 40 + every { bearingBitmap.config } returns mockk() + every { backgroundBitmap.width } returns 20 + every { backgroundBitmap.height } returns 10 + + val mergedBitmap = mockk() + mockkStatic(BitmapUtils::class) + every { BitmapUtils.mergeBitmap(bearingBitmap, backgroundBitmap, 10f, 15f) } returns mergedBitmap + + every { bearingBitmap.width } returns 40 + every { bearingBitmap.height } returns 40 + every { bearingBitmap.config } returns mockk() + every { backgroundStaleBitmap.width } returns 30 + every { backgroundStaleBitmap.height } returns 10 + + val mergedStaleBitmap = mockk() + every { BitmapUtils.mergeBitmap(bearingBitmap, backgroundStaleBitmap, 5f, 15f) } returns mergedStaleBitmap + + addBitmaps(withShadow = true, renderMode = RenderMode.COMPASS) + + verify { style.addImage(BEARING_ICON, mergedBitmap) } + verify { style.addImage(BEARING_STALE_ICON, mergedStaleBitmap) } + + unmockkStatic(BitmapUtils::class) + } + + @Test + fun addBitmaps_gps() { + addBitmaps(withShadow = true, renderMode = RenderMode.GPS) + + verify { style.addImage(FOREGROUND_ICON, foregroundBitmap) } + verify { style.addImage(FOREGROUND_STALE_ICON, foregroundStaleBitmap) } + verify { style.addImage(BACKGROUND_ICON, backgroundBitmap) } + verify { style.addImage(BACKGROUND_STALE_ICON, backgroundStaleBitmap) } + verify { style.addImage(BEARING_ICON, bearingBitmap) } + } + + private val shadowBitmap = mockk() + private val backgroundBitmap = mockk() + private val backgroundStaleBitmap = mockk() + private val bearingBitmap = mockk() + private val foregroundBitmap = mockk() + private val foregroundStaleBitmap = mockk() + + private fun addBitmaps(withShadow: Boolean, @RenderMode.Mode renderMode: Int) { + locationLayerRenderer.addBitmaps( + renderMode, + if (withShadow) shadowBitmap else null, + backgroundBitmap, + backgroundStaleBitmap, + bearingBitmap, + foregroundBitmap, + foregroundStaleBitmap + ) + } + + private fun LatLng.toLocationArray() = arrayOf(latitude, longitude, 0.0) +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationAnimatorCoordinatorTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationAnimatorCoordinatorTest.kt index e3701d228..9da535b54 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationAnimatorCoordinatorTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationAnimatorCoordinatorTest.kt @@ -24,674 +24,702 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class LocationAnimatorCoordinatorTest { - private lateinit var locationAnimatorCoordinator: LocationAnimatorCoordinator - private val cameraPosition: CameraPosition = CameraPosition.DEFAULT + private lateinit var locationAnimatorCoordinator: LocationAnimatorCoordinator + private val cameraPosition: CameraPosition = CameraPosition.DEFAULT - private val animatorProvider: MapboxAnimatorProvider = mockk() - private val animatorSetProvider: MapboxAnimatorSetProvider = mockk() + private val animatorProvider: MapboxAnimatorProvider = mockk() + private val animatorSetProvider: MapboxAnimatorSetProvider = mockk() - private val projection: Projection = mockk() + private val projection: Projection = mockk() - @Before - fun setUp() { - locationAnimatorCoordinator = LocationAnimatorCoordinator(projection, - animatorSetProvider, - animatorProvider) - configureAnimatorProvider() - every { projection.getMetersPerPixelAtLatitude(any()) } answers { 1.0 } - val startedAnimatorsSlot = slot>() - every { animatorSetProvider.startAnimation(capture(startedAnimatorsSlot), any(), any()) } answers { - startedAnimatorsSlot.captured.forEach { - it.start() - } - } - locationAnimatorCoordinator.updateAnimatorListenerHolders(getListenerHoldersSet( - ANIMATOR_LAYER_LATLNG, - ANIMATOR_CAMERA_LATLNG, - ANIMATOR_LAYER_GPS_BEARING, - ANIMATOR_LAYER_COMPASS_BEARING, - ANIMATOR_CAMERA_GPS_BEARING, - ANIMATOR_CAMERA_COMPASS_BEARING, - ANIMATOR_LAYER_ACCURACY, - ANIMATOR_ZOOM, - ANIMATOR_TILT - )) - } - - private fun configureAnimatorProvider() { - // workaround https://github.com/mockk/mockk/issues/229#issuecomment-457816131 - registerInstanceFactory { AnimationsValueChangeListener {} } - registerInstanceFactory { AnimationsValueChangeListener {} } - val floatsSlot = slot>() - val listenerSlot = slot>() - val maxFpsSlot = slot() - every { - animatorProvider.floatAnimator(capture(floatsSlot), capture(listenerSlot), capture(maxFpsSlot)) - } answers { - MapboxFloatAnimator(floatsSlot.captured, listenerSlot.captured, maxFpsSlot.captured) + @Before + fun setUp() { + locationAnimatorCoordinator = LocationAnimatorCoordinator( + projection, + animatorSetProvider, + animatorProvider + ) + configureAnimatorProvider() + every { projection.getMetersPerPixelAtLatitude(any()) } answers { 1.0 } + val startedAnimatorsSlot = slot>() + every { animatorSetProvider.startAnimation(capture(startedAnimatorsSlot), any(), any()) } answers { + startedAnimatorsSlot.captured.forEach { + it.start() + } + } + locationAnimatorCoordinator.updateAnimatorListenerHolders( + getListenerHoldersSet( + ANIMATOR_LAYER_LATLNG, + ANIMATOR_CAMERA_LATLNG, + ANIMATOR_LAYER_GPS_BEARING, + ANIMATOR_LAYER_COMPASS_BEARING, + ANIMATOR_CAMERA_GPS_BEARING, + ANIMATOR_CAMERA_COMPASS_BEARING, + ANIMATOR_LAYER_ACCURACY, + ANIMATOR_ZOOM, + ANIMATOR_TILT + ) + ) } - val latLngsSlot = slot>() - every { - animatorProvider.latLngAnimator(capture(latLngsSlot), capture(listenerSlot), capture(maxFpsSlot)) - } answers { - MapboxLatLngAnimator(latLngsSlot.captured, listenerSlot.captured, maxFpsSlot.captured) + private fun configureAnimatorProvider() { + // workaround https://github.com/mockk/mockk/issues/229#issuecomment-457816131 + registerInstanceFactory { AnimationsValueChangeListener {} } + registerInstanceFactory { AnimationsValueChangeListener {} } + val floatsSlot = slot>() + val listenerSlot = slot>() + val maxFpsSlot = slot() + every { + animatorProvider.floatAnimator(capture(floatsSlot), capture(listenerSlot), capture(maxFpsSlot)) + } answers { + MapboxFloatAnimator(floatsSlot.captured, listenerSlot.captured, maxFpsSlot.captured) + } + + val latLngsSlot = slot>() + every { + animatorProvider.latLngAnimator(capture(latLngsSlot), capture(listenerSlot), capture(maxFpsSlot)) + } answers { + MapboxLatLngAnimator(latLngsSlot.captured, listenerSlot.captured, maxFpsSlot.captured) + } + + val callback = slot() + every { + animatorProvider.cameraAnimator(capture(floatsSlot), capture(listenerSlot), capture(callback)) + } answers { + MapboxCameraAnimatorAdapter(floatsSlot.captured, listenerSlot.captured, callback.captured) + } + every { + animatorProvider.cameraAnimator(capture(floatsSlot), capture(listenerSlot), null) + } answers { + MapboxCameraAnimatorAdapter(floatsSlot.captured, listenerSlot.captured, null) + } } - val callback = slot() - every { - animatorProvider.cameraAnimator(capture(floatsSlot), capture(listenerSlot), capture(callback)) - } answers { - MapboxCameraAnimatorAdapter(floatsSlot.captured, listenerSlot.captured, callback.captured) - } - every { - animatorProvider.cameraAnimator(capture(floatsSlot), capture(listenerSlot), null) - } answers { - MapboxCameraAnimatorAdapter(floatsSlot.captured, listenerSlot.captured, null) - } - } + @Test + fun feedNewLocation_animatorsAreCreated() { + locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, false) - @Test - fun feedNewLocation_animatorsAreCreated() { - locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, false) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING] != null) - } - - @Test - fun feedNewLocation_animatorValue() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 35f - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng - assertEquals(location.latitude, cameraLatLngTarget.latitude) - assertEquals(location.longitude, cameraLatLngTarget.longitude) - - val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng - assertEquals(location.latitude, layerLatLngTarget.latitude) - assertEquals(location.longitude, layerLatLngTarget.longitude) - - val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float - assertEquals(location.bearing, cameraBearingTarget) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(location.bearing, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_multiplePoints() { - val previousLocation = Location("") - previousLocation.latitude = 0.0 - previousLocation.longitude = 0.0 - previousLocation.bearing = 0f - - val locationInter = Location("") - locationInter.latitude = 51.1 - locationInter.longitude = 17.1 - locationInter.bearing = 35f - val location = Location("") - location.latitude = 51.2 - location.longitude = 17.2 - location.bearing = 36f - locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, false) - - val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng - assertEquals(location.latitude, cameraLatLngTarget.latitude) - assertEquals(location.longitude, cameraLatLngTarget.longitude) - - val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng - assertEquals(location.latitude, layerLatLngTarget.latitude) - assertEquals(location.longitude, layerLatLngTarget.longitude) - - val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float - assertEquals(location.bearing, cameraBearingTarget) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(location.bearing, layerBearingTarget) - - verify { - animatorProvider.latLngAnimator( - arrayOf( - LatLng(previousLocation.latitude, previousLocation.longitude), - LatLng(locationInter.latitude, locationInter.longitude), - LatLng(location.latitude, location.longitude) - ), any(), any() - ) - } - verify { - animatorProvider.floatAnimator( - arrayOf(previousLocation.bearing, locationInter.bearing, location.bearing), any(), any() - ) - } - } - - @Test - fun feedNewLocation_animatorValue_bearing() { - val previous = Location("") - previous.latitude = 51.1 - previous.longitude = 17.1 - previous.bearing = 355f - - val current = Location("") - current.latitude = 51.2 - current.longitude = 17.2 - current.bearing = 0f - - locationAnimatorCoordinator.feedNewLocation(arrayOf(previous, current), cameraPosition, false, false) - - verify { - animatorProvider.floatAnimator( - arrayOf(0f, -5f, 0f), any(), any() - ) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING] != null) } - locationAnimatorCoordinator.feedNewLocation(arrayOf(previous, current), cameraPosition, true, false) + @Test + fun feedNewLocation_animatorValue() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 35f + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - verify { - animatorProvider.floatAnimator( - arrayOf(0f, 0f), any(), any() - ) + val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng + assertEquals(location.latitude, cameraLatLngTarget.latitude) + assertEquals(location.longitude, cameraLatLngTarget.longitude) + + val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng + assertEquals(location.latitude, layerLatLngTarget.latitude) + assertEquals(location.longitude, layerLatLngTarget.longitude) + + val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float + assertEquals(location.bearing, cameraBearingTarget) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(location.bearing, layerBearingTarget) } - } - @Test - fun feedNewLocation_animatorValue_multiplePoints_animationDuration() { - every { projection.getMetersPerPixelAtLatitude(any()) } answers { 10000.0 } // disable snap - val locationInter = Location("") - locationInter.latitude = 51.1 - locationInter.longitude = 17.1 - locationInter.bearing = 35f - val location = Location("") - location.latitude = 51.2 - location.longitude = 17.2 - location.bearing = 36f - locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, false) + @Test + fun feedNewLocation_animatorValue_multiplePoints() { + val previousLocation = Location("") + previousLocation.latitude = 0.0 + previousLocation.longitude = 0.0 + previousLocation.bearing = 0f - verify { - animatorSetProvider.startAnimation(eq(listOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG], - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] - )), any(), 0) + val locationInter = Location("") + locationInter.latitude = 51.1 + locationInter.longitude = 17.1 + locationInter.bearing = 35f + val location = Location("") + location.latitude = 51.2 + location.longitude = 17.2 + location.bearing = 36f + locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, false) + + val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng + assertEquals(location.latitude, cameraLatLngTarget.latitude) + assertEquals(location.longitude, cameraLatLngTarget.longitude) + + val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng + assertEquals(location.latitude, layerLatLngTarget.latitude) + assertEquals(location.longitude, layerLatLngTarget.longitude) + + val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float + assertEquals(location.bearing, cameraBearingTarget) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(location.bearing, layerBearingTarget) + + verify { + animatorProvider.latLngAnimator( + arrayOf( + LatLng(previousLocation.latitude, previousLocation.longitude), + LatLng(locationInter.latitude, locationInter.longitude), + LatLng(location.latitude, location.longitude) + ), + any(), + any() + ) + } + verify { + animatorProvider.floatAnimator( + arrayOf(previousLocation.bearing, locationInter.bearing, location.bearing), + any(), + any() + ) + } } - } - @Test - fun feedNewLocation_animatorValue_multiplePoints_animationDuration_lookAhead() { - every { projection.getMetersPerPixelAtLatitude(any()) } answers { 10000.0 } // disable snap - val locationInter = Location("") - locationInter.latitude = 51.1 - locationInter.longitude = 17.1 - locationInter.bearing = 35f - val location = Location("") - location.latitude = 51.2 - location.longitude = 17.2 - location.bearing = 36f - location.time = System.currentTimeMillis() + 2000 - locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, true) + @Test + fun feedNewLocation_animatorValue_bearing() { + val previous = Location("") + previous.latitude = 51.1 + previous.longitude = 17.1 + previous.bearing = 355f - verify { - animatorSetProvider.startAnimation(eq(listOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG], - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] - )), any(), more(1500L)) + val current = Location("") + current.latitude = 51.2 + current.longitude = 17.2 + current.bearing = 0f + + locationAnimatorCoordinator.feedNewLocation(arrayOf(previous, current), cameraPosition, false, false) + + verify { + animatorProvider.floatAnimator( + arrayOf(0f, -5f, 0f), + any(), + any() + ) + } + + locationAnimatorCoordinator.feedNewLocation(arrayOf(previous, current), cameraPosition, true, false) + + verify { + animatorProvider.floatAnimator( + arrayOf(0f, 0f), + any(), + any() + ) + } } - } - @Test - fun feedNewLocation_animatorValue_correctRotation_1() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 0f + @Test + fun feedNewLocation_animatorValue_multiplePoints_animationDuration() { + every { projection.getMetersPerPixelAtLatitude(any()) } answers { 10000.0 } // disable snap + val locationInter = Location("") + locationInter.latitude = 51.1 + locationInter.longitude = 17.1 + locationInter.bearing = 35f + val location = Location("") + location.latitude = 51.2 + location.longitude = 17.2 + location.bearing = 36f + locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, false) - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns 270f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(360f, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_correctRotation_2() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 90f - - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns 280f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(450f, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_correctRotation_3() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 300f - - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns 450f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(-60f, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_correctRotation_4() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 350f - - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns 10f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(-10f, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_correctRotation_5() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 90f - - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns -280f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(90f, layerBearingTarget) - } - - @Test - fun feedNewLocation_animatorValue_correctRotation_6() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 270f - - val animator = mockk(relaxed = true) - every { animator.animatedValue } returns -350f - locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(-90f, layerBearingTarget) - } - - @Test - fun feedNewLocation_isNorth_animatorsAreCreated() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 35f - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING] != null) - } - - @Test - fun feedNewLocation_isNorth_animatorValue() { - val location = Location("") - location.latitude = 51.0 - location.longitude = 17.0 - location.bearing = 35f - locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, true) - - val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng - assertEquals(cameraLatLngTarget.latitude, cameraLatLngTarget.latitude) - - val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng - assertEquals(layerLatLngTarget.latitude, layerLatLngTarget.latitude) - - val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float - assertEquals(0f, cameraBearingTarget) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float - assertEquals(location.bearing, layerBearingTarget) - } - - @Test - fun feedNewCompassBearing_animatorsAreCreated() { - locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING] != null) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING] != null) - } - - @Test - fun feedNewCompassBearing_animatorValue() { - val bearing = 77f - locationAnimatorCoordinator.feedNewCompassBearing(bearing, cameraPosition) - - val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING]?.target as Float - assertEquals(bearing, cameraBearingTarget) - - val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING]?.target as Float - assertEquals(bearing, layerBearingTarget) - } - - @Test - fun feedNewAccuracyRadius_animatorsCreated() { - locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] != null) - } - - @Test - fun feedNewAccuracyRadius_animatorValue() { - val accuracy = 150f - locationAnimatorCoordinator.feedNewAccuracyRadius(accuracy, false) - - val layerAccuracy = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]?.target as Float - assertEquals(layerAccuracy, accuracy) - } - - @Test - fun feedNewAccuracyRadius_noAnimation_animatorsCreated() { - locationAnimatorCoordinator.feedNewAccuracyRadius(150f, true) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] != null) - } - - @Test - fun feedNewAccuracyRadius_noAnimation_animatorValue() { - val accuracy = 150f - locationAnimatorCoordinator.feedNewAccuracyRadius(accuracy, true) - - val layerAccuracy = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]?.target as Float - assertEquals(layerAccuracy, accuracy) - } - - @Test - fun feedNewZoomLevel_animatorsCreated() { - locationAnimatorCoordinator.feedNewZoomLevel( - 15.0, - cameraPosition, - DEFAULT_TRACKING_ZOOM_ANIM_DURATION, - null - ) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM] != null) - } - - @Test - fun feedNewZoomLevel_animatorValue() { - val zoom = 15.0f - locationAnimatorCoordinator.feedNewZoomLevel( - zoom.toDouble(), - cameraPosition, - DEFAULT_TRACKING_ZOOM_ANIM_DURATION, - null - ) - - val animator = locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM] - assertEquals(zoom, animator.target) - verify { animatorSetProvider.startAnimation(eq(listOf(animator)), any(), DEFAULT_TRACKING_ZOOM_ANIM_DURATION) } - } - - @Test - fun feedNewTiltLevel_animatorsCreated() { - locationAnimatorCoordinator.feedNewTilt( - 30.0, - cameraPosition, - DEFAULT_TRACKING_TILT_ANIM_DURATION, - null - ) - - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT] != null) - } - - @Test - fun feedNewTiltLevel_animatorValue() { - val tilt = 30.0f - locationAnimatorCoordinator.feedNewTilt( - tilt.toDouble(), - cameraPosition, - DEFAULT_TRACKING_TILT_ANIM_DURATION, - null - ) - - val animator = locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT] - assertEquals(tilt, animator.target) - verify { animatorSetProvider.startAnimation(eq(listOf(animator)), any(), DEFAULT_TRACKING_TILT_ANIM_DURATION) } - } - - @Test - fun cancelAllAnimators() { - locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, true) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG].isStarted) - - locationAnimatorCoordinator.cancelAllAnimations() - - assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG].isStarted) - } - - @Test - fun cancelZoomAnimators() { - locationAnimatorCoordinator.feedNewZoomLevel( - 15.0, - cameraPosition, - DEFAULT_TRACKING_ZOOM_ANIM_DURATION, - null - ) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM].isStarted) - - locationAnimatorCoordinator.cancelZoomAnimation() - - assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM].isStarted) - } - - @Test - fun cancelTiltAnimation() { - locationAnimatorCoordinator.feedNewTilt( - 30.0, - cameraPosition, - DEFAULT_TRACKING_TILT_ANIM_DURATION, - null - ) - assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT].isStarted) - - locationAnimatorCoordinator.cancelTiltAnimation() - - assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT].isStarted) - } - - @Test - fun resetAllCameraAnimations_empty() { - locationAnimatorCoordinator.resetAllCameraAnimations(cameraPosition, false) - assertTrue(locationAnimatorCoordinator.animatorArray.size() == 0) - } - - @Test - fun resetAllLayerAnimations_empty() { - locationAnimatorCoordinator.resetAllLayerAnimations() - assertTrue(locationAnimatorCoordinator.animatorArray.size() == 0) - } - - @Test - fun addNewListener() { - val listener = Mockito.mock(AnimationsValueChangeListener::class.java) - val holder = AnimatorListenerHolder(RenderMode.NORMAL, listener) - val set = HashSet().also { - it.add(holder) + verify { + animatorSetProvider.startAnimation( + eq( + listOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG], + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] + ) + ), + any(), + 0 + ) + } } - locationAnimatorCoordinator.updateAnimatorListenerHolders(set) - assertTrue(locationAnimatorCoordinator.listeners.contains(listener)) - } + @Test + fun feedNewLocation_animatorValue_multiplePoints_animationDuration_lookAhead() { + every { projection.getMetersPerPixelAtLatitude(any()) } answers { 10000.0 } // disable snap + val locationInter = Location("") + locationInter.latitude = 51.1 + locationInter.longitude = 17.1 + locationInter.bearing = 35f + val location = Location("") + location.latitude = 51.2 + location.longitude = 17.2 + location.bearing = 36f + location.time = System.currentTimeMillis() + 2000 + locationAnimatorCoordinator.feedNewLocation(arrayOf(locationInter, location), cameraPosition, false, true) - @Test - fun updateListeners() { - val listener = Mockito.mock(AnimationsValueChangeListener::class.java) - val holder = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener) - val set = HashSet().also { - it.add(holder) + verify { + animatorSetProvider.startAnimation( + eq( + listOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG], + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] + ) + ), + any(), + more(1500L) + ) + } } - locationAnimatorCoordinator.updateAnimatorListenerHolders(set) - val listener2 = Mockito.mock(AnimationsValueChangeListener::class.java) - val holder2 = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener2) - val listener3 = Mockito.mock(AnimationsValueChangeListener::class.java) - val holder3 = AnimatorListenerHolder(ANIMATOR_LAYER_ACCURACY, listener3) - val set2 = HashSet().also { - it.add(holder2) - it.add(holder3) + @Test + fun feedNewLocation_animatorValue_correctRotation_1() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 0f + + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns 270f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) + + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(360f, layerBearingTarget) } - locationAnimatorCoordinator.updateAnimatorListenerHolders(set2) - assertTrue(locationAnimatorCoordinator.listeners.size() == 2) - assertTrue(locationAnimatorCoordinator.listeners.contains(listener2)) - assertTrue(locationAnimatorCoordinator.listeners.contains(listener3)) - } + @Test + fun feedNewLocation_animatorValue_correctRotation_2() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 90f - @Test - fun updateListeners_listenerRemoved_animtorInvalid() { - // setup accuracy animator - val listener: AnimationsValueChangeListener = mockk(relaxUnitFun = true) - val holder = AnimatorListenerHolder(ANIMATOR_LAYER_ACCURACY, listener) - val set = HashSet().also { - it.add(holder) + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns 280f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) + + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(450f, layerBearingTarget) } - locationAnimatorCoordinator.updateAnimatorListenerHolders(set) - locationAnimatorCoordinator.feedNewAccuracyRadius(500f, true) - // reset animator listeners which should make the previously created animator invalid - val listener2: AnimationsValueChangeListener<*> = mockk() - val holder2 = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener2) - val listener3: AnimationsValueChangeListener<*> = mockk() - val holder3 = AnimatorListenerHolder(ANIMATOR_CAMERA_GPS_BEARING, listener3) - val set2 = HashSet().also { - it.add(holder2) - it.add(holder3) + @Test + fun feedNewLocation_animatorValue_correctRotation_3() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 300f + + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns 450f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) + + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(-60f, layerBearingTarget) } - locationAnimatorCoordinator.updateAnimatorListenerHolders(set2) - // try pushing an update to verify it was ignored - val valueAnimator: ValueAnimator = mockk() - every { valueAnimator.animatedValue } returns 10f - val animator = locationAnimatorCoordinator.animatorArray.get(ANIMATOR_LAYER_ACCURACY) - animator.onAnimationUpdate(valueAnimator) + @Test + fun feedNewLocation_animatorValue_correctRotation_4() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 350f - verify(exactly = 0) { listener.onNewAnimationValue(10f) } - } + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns 10f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) - @Test - fun feedNewCompassBearing_withAnimation() { - locationAnimatorCoordinator.setCompassAnimationEnabled(true) - locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) - val animators = mutableListOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING]) - - verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(LocationComponentConstants.COMPASS_UPDATE_RATE_MS)) } - } - - @Test - fun feedNewCompassBearing_withoutAnimation() { - locationAnimatorCoordinator.setCompassAnimationEnabled(false) - locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) - - val animators = mutableListOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING], - locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING]) - - verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(0)) } - } - - @Test - fun feedNewAccuracy_withAnimation() { - locationAnimatorCoordinator.setAccuracyAnimationEnabled(true) - locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) - - val animators = mutableListOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]) - - verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(LocationComponentConstants.ACCURACY_RADIUS_ANIMATION_DURATION)) } - } - - @Test - fun feedNewAccuracy_withoutAnimation() { - locationAnimatorCoordinator.setAccuracyAnimationEnabled(false) - locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) - - val animators = mutableListOf( - locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]) - - verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(0)) } - } - - @Test - fun maxFps_setter() { - locationAnimatorCoordinator.setMaxAnimationFps(5) - assertEquals(5, locationAnimatorCoordinator.maxAnimationFps) - } - - @Test - fun maxFps_moreThanZeroRequired() { - locationAnimatorCoordinator.setMaxAnimationFps(0) - assertEquals(Int.MAX_VALUE, locationAnimatorCoordinator.maxAnimationFps) - locationAnimatorCoordinator.setMaxAnimationFps(-1) - assertEquals(Int.MAX_VALUE, locationAnimatorCoordinator.maxAnimationFps) - } - - @Test - fun maxFps_givenToAnimator() { - locationAnimatorCoordinator.setMaxAnimationFps(5) - locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, false) - verify { animatorProvider.latLngAnimator(any(), any(), 5) } - verify { animatorProvider.floatAnimator(any(), any(), 5) } - } - - private fun getListenerHoldersSet(vararg animatorTypes: Int): Set { - return HashSet().also { - for (type in animatorTypes) { - it.add(AnimatorListenerHolder(type, mockk(relaxUnitFun = true))) - } + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(-10f, layerBearingTarget) + } + + @Test + fun feedNewLocation_animatorValue_correctRotation_5() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 90f + + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns -280f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) + + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(90f, layerBearingTarget) + } + + @Test + fun feedNewLocation_animatorValue_correctRotation_6() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 270f + + val animator = mockk(relaxed = true) + every { animator.animatedValue } returns -350f + locationAnimatorCoordinator.animatorArray.put(ANIMATOR_LAYER_GPS_BEARING, animator) + + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(-90f, layerBearingTarget) + } + + @Test + fun feedNewLocation_isNorth_animatorsAreCreated() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 35f + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, false) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING] != null) + } + + @Test + fun feedNewLocation_isNorth_animatorValue() { + val location = Location("") + location.latitude = 51.0 + location.longitude = 17.0 + location.bearing = 35f + locationAnimatorCoordinator.feedNewLocation(location, cameraPosition, true) + + val cameraLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG]?.target as LatLng + assertEquals(cameraLatLngTarget.latitude, cameraLatLngTarget.latitude) + + val layerLatLngTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_LATLNG]?.target as LatLng + assertEquals(layerLatLngTarget.latitude, layerLatLngTarget.latitude) + + val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_GPS_BEARING]?.target as Float + assertEquals(0f, cameraBearingTarget) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_GPS_BEARING]?.target as Float + assertEquals(location.bearing, layerBearingTarget) + } + + @Test + fun feedNewCompassBearing_animatorsAreCreated() { + locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING] != null) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING] != null) + } + + @Test + fun feedNewCompassBearing_animatorValue() { + val bearing = 77f + locationAnimatorCoordinator.feedNewCompassBearing(bearing, cameraPosition) + + val cameraBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING]?.target as Float + assertEquals(bearing, cameraBearingTarget) + + val layerBearingTarget = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING]?.target as Float + assertEquals(bearing, layerBearingTarget) + } + + @Test + fun feedNewAccuracyRadius_animatorsCreated() { + locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] != null) + } + + @Test + fun feedNewAccuracyRadius_animatorValue() { + val accuracy = 150f + locationAnimatorCoordinator.feedNewAccuracyRadius(accuracy, false) + + val layerAccuracy = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]?.target as Float + assertEquals(layerAccuracy, accuracy) + } + + @Test + fun feedNewAccuracyRadius_noAnimation_animatorsCreated() { + locationAnimatorCoordinator.feedNewAccuracyRadius(150f, true) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] != null) + } + + @Test + fun feedNewAccuracyRadius_noAnimation_animatorValue() { + val accuracy = 150f + locationAnimatorCoordinator.feedNewAccuracyRadius(accuracy, true) + + val layerAccuracy = locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY]?.target as Float + assertEquals(layerAccuracy, accuracy) + } + + @Test + fun feedNewZoomLevel_animatorsCreated() { + locationAnimatorCoordinator.feedNewZoomLevel( + 15.0, + cameraPosition, + DEFAULT_TRACKING_ZOOM_ANIM_DURATION, + null + ) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM] != null) + } + + @Test + fun feedNewZoomLevel_animatorValue() { + val zoom = 15.0f + locationAnimatorCoordinator.feedNewZoomLevel( + zoom.toDouble(), + cameraPosition, + DEFAULT_TRACKING_ZOOM_ANIM_DURATION, + null + ) + + val animator = locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM] + assertEquals(zoom, animator.target) + verify { animatorSetProvider.startAnimation(eq(listOf(animator)), any(), DEFAULT_TRACKING_ZOOM_ANIM_DURATION) } + } + + @Test + fun feedNewTiltLevel_animatorsCreated() { + locationAnimatorCoordinator.feedNewTilt( + 30.0, + cameraPosition, + DEFAULT_TRACKING_TILT_ANIM_DURATION, + null + ) + + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT] != null) + } + + @Test + fun feedNewTiltLevel_animatorValue() { + val tilt = 30.0f + locationAnimatorCoordinator.feedNewTilt( + tilt.toDouble(), + cameraPosition, + DEFAULT_TRACKING_TILT_ANIM_DURATION, + null + ) + + val animator = locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT] + assertEquals(tilt, animator.target) + verify { animatorSetProvider.startAnimation(eq(listOf(animator)), any(), DEFAULT_TRACKING_TILT_ANIM_DURATION) } + } + + @Test + fun cancelAllAnimators() { + locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, true) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG].isStarted) + + locationAnimatorCoordinator.cancelAllAnimations() + + assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_LATLNG].isStarted) + } + + @Test + fun cancelZoomAnimators() { + locationAnimatorCoordinator.feedNewZoomLevel( + 15.0, + cameraPosition, + DEFAULT_TRACKING_ZOOM_ANIM_DURATION, + null + ) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM].isStarted) + + locationAnimatorCoordinator.cancelZoomAnimation() + + assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_ZOOM].isStarted) + } + + @Test + fun cancelTiltAnimation() { + locationAnimatorCoordinator.feedNewTilt( + 30.0, + cameraPosition, + DEFAULT_TRACKING_TILT_ANIM_DURATION, + null + ) + assertTrue(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT].isStarted) + + locationAnimatorCoordinator.cancelTiltAnimation() + + assertFalse(locationAnimatorCoordinator.animatorArray[ANIMATOR_TILT].isStarted) + } + + @Test + fun resetAllCameraAnimations_empty() { + locationAnimatorCoordinator.resetAllCameraAnimations(cameraPosition, false) + assertTrue(locationAnimatorCoordinator.animatorArray.size() == 0) + } + + @Test + fun resetAllLayerAnimations_empty() { + locationAnimatorCoordinator.resetAllLayerAnimations() + assertTrue(locationAnimatorCoordinator.animatorArray.size() == 0) + } + + @Test + fun addNewListener() { + val listener = Mockito.mock(AnimationsValueChangeListener::class.java) + val holder = AnimatorListenerHolder(RenderMode.NORMAL, listener) + val set = HashSet().also { + it.add(holder) + } + locationAnimatorCoordinator.updateAnimatorListenerHolders(set) + + assertTrue(locationAnimatorCoordinator.listeners.contains(listener)) + } + + @Test + fun updateListeners() { + val listener = Mockito.mock(AnimationsValueChangeListener::class.java) + val holder = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener) + val set = HashSet().also { + it.add(holder) + } + locationAnimatorCoordinator.updateAnimatorListenerHolders(set) + + val listener2 = Mockito.mock(AnimationsValueChangeListener::class.java) + val holder2 = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener2) + val listener3 = Mockito.mock(AnimationsValueChangeListener::class.java) + val holder3 = AnimatorListenerHolder(ANIMATOR_LAYER_ACCURACY, listener3) + val set2 = HashSet().also { + it.add(holder2) + it.add(holder3) + } + locationAnimatorCoordinator.updateAnimatorListenerHolders(set2) + + assertTrue(locationAnimatorCoordinator.listeners.size() == 2) + assertTrue(locationAnimatorCoordinator.listeners.contains(listener2)) + assertTrue(locationAnimatorCoordinator.listeners.contains(listener3)) + } + + @Test + fun updateListeners_listenerRemoved_animtorInvalid() { + // setup accuracy animator + val listener: AnimationsValueChangeListener = mockk(relaxUnitFun = true) + val holder = AnimatorListenerHolder(ANIMATOR_LAYER_ACCURACY, listener) + val set = HashSet().also { + it.add(holder) + } + locationAnimatorCoordinator.updateAnimatorListenerHolders(set) + locationAnimatorCoordinator.feedNewAccuracyRadius(500f, true) + + // reset animator listeners which should make the previously created animator invalid + val listener2: AnimationsValueChangeListener<*> = mockk() + val holder2 = AnimatorListenerHolder(ANIMATOR_LAYER_LATLNG, listener2) + val listener3: AnimationsValueChangeListener<*> = mockk() + val holder3 = AnimatorListenerHolder(ANIMATOR_CAMERA_GPS_BEARING, listener3) + val set2 = HashSet().also { + it.add(holder2) + it.add(holder3) + } + locationAnimatorCoordinator.updateAnimatorListenerHolders(set2) + + // try pushing an update to verify it was ignored + val valueAnimator: ValueAnimator = mockk() + every { valueAnimator.animatedValue } returns 10f + val animator = locationAnimatorCoordinator.animatorArray.get(ANIMATOR_LAYER_ACCURACY) + animator.onAnimationUpdate(valueAnimator) + + verify(exactly = 0) { listener.onNewAnimationValue(10f) } + } + + @Test + fun feedNewCompassBearing_withAnimation() { + locationAnimatorCoordinator.setCompassAnimationEnabled(true) + locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) + + val animators = mutableListOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING] + ) + + verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(LocationComponentConstants.COMPASS_UPDATE_RATE_MS)) } + } + + @Test + fun feedNewCompassBearing_withoutAnimation() { + locationAnimatorCoordinator.setCompassAnimationEnabled(false) + locationAnimatorCoordinator.feedNewCompassBearing(77f, cameraPosition) + + val animators = mutableListOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_COMPASS_BEARING], + locationAnimatorCoordinator.animatorArray[ANIMATOR_CAMERA_COMPASS_BEARING] + ) + + verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(0)) } + } + + @Test + fun feedNewAccuracy_withAnimation() { + locationAnimatorCoordinator.setAccuracyAnimationEnabled(true) + locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) + + val animators = mutableListOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] + ) + + verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(LocationComponentConstants.ACCURACY_RADIUS_ANIMATION_DURATION)) } + } + + @Test + fun feedNewAccuracy_withoutAnimation() { + locationAnimatorCoordinator.setAccuracyAnimationEnabled(false) + locationAnimatorCoordinator.feedNewAccuracyRadius(150f, false) + + val animators = mutableListOf( + locationAnimatorCoordinator.animatorArray[ANIMATOR_LAYER_ACCURACY] + ) + + verify(exactly = 1) { animatorSetProvider.startAnimation(eq(animators), ofType(LinearInterpolator::class), eq(0)) } + } + + @Test + fun maxFps_setter() { + locationAnimatorCoordinator.setMaxAnimationFps(5) + assertEquals(5, locationAnimatorCoordinator.maxAnimationFps) + } + + @Test + fun maxFps_moreThanZeroRequired() { + locationAnimatorCoordinator.setMaxAnimationFps(0) + assertEquals(Int.MAX_VALUE, locationAnimatorCoordinator.maxAnimationFps) + locationAnimatorCoordinator.setMaxAnimationFps(-1) + assertEquals(Int.MAX_VALUE, locationAnimatorCoordinator.maxAnimationFps) + } + + @Test + fun maxFps_givenToAnimator() { + locationAnimatorCoordinator.setMaxAnimationFps(5) + locationAnimatorCoordinator.feedNewLocation(Location(""), cameraPosition, false) + verify { animatorProvider.latLngAnimator(any(), any(), 5) } + verify { animatorProvider.floatAnimator(any(), any(), 5) } + } + + private fun getListenerHoldersSet(vararg animatorTypes: Int): Set { + return HashSet().also { + for (type in animatorTypes) { + it.add(AnimatorListenerHolder(type, mockk(relaxUnitFun = true))) + } + } } - } } private fun SparseArray.contains(listener: AnimationsValueChangeListener<*>?): Boolean { - for (i in 0 until this.size()) { - val element = this.get(this.keyAt(i)) - if (element == listener) { - return true + for (i in 0 until this.size()) { + val element = this.get(this.keyAt(i)) + if (element == listener) { + return true + } } - } - return false -} \ No newline at end of file + return false +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentPositionManagerTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentPositionManagerTest.kt index c8a75b670..4eafbb73d 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentPositionManagerTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentPositionManagerTest.kt @@ -14,117 +14,117 @@ import org.mockito.junit.MockitoJUnitRunner @RunWith(MockitoJUnitRunner::class) class LocationComponentPositionManagerTest { - private lateinit var style: Style - private lateinit var layer: Layer + private lateinit var style: Style + private lateinit var layer: Layer - @Before - fun setup() { - style = mockk(relaxed = true) - layer = mockk(relaxed = true) - } + @Before + fun setup() { + style = mockk(relaxed = true) + layer = mockk(relaxed = true) + } - @Test - fun update_noChange_null() { - val positionManager = LocationComponentPositionManager(style, null, null) - val requiresUpdate = positionManager.update(null, null) - assertFalse(requiresUpdate) - } + @Test + fun update_noChange_null() { + val positionManager = LocationComponentPositionManager(style, null, null) + val requiresUpdate = positionManager.update(null, null) + assertFalse(requiresUpdate) + } - @Test - fun update_noChange_above() { - val positionManager = LocationComponentPositionManager(style, "above", null) - val requiresUpdate = positionManager.update("above", null) - assertFalse(requiresUpdate) - } + @Test + fun update_noChange_above() { + val positionManager = LocationComponentPositionManager(style, "above", null) + val requiresUpdate = positionManager.update("above", null) + assertFalse(requiresUpdate) + } - @Test - fun update_noChange_below() { - val positionManager = LocationComponentPositionManager(style, null, "below") - val requiresUpdate = positionManager.update(null, "below") - assertFalse(requiresUpdate) - } + @Test + fun update_noChange_below() { + val positionManager = LocationComponentPositionManager(style, null, "below") + val requiresUpdate = positionManager.update(null, "below") + assertFalse(requiresUpdate) + } - @Test - fun update_fromNull_above() { - val positionManager = LocationComponentPositionManager(style, null, null) - val requiresUpdate = positionManager.update("above", null) - assertTrue(requiresUpdate) - } + @Test + fun update_fromNull_above() { + val positionManager = LocationComponentPositionManager(style, null, null) + val requiresUpdate = positionManager.update("above", null) + assertTrue(requiresUpdate) + } - @Test - fun update_fromNull_below() { - val positionManager = LocationComponentPositionManager(style, null, null) - val requiresUpdate = positionManager.update(null, "below") - assertTrue(requiresUpdate) - } + @Test + fun update_fromNull_below() { + val positionManager = LocationComponentPositionManager(style, null, null) + val requiresUpdate = positionManager.update(null, "below") + assertTrue(requiresUpdate) + } - @Test - fun update_toNull_above() { - val positionManager = LocationComponentPositionManager(style, "above", null) - val requiresUpdate = positionManager.update(null, null) - assertTrue(requiresUpdate) - } + @Test + fun update_toNull_above() { + val positionManager = LocationComponentPositionManager(style, "above", null) + val requiresUpdate = positionManager.update(null, null) + assertTrue(requiresUpdate) + } - @Test - fun update_toNull_below() { - val positionManager = LocationComponentPositionManager(style, null, "below") - val requiresUpdate = positionManager.update(null, null) - assertTrue(requiresUpdate) - } + @Test + fun update_toNull_below() { + val positionManager = LocationComponentPositionManager(style, null, "below") + val requiresUpdate = positionManager.update(null, null) + assertTrue(requiresUpdate) + } - @Test - fun update_fromValue_above() { - val positionManager = LocationComponentPositionManager(style, "above1", null) - val requiresUpdate = positionManager.update("above2", null) - assertTrue(requiresUpdate) - } + @Test + fun update_fromValue_above() { + val positionManager = LocationComponentPositionManager(style, "above1", null) + val requiresUpdate = positionManager.update("above2", null) + assertTrue(requiresUpdate) + } - @Test - fun update_fromValue_below() { - val positionManager = LocationComponentPositionManager(style, null, "below1") - val requiresUpdate = positionManager.update(null, "below2") - assertTrue(requiresUpdate) - } + @Test + fun update_fromValue_below() { + val positionManager = LocationComponentPositionManager(style, null, "below1") + val requiresUpdate = positionManager.update(null, "below2") + assertTrue(requiresUpdate) + } - @Test - fun addLayer_noModifier() { - val positionManager = LocationComponentPositionManager(style, null, null) - positionManager.addLayerToMap(layer) + @Test + fun addLayer_noModifier() { + val positionManager = LocationComponentPositionManager(style, null, null) + positionManager.addLayerToMap(layer) - verify { style.addLayer(layer) } - } + verify { style.addLayer(layer) } + } - @Test - fun addLayer_above() { - val positionManager = LocationComponentPositionManager(style, "above", null) - positionManager.addLayerToMap(layer) + @Test + fun addLayer_above() { + val positionManager = LocationComponentPositionManager(style, "above", null) + positionManager.addLayerToMap(layer) - verify { style.addLayerAbove(layer, "above") } - } + verify { style.addLayerAbove(layer, "above") } + } - @Test - fun addLayer_below() { - val positionManager = LocationComponentPositionManager(style, null, "below") - positionManager.addLayerToMap(layer) + @Test + fun addLayer_below() { + val positionManager = LocationComponentPositionManager(style, null, "below") + positionManager.addLayerToMap(layer) - verify { style.addLayerBelow(layer, "below") } - } + verify { style.addLayerBelow(layer, "below") } + } - @Test - fun addLayer_afterUpdate_above() { - val positionManager = LocationComponentPositionManager(style, null, null) - positionManager.update("above", null) - positionManager.addLayerToMap(layer) + @Test + fun addLayer_afterUpdate_above() { + val positionManager = LocationComponentPositionManager(style, null, null) + positionManager.update("above", null) + positionManager.addLayerToMap(layer) - verify { style.addLayerAbove(layer, "above") } - } + verify { style.addLayerAbove(layer, "above") } + } - @Test - fun addLayer_afterUpdate_below() { - val positionManager = LocationComponentPositionManager(style, null, null) - positionManager.update(null, "below") - positionManager.addLayerToMap(layer) + @Test + fun addLayer_afterUpdate_below() { + val positionManager = LocationComponentPositionManager(style, null, null) + positionManager.update(null, "below") + positionManager.addLayerToMap(layer) - verify { style.addLayerBelow(layer, "below") } - } -} \ No newline at end of file + verify { style.addLayerBelow(layer, "below") } + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentTest.kt index 33a067f59..5545be40b 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentTest.kt @@ -28,606 +28,606 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class LocationComponentTest { - private lateinit var locationComponent: LocationComponent + private lateinit var locationComponent: LocationComponent - @Mock - private lateinit var locationComponentOptions: LocationComponentOptions + @Mock + private lateinit var locationComponentOptions: LocationComponentOptions - @Mock - private lateinit var mapboxMap: MapboxMap + @Mock + private lateinit var mapboxMap: MapboxMap - @Mock - private lateinit var transform: Transform + @Mock + private lateinit var transform: Transform - @Mock - private lateinit var context: Context + @Mock + private lateinit var context: Context - @Mock - private lateinit var locationEngine: LocationEngine + @Mock + private lateinit var locationEngine: LocationEngine - @Mock - private lateinit var locationEngineRequest: LocationEngineRequest + @Mock + private lateinit var locationEngineRequest: LocationEngineRequest - @Mock - private lateinit var currentListener: LocationComponent.CurrentLocationEngineCallback + @Mock + private lateinit var currentListener: LocationComponent.CurrentLocationEngineCallback - @Mock - private lateinit var lastListener: LocationComponent.LastLocationEngineCallback + @Mock + private lateinit var lastListener: LocationComponent.LastLocationEngineCallback - @Mock - private lateinit var compassEngine: CompassEngine + @Mock + private lateinit var compassEngine: CompassEngine - @Mock - private lateinit var locationLayerController: LocationLayerController + @Mock + private lateinit var locationLayerController: LocationLayerController - @Mock - private lateinit var locationCameraController: LocationCameraController + @Mock + private lateinit var locationCameraController: LocationCameraController - @Mock - private lateinit var locationAnimatorCoordinator: LocationAnimatorCoordinator + @Mock + private lateinit var locationAnimatorCoordinator: LocationAnimatorCoordinator - @Mock - private lateinit var staleStateManager: StaleStateManager + @Mock + private lateinit var staleStateManager: StaleStateManager - @Mock - private lateinit var locationEngineProvider: LocationComponent.InternalLocationEngineProvider + @Mock + private lateinit var locationEngineProvider: LocationComponent.InternalLocationEngineProvider - @Mock - private lateinit var style: Style + @Mock + private lateinit var style: Style - private lateinit var developerAnimationListeners: List + private lateinit var developerAnimationListeners: List - @Before - fun before() { - MockitoAnnotations.initMocks(this) - developerAnimationListeners = mutableListOf() - locationComponent = LocationComponent(mapboxMap, transform, developerAnimationListeners, currentListener, lastListener, locationLayerController, locationCameraController, locationAnimatorCoordinator, staleStateManager, compassEngine, locationEngineProvider, false) - doReturn(locationEngine).`when`(locationEngineProvider).getBestLocationEngine(context, false) - doReturn(style).`when`(mapboxMap).style - } - - @Test - fun activateWithRequestTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - - Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) - - doReturn(mock(TypedArray::class.java)).`when`(context) - .obtainStyledAttributes(R.style.mapbox_LocationComponent, R.styleable.mapbox_LocationComponent) - - val resources = mock(Resources::class.java) - - doReturn(resources).`when`(context).resources - doReturn(0f).`when`(resources) - .getDimension(R.dimen.mapbox_locationComponentTrackingMultiFingerMoveThreshold) - doReturn(0f).`when`(resources) - .getDimension(R.dimen.mapbox_locationComponentTrackingMultiFingerMoveThreshold) - locationComponent.activateLocationComponent(context, mock(Style::class.java), true, locationEngineRequest) - Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) - } - - @Test - fun activateWithDefaultLocationEngineRequestAndOptionsTestDefaultLocationEngine() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), true, locationEngineRequest, locationComponentOptions) - Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) - Assert.assertNotNull(locationComponent.locationEngine) - } - - @Test - fun activateWithDefaultLocationEngineRequestAndOptionsTestCustomLocationEngine() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), false, locationEngineRequest, locationComponentOptions) - Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) - Assert.assertNull(locationComponent.locationEngine) - } - - @Test - fun locationUpdatesWhenEnabledDisableTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - verify(locationEngine, times(0)).removeLocationUpdates(currentListener) - verify(locationEngine, times(0)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - - locationComponent.onStart() - verify(locationEngine, times(0)).removeLocationUpdates(currentListener) - verify(locationEngine, times(0)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - - locationComponent.isLocationComponentEnabled = true - verify(locationEngine).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - - locationComponent.isLocationComponentEnabled = false - verify(locationEngine).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - verify(locationEngine).removeLocationUpdates(currentListener) - } - - @Test - fun locationUpdatesWhenStartedStoppedTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - - locationComponent.onStop() - verify(locationEngine).removeLocationUpdates(currentListener) - - locationComponent.onStart() - verify(locationEngine, times(2)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - } - - @Test - fun locationUpdatesWhenNewRequestTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - - val newRequest = mock(LocationEngineRequest::class.java) - locationComponent.locationEngineRequest = newRequest - verify(locationEngine).removeLocationUpdates(currentListener) - verify(locationEngine).requestLocationUpdates(eq(newRequest), eq(currentListener), any(Looper::class.java)) - } - - @Test - fun lastLocationUpdateOnStartTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - - verify(locationEngine).getLastLocation(lastListener) - } - - @Test - fun transitionCallbackFinishedTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - val listener = mock(OnLocationCameraTransitionListener::class.java) - - val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) - locationComponent.setCameraMode(CameraMode.TRACKING, listener) - verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), callback.capture()) - callback.value.onLocationCameraTransitionFinished(CameraMode.TRACKING) - - verify(listener).onLocationCameraTransitionFinished(CameraMode.TRACKING) - verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) - } - - @Test - fun transitionCallbackCanceledTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - val listener = mock(OnLocationCameraTransitionListener::class.java) - - val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) - locationComponent.setCameraMode(CameraMode.TRACKING, listener) - verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), callback.capture()) - callback.value.onLocationCameraTransitionCanceled(CameraMode.TRACKING) - - verify(listener).onLocationCameraTransitionCanceled(CameraMode.TRACKING) - verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) - } - - @Test - fun transitionCustomFinishedTest() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - val listener = mock(OnLocationCameraTransitionListener::class.java) - - val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) - locationComponent.setCameraMode(CameraMode.TRACKING, 1200, 14.0, 13.0, 45.0, listener) - verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(1200L), eq(14.0), eq(13.0), eq(45.0), callback.capture()) - callback.value.onLocationCameraTransitionFinished(CameraMode.TRACKING) - - verify(listener).onLocationCameraTransitionFinished(CameraMode.TRACKING) - verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) - } - - @Test - fun compass_listenWhenConsumedByNoneCamera() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationCameraController.isConsumingCompass).thenReturn(true) - locationComponent.cameraMode = CameraMode.NONE_COMPASS - verify(compassEngine).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_listenWhenConsumedByTrackingCamera() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationCameraController.isConsumingCompass).thenReturn(true) - locationComponent.cameraMode = CameraMode.TRACKING_COMPASS - verify(compassEngine).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_listenWhenConsumedByLayer() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - verify(compassEngine).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_notListenWhenNotConsumed() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(false) - `when`(locationCameraController.isConsumingCompass).thenReturn(false) - locationComponent.renderMode = RenderMode.GPS - locationComponent.renderMode = RenderMode.NORMAL - locationComponent.cameraMode = CameraMode.TRACKING - locationComponent.cameraMode = CameraMode.NONE - locationComponent.cameraMode = CameraMode.NONE_GPS - locationComponent.cameraMode = CameraMode.TRACKING_GPS - locationComponent.cameraMode = CameraMode.TRACKING_GPS_NORTH - verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_removeListenerOnChange() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - `when`(locationLayerController.isConsumingCompass).thenReturn(false) - locationComponent.renderMode = RenderMode.NORMAL - verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_removeListenerOnStop() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - locationComponent.onStop() - verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_reAddListenerOnStart() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - locationComponent.onStop() - locationComponent.onStart() - verify(compassEngine, times(2)).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_removeListenerOnStyleStartLoad() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - locationComponent.onStartLoadingMap() - verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_reAddListenerOnStyleLoadFinished() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - locationComponent.onStartLoadingMap() - locationComponent.onFinishLoadingStyle() - verify(compassEngine, times(2)).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_reAddListenerOnlyWhenEnabled() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - locationComponent.isLocationComponentEnabled = false - - locationComponent.onStartLoadingMap() - locationComponent.onFinishLoadingStyle() - verify(compassEngine).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_notAdListenerWhenDisabled() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_notAdListenerWhenStopped() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun compass_notAddListenerWhenLayerNotReady() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.onStart() - locationComponent.isLocationComponentEnabled = true - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationLayerController.isConsumingCompass).thenReturn(true) - locationComponent.renderMode = RenderMode.COMPASS - - verify(compassEngine, times(1)).addCompassListener(any(CompassListener::class.java)) - - locationComponent.onStartLoadingMap() - // Layer should be disabled at this point - locationComponent.setCameraMode(CameraMode.TRACKING_COMPASS) - verify(compassEngine, times(1)).addCompassListener(any(CompassListener::class.java)) - } - - @Test - fun developerAnimationCalled() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - for (listener in developerAnimationListeners) { - listener.onDeveloperAnimationStarted() + @Before + fun before() { + MockitoAnnotations.initMocks(this) + developerAnimationListeners = mutableListOf() + locationComponent = LocationComponent(mapboxMap, transform, developerAnimationListeners, currentListener, lastListener, locationLayerController, locationCameraController, locationAnimatorCoordinator, staleStateManager, compassEngine, locationEngineProvider, false) + doReturn(locationEngine).`when`(locationEngineProvider).getBestLocationEngine(context, false) + doReturn(style).`when`(mapboxMap).style } - verify(locationCameraController).setCameraMode(eq(CameraMode.NONE), isNull(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), any()) - } - @Test - fun internal_cameraTrackingChangedListener_onCameraTrackingDismissed() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true + @Test + fun activateWithRequestTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - val cameraChangeListener: OnCameraTrackingChangedListener = mock(OnCameraTrackingChangedListener::class.java) - locationComponent.addOnCameraTrackingChangedListener(cameraChangeListener) + Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) - locationComponent.cameraTrackingChangedListener.onCameraTrackingDismissed() + doReturn(mock(TypedArray::class.java)).`when`(context) + .obtainStyledAttributes(R.style.mapbox_LocationComponent, R.styleable.mapbox_LocationComponent) - verify(cameraChangeListener).onCameraTrackingDismissed() - } + val resources = mock(Resources::class.java) - @Test - fun internal_cameraTrackingChangedListener_onCameraTrackingChanged() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true + doReturn(resources).`when`(context).resources + doReturn(0f).`when`(resources) + .getDimension(R.dimen.mapbox_locationComponentTrackingMultiFingerMoveThreshold) + doReturn(0f).`when`(resources) + .getDimension(R.dimen.mapbox_locationComponentTrackingMultiFingerMoveThreshold) + locationComponent.activateLocationComponent(context, mock(Style::class.java), true, locationEngineRequest) + Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) + } - val cameraValueListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) - val layerValueListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) - `when`(locationCameraController.animationListeners).thenReturn(setOf(cameraValueListener)) - `when`(locationLayerController.animationListeners).thenReturn(setOf(layerValueListener)) - val cameraChangeListener: OnCameraTrackingChangedListener = mock(OnCameraTrackingChangedListener::class.java) - locationComponent.addOnCameraTrackingChangedListener(cameraChangeListener) + @Test + fun activateWithDefaultLocationEngineRequestAndOptionsTestDefaultLocationEngine() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), true, locationEngineRequest, locationComponentOptions) + Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) + Assert.assertNotNull(locationComponent.locationEngine) + } - locationComponent.cameraTrackingChangedListener.onCameraTrackingChanged(CameraMode.TRACKING_GPS) + @Test + fun activateWithDefaultLocationEngineRequestAndOptionsTestCustomLocationEngine() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), false, locationEngineRequest, locationComponentOptions) + Assert.assertEquals(locationEngineRequest, locationComponent.locationEngineRequest) + Assert.assertNull(locationComponent.locationEngine) + } - verify(locationAnimatorCoordinator).cancelZoomAnimation() - verify(locationAnimatorCoordinator).cancelTiltAnimation() - verify(locationAnimatorCoordinator).updateAnimatorListenerHolders(eq(setOf(cameraValueListener, layerValueListener))) - verify(locationAnimatorCoordinator).resetAllCameraAnimations(any(), anyBoolean()) - verify(locationAnimatorCoordinator).resetAllLayerAnimations() - verify(cameraChangeListener).onCameraTrackingChanged(CameraMode.TRACKING_GPS) - } + @Test + fun locationUpdatesWhenEnabledDisableTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + verify(locationEngine, times(0)).removeLocationUpdates(currentListener) + verify(locationEngine, times(0)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - @Test - fun internal_renderModeChangedListener_onRenderModeChanged() { - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + verify(locationEngine, times(0)).removeLocationUpdates(currentListener) + verify(locationEngine, times(0)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - val cameraListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) - val layerListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) - `when`(locationCameraController.animationListeners).thenReturn(setOf(cameraListener)) - `when`(locationLayerController.animationListeners).thenReturn(setOf(layerListener)) - val renderChangeListener: OnRenderModeChangedListener = mock(OnRenderModeChangedListener::class.java) - locationComponent.addOnRenderModeChangedListener(renderChangeListener) + locationComponent.isLocationComponentEnabled = true + verify(locationEngine).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) - locationComponent.renderModeChangedListener.onRenderModeChanged(RenderMode.NORMAL) + locationComponent.isLocationComponentEnabled = false + verify(locationEngine).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) + verify(locationEngine).removeLocationUpdates(currentListener) + } - verify(locationAnimatorCoordinator).updateAnimatorListenerHolders(eq(setOf(cameraListener, layerListener))) - verify(locationAnimatorCoordinator).resetAllCameraAnimations(any(), anyBoolean()) - verify(locationAnimatorCoordinator).resetAllLayerAnimations() - verify(renderChangeListener).onRenderModeChanged(RenderMode.NORMAL) - } + @Test + fun locationUpdatesWhenStartedStoppedTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true - @Test - fun tiltWhileTracking_notReady() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true + locationComponent.onStop() + verify(locationEngine).removeLocationUpdates(currentListener) - val callback = mock(MapboxMap.CancelableCallback::class.java) + locationComponent.onStart() + verify(locationEngine, times(2)).requestLocationUpdates(eq(locationEngineRequest), eq(currentListener), any(Looper::class.java)) + } - locationComponent.tiltWhileTracking(30.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) - } + @Test + fun locationUpdatesWhenNewRequestTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true - @Test - fun tiltWhileTracking_notTracking() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.NONE) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + val newRequest = mock(LocationEngineRequest::class.java) + locationComponent.locationEngineRequest = newRequest + verify(locationEngine).removeLocationUpdates(currentListener) + verify(locationEngine).requestLocationUpdates(eq(newRequest), eq(currentListener), any(Looper::class.java)) + } - val callback = mock(MapboxMap.CancelableCallback::class.java) + @Test + fun lastLocationUpdateOnStartTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true - locationComponent.tiltWhileTracking(30.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) - } + verify(locationEngine).getLastLocation(lastListener) + } - @Test - fun tiltWhileTracking_transitioning() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) - `when`(locationCameraController.isTransitioning).thenReturn(true) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + @Test + fun transitionCallbackFinishedTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - val callback = mock(MapboxMap.CancelableCallback::class.java) + val listener = mock(OnLocationCameraTransitionListener::class.java) - locationComponent.tiltWhileTracking(30.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) - } + val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) + locationComponent.setCameraMode(CameraMode.TRACKING, listener) + verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), callback.capture()) + callback.value.onLocationCameraTransitionFinished(CameraMode.TRACKING) - @Test - fun tiltWhileTracking_sucessful() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) - `when`(locationCameraController.isTransitioning).thenReturn(false) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + verify(listener).onLocationCameraTransitionFinished(CameraMode.TRACKING) + verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) + } - val callback = mock(MapboxMap.CancelableCallback::class.java) + @Test + fun transitionCallbackCanceledTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - locationComponent.tiltWhileTracking(30.0, 500L, callback) - verify(callback, times(0)).onCancel() - verify(locationAnimatorCoordinator).feedNewTilt(30.0, CameraPosition.DEFAULT, 500L, callback) - } + val listener = mock(OnLocationCameraTransitionListener::class.java) - @Test - fun zoomWhileTracking_notReady() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true + val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) + locationComponent.setCameraMode(CameraMode.TRACKING, listener) + verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), callback.capture()) + callback.value.onLocationCameraTransitionCanceled(CameraMode.TRACKING) - val callback = mock(MapboxMap.CancelableCallback::class.java) + verify(listener).onLocationCameraTransitionCanceled(CameraMode.TRACKING) + verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) + } - locationComponent.zoomWhileTracking(14.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) - } + @Test + fun transitionCustomFinishedTest() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - @Test - fun zoomWhileTracking_notTracking() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.NONE) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + val listener = mock(OnLocationCameraTransitionListener::class.java) - val callback = mock(MapboxMap.CancelableCallback::class.java) + val callback = ArgumentCaptor.forClass(OnLocationCameraTransitionListener::class.java) + locationComponent.setCameraMode(CameraMode.TRACKING, 1200, 14.0, 13.0, 45.0, listener) + verify(locationCameraController).setCameraMode(eq(CameraMode.TRACKING), any(), eq(1200L), eq(14.0), eq(13.0), eq(45.0), callback.capture()) + callback.value.onLocationCameraTransitionFinished(CameraMode.TRACKING) - locationComponent.zoomWhileTracking(14.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) - } + verify(listener).onLocationCameraTransitionFinished(CameraMode.TRACKING) + verify(locationAnimatorCoordinator).resetAllCameraAnimations(CameraPosition.DEFAULT, false) + } - @Test - fun zoomWhileTracking_transitioning() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) - `when`(locationCameraController.isTransitioning).thenReturn(true) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + @Test + fun compass_listenWhenConsumedByNoneCamera() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - val callback = mock(MapboxMap.CancelableCallback::class.java) + `when`(locationCameraController.isConsumingCompass).thenReturn(true) + locationComponent.cameraMode = CameraMode.NONE_COMPASS + verify(compassEngine).addCompassListener(any(CompassListener::class.java)) + } - locationComponent.zoomWhileTracking(14.0, 500L, callback) - verify(callback).onCancel() - verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) - } + @Test + fun compass_listenWhenConsumedByTrackingCamera() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - @Test - fun zoomWhileTracking_successful() { - `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) - `when`(locationCameraController.isTransitioning).thenReturn(false) - locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() + `when`(locationCameraController.isConsumingCompass).thenReturn(true) + locationComponent.cameraMode = CameraMode.TRACKING_COMPASS + verify(compassEngine).addCompassListener(any(CompassListener::class.java)) + } - val callback = mock(MapboxMap.CancelableCallback::class.java) + @Test + fun compass_listenWhenConsumedByLayer() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - locationComponent.zoomWhileTracking(14.0, 500L, callback) - verify(callback, times(0)).onCancel() - verify(locationAnimatorCoordinator).feedNewZoomLevel(14.0, CameraPosition.DEFAULT, 500L, callback) - } + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + verify(compassEngine).addCompassListener(any(CompassListener::class.java)) + } - @Test - fun newLocation_accuracy_symbolLayerRadiusValue() { - val location = Location("test") - location.accuracy = 50f - val projection: Projection = mock(Projection::class.java) - `when`(projection.getMetersPerPixelAtLatitude(location.latitude)).thenReturn(10.0) - `when`(mapboxMap.projection).thenReturn(projection) - `when`(style.isFullyLoaded).thenReturn(true) - locationComponent.activateLocationComponent( - LocationComponentActivationOptions.builder(context, style) - .locationComponentOptions(locationComponentOptions) - .useDefaultLocationEngine(false) - .build() - ) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() - locationComponent.forceLocationUpdate(location) + @Test + fun compass_notListenWhenNotConsumed() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - val radius = (location.accuracy * (1 / 10.0)).toFloat() - verify(locationAnimatorCoordinator).feedNewAccuracyRadius(radius, false) - } + `when`(locationLayerController.isConsumingCompass).thenReturn(false) + `when`(locationCameraController.isConsumingCompass).thenReturn(false) + locationComponent.renderMode = RenderMode.GPS + locationComponent.renderMode = RenderMode.NORMAL + locationComponent.cameraMode = CameraMode.TRACKING + locationComponent.cameraMode = CameraMode.NONE + locationComponent.cameraMode = CameraMode.NONE_GPS + locationComponent.cameraMode = CameraMode.TRACKING_GPS + locationComponent.cameraMode = CameraMode.TRACKING_GPS_NORTH + verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) + } - @Test - fun newLocation_accuracy_indicatorLayerRadiusValue() { - val location = Location("test") - location.accuracy = 50f - `when`(style.isFullyLoaded).thenReturn(true) - locationComponent = LocationComponent(mapboxMap, transform, developerAnimationListeners, currentListener, lastListener, locationLayerController, locationCameraController, locationAnimatorCoordinator, staleStateManager, compassEngine, locationEngineProvider, true) - locationComponent.activateLocationComponent( - LocationComponentActivationOptions.builder(context, style) - .locationComponentOptions(locationComponentOptions) - .useSpecializedLocationLayer(true) - .useDefaultLocationEngine(false) - .build() - ) - locationComponent.isLocationComponentEnabled = true - locationComponent.onStart() - locationComponent.forceLocationUpdate(location) + @Test + fun compass_removeListenerOnChange() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) - verify(locationAnimatorCoordinator).feedNewAccuracyRadius(location.accuracy, false) - } -} \ No newline at end of file + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + `when`(locationLayerController.isConsumingCompass).thenReturn(false) + locationComponent.renderMode = RenderMode.NORMAL + verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_removeListenerOnStop() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + locationComponent.onStop() + verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_reAddListenerOnStart() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + locationComponent.onStop() + locationComponent.onStart() + verify(compassEngine, times(2)).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_removeListenerOnStyleStartLoad() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + locationComponent.onStartLoadingMap() + verify(compassEngine).removeCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_reAddListenerOnStyleLoadFinished() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + locationComponent.onStartLoadingMap() + locationComponent.onFinishLoadingStyle() + verify(compassEngine, times(2)).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_reAddListenerOnlyWhenEnabled() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + locationComponent.isLocationComponentEnabled = false + + locationComponent.onStartLoadingMap() + locationComponent.onFinishLoadingStyle() + verify(compassEngine).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_notAdListenerWhenDisabled() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_notAdListenerWhenStopped() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + verify(compassEngine, never()).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun compass_notAddListenerWhenLayerNotReady() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.onStart() + locationComponent.isLocationComponentEnabled = true + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationLayerController.isConsumingCompass).thenReturn(true) + locationComponent.renderMode = RenderMode.COMPASS + + verify(compassEngine, times(1)).addCompassListener(any(CompassListener::class.java)) + + locationComponent.onStartLoadingMap() + // Layer should be disabled at this point + locationComponent.setCameraMode(CameraMode.TRACKING_COMPASS) + verify(compassEngine, times(1)).addCompassListener(any(CompassListener::class.java)) + } + + @Test + fun developerAnimationCalled() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + for (listener in developerAnimationListeners) { + listener.onDeveloperAnimationStarted() + } + verify(locationCameraController).setCameraMode(eq(CameraMode.NONE), isNull(), eq(TRANSITION_ANIMATION_DURATION_MS), isNull(), isNull(), isNull(), any()) + } + + @Test + fun internal_cameraTrackingChangedListener_onCameraTrackingDismissed() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + + val cameraChangeListener: OnCameraTrackingChangedListener = mock(OnCameraTrackingChangedListener::class.java) + locationComponent.addOnCameraTrackingChangedListener(cameraChangeListener) + + locationComponent.cameraTrackingChangedListener.onCameraTrackingDismissed() + + verify(cameraChangeListener).onCameraTrackingDismissed() + } + + @Test + fun internal_cameraTrackingChangedListener_onCameraTrackingChanged() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + + val cameraValueListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) + val layerValueListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) + `when`(locationCameraController.animationListeners).thenReturn(setOf(cameraValueListener)) + `when`(locationLayerController.animationListeners).thenReturn(setOf(layerValueListener)) + val cameraChangeListener: OnCameraTrackingChangedListener = mock(OnCameraTrackingChangedListener::class.java) + locationComponent.addOnCameraTrackingChangedListener(cameraChangeListener) + + locationComponent.cameraTrackingChangedListener.onCameraTrackingChanged(CameraMode.TRACKING_GPS) + + verify(locationAnimatorCoordinator).cancelZoomAnimation() + verify(locationAnimatorCoordinator).cancelTiltAnimation() + verify(locationAnimatorCoordinator).updateAnimatorListenerHolders(eq(setOf(cameraValueListener, layerValueListener))) + verify(locationAnimatorCoordinator).resetAllCameraAnimations(any(), anyBoolean()) + verify(locationAnimatorCoordinator).resetAllLayerAnimations() + verify(cameraChangeListener).onCameraTrackingChanged(CameraMode.TRACKING_GPS) + } + + @Test + fun internal_renderModeChangedListener_onRenderModeChanged() { + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + + val cameraListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) + val layerListener: AnimatorListenerHolder = mock(AnimatorListenerHolder::class.java) + `when`(locationCameraController.animationListeners).thenReturn(setOf(cameraListener)) + `when`(locationLayerController.animationListeners).thenReturn(setOf(layerListener)) + val renderChangeListener: OnRenderModeChangedListener = mock(OnRenderModeChangedListener::class.java) + locationComponent.addOnRenderModeChangedListener(renderChangeListener) + + locationComponent.renderModeChangedListener.onRenderModeChanged(RenderMode.NORMAL) + + verify(locationAnimatorCoordinator).updateAnimatorListenerHolders(eq(setOf(cameraListener, layerListener))) + verify(locationAnimatorCoordinator).resetAllCameraAnimations(any(), anyBoolean()) + verify(locationAnimatorCoordinator).resetAllLayerAnimations() + verify(renderChangeListener).onRenderModeChanged(RenderMode.NORMAL) + } + + @Test + fun tiltWhileTracking_notReady() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.tiltWhileTracking(30.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun tiltWhileTracking_notTracking() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.NONE) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.tiltWhileTracking(30.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun tiltWhileTracking_transitioning() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) + `when`(locationCameraController.isTransitioning).thenReturn(true) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.tiltWhileTracking(30.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewTilt(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun tiltWhileTracking_sucessful() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) + `when`(locationCameraController.isTransitioning).thenReturn(false) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.tiltWhileTracking(30.0, 500L, callback) + verify(callback, times(0)).onCancel() + verify(locationAnimatorCoordinator).feedNewTilt(30.0, CameraPosition.DEFAULT, 500L, callback) + } + + @Test + fun zoomWhileTracking_notReady() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.zoomWhileTracking(14.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun zoomWhileTracking_notTracking() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.NONE) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.zoomWhileTracking(14.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun zoomWhileTracking_transitioning() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) + `when`(locationCameraController.isTransitioning).thenReturn(true) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.zoomWhileTracking(14.0, 500L, callback) + verify(callback).onCancel() + verify(locationAnimatorCoordinator, times(0)).feedNewZoomLevel(anyDouble(), any(), anyLong(), any()) + } + + @Test + fun zoomWhileTracking_successful() { + `when`(mapboxMap.cameraPosition).thenReturn(CameraPosition.DEFAULT) + `when`(locationCameraController.cameraMode).thenReturn(CameraMode.TRACKING) + `when`(locationCameraController.isTransitioning).thenReturn(false) + locationComponent.activateLocationComponent(context, mock(Style::class.java), locationEngine, locationEngineRequest, locationComponentOptions) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + + val callback = mock(MapboxMap.CancelableCallback::class.java) + + locationComponent.zoomWhileTracking(14.0, 500L, callback) + verify(callback, times(0)).onCancel() + verify(locationAnimatorCoordinator).feedNewZoomLevel(14.0, CameraPosition.DEFAULT, 500L, callback) + } + + @Test + fun newLocation_accuracy_symbolLayerRadiusValue() { + val location = Location("test") + location.accuracy = 50f + val projection: Projection = mock(Projection::class.java) + `when`(projection.getMetersPerPixelAtLatitude(location.latitude)).thenReturn(10.0) + `when`(mapboxMap.projection).thenReturn(projection) + `when`(style.isFullyLoaded).thenReturn(true) + locationComponent.activateLocationComponent( + LocationComponentActivationOptions.builder(context, style) + .locationComponentOptions(locationComponentOptions) + .useDefaultLocationEngine(false) + .build() + ) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + locationComponent.forceLocationUpdate(location) + + val radius = (location.accuracy * (1 / 10.0)).toFloat() + verify(locationAnimatorCoordinator).feedNewAccuracyRadius(radius, false) + } + + @Test + fun newLocation_accuracy_indicatorLayerRadiusValue() { + val location = Location("test") + location.accuracy = 50f + `when`(style.isFullyLoaded).thenReturn(true) + locationComponent = LocationComponent(mapboxMap, transform, developerAnimationListeners, currentListener, lastListener, locationLayerController, locationCameraController, locationAnimatorCoordinator, staleStateManager, compassEngine, locationEngineProvider, true) + locationComponent.activateLocationComponent( + LocationComponentActivationOptions.builder(context, style) + .locationComponentOptions(locationComponentOptions) + .useSpecializedLocationLayer(true) + .useDefaultLocationEngine(false) + .build() + ) + locationComponent.isLocationComponentEnabled = true + locationComponent.onStart() + locationComponent.forceLocationUpdate(location) + + verify(locationAnimatorCoordinator).feedNewAccuracyRadius(location.accuracy, false) + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/MapboxAnimatorTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/MapboxAnimatorTest.kt index 0c5b770b4..683cf3f0e 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/MapboxAnimatorTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/MapboxAnimatorTest.kt @@ -11,33 +11,33 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class MapboxAnimatorTest { - @Test - fun fps_unlimited() { - val valueAnimator = mockk() - every { valueAnimator.animatedValue } answers { 5f } - val listener = mockk>() - every { listener.onNewAnimationValue(any()) } answers {} - val mapboxAnimator = MapboxFloatAnimator(floatArrayOf(0f, 10f).toTypedArray(), listener, Int.MAX_VALUE) + @Test + fun fps_unlimited() { + val valueAnimator = mockk() + every { valueAnimator.animatedValue } answers { 5f } + val listener = mockk>() + every { listener.onNewAnimationValue(any()) } answers {} + val mapboxAnimator = MapboxFloatAnimator(floatArrayOf(0f, 10f).toTypedArray(), listener, Int.MAX_VALUE) - for (i in 0 until 5) - mapboxAnimator.onAnimationUpdate(valueAnimator) + for (i in 0 until 5) + mapboxAnimator.onAnimationUpdate(valueAnimator) - verify(exactly = 5) { listener.onNewAnimationValue(5f) } - } - - @Test - fun fps_limited() { - val valueAnimator = mockk() - every { valueAnimator.animatedValue } answers { 5f } - val listener = mockk>() - every { listener.onNewAnimationValue(any()) } answers {} - val mapboxAnimator = MapboxFloatAnimator(floatArrayOf(0f, 10f).toTypedArray(), listener, 5) - - for (i in 0 until 5) { - mapboxAnimator.onAnimationUpdate(valueAnimator) - Thread.sleep(150) + verify(exactly = 5) { listener.onNewAnimationValue(5f) } } - verify(exactly = 3) { listener.onNewAnimationValue(5f) } - } -} \ No newline at end of file + @Test + fun fps_limited() { + val valueAnimator = mockk() + every { valueAnimator.animatedValue } answers { 5f } + val listener = mockk>() + every { listener.onNewAnimationValue(any()) } answers {} + val mapboxAnimator = MapboxFloatAnimator(floatArrayOf(0f, 10f).toTypedArray(), listener, 5) + + for (i in 0 until 5) { + mapboxAnimator.onAnimationUpdate(valueAnimator) + Thread.sleep(150) + } + + verify(exactly = 3) { listener.onNewAnimationValue(5f) } + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/log/LoggerTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/log/LoggerTest.kt index 82e1c67f6..e75fe3ef8 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/log/LoggerTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/log/LoggerTest.kt @@ -10,84 +10,84 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class LoggerTest { - private val logger: LoggerDefinition = mockk(relaxed = true) + private val logger: LoggerDefinition = mockk(relaxed = true) - @Before - fun setUp() { - Logger.setLoggerDefinition(logger) - } + @Before + fun setUp() { + Logger.setLoggerDefinition(logger) + } - @Test - fun verbosityLogLevel() { - Logger.setVerbosity(Logger.VERBOSE) - Logger.v(TAG, MESSAGE) - verify { logger.v(TAG, MESSAGE) } - } + @Test + fun verbosityLogLevel() { + Logger.setVerbosity(Logger.VERBOSE) + Logger.v(TAG, MESSAGE) + verify { logger.v(TAG, MESSAGE) } + } - @Test - fun verbosityLogLevelIgnore() { - Logger.setVerbosity(Logger.DEBUG) - Logger.v(TAG, MESSAGE) - verify(exactly = 0) { logger.v(TAG, MESSAGE) } - } + @Test + fun verbosityLogLevelIgnore() { + Logger.setVerbosity(Logger.DEBUG) + Logger.v(TAG, MESSAGE) + verify(exactly = 0) { logger.v(TAG, MESSAGE) } + } - @Test - fun debugLogLevel() { - Logger.setVerbosity(Logger.VERBOSE) - Logger.d(TAG, MESSAGE) - verify { logger.d(TAG, MESSAGE) } - } + @Test + fun debugLogLevel() { + Logger.setVerbosity(Logger.VERBOSE) + Logger.d(TAG, MESSAGE) + verify { logger.d(TAG, MESSAGE) } + } - @Test - fun debugLogLevelIgnore() { - Logger.setVerbosity(Logger.WARN) - Logger.d(TAG, MESSAGE) - verify(exactly = 0) { logger.d(TAG, MESSAGE) } - } + @Test + fun debugLogLevelIgnore() { + Logger.setVerbosity(Logger.WARN) + Logger.d(TAG, MESSAGE) + verify(exactly = 0) { logger.d(TAG, MESSAGE) } + } - @Test - fun warnLogLevel() { - Logger.setVerbosity(Logger.WARN) - Logger.w(TAG, MESSAGE) - verify { logger.w(TAG, MESSAGE) } - } + @Test + fun warnLogLevel() { + Logger.setVerbosity(Logger.WARN) + Logger.w(TAG, MESSAGE) + verify { logger.w(TAG, MESSAGE) } + } - @Test - fun warnLogLevelIgnore() { - Logger.setVerbosity(Logger.ERROR) - Logger.w(TAG, MESSAGE) - verify(exactly = 0) { logger.w(TAG, MESSAGE) } - } + @Test + fun warnLogLevelIgnore() { + Logger.setVerbosity(Logger.ERROR) + Logger.w(TAG, MESSAGE) + verify(exactly = 0) { logger.w(TAG, MESSAGE) } + } - @Test - fun errorLogLevel() { - Logger.setVerbosity(Logger.ERROR) - Logger.e(TAG, MESSAGE) - verify { logger.e(TAG, MESSAGE) } - } + @Test + fun errorLogLevel() { + Logger.setVerbosity(Logger.ERROR) + Logger.e(TAG, MESSAGE) + verify { logger.e(TAG, MESSAGE) } + } - @Test - fun errorLogLevelIgnore() { - Logger.setVerbosity(Logger.NONE) - Logger.e(TAG, MESSAGE) - verify(exactly = 0) { logger.e(TAG, MESSAGE) } - } + @Test + fun errorLogLevelIgnore() { + Logger.setVerbosity(Logger.NONE) + Logger.e(TAG, MESSAGE) + verify(exactly = 0) { logger.e(TAG, MESSAGE) } + } - @Test - fun noneLogLevelIgnore() { - Logger.setVerbosity(Logger.NONE) - Logger.v(TAG, MESSAGE) - Logger.d(TAG, MESSAGE) - Logger.w(TAG, MESSAGE) - Logger.e(TAG, MESSAGE) - verify(exactly = 0) { logger.v(TAG, MESSAGE) } - verify(exactly = 0) { logger.d(TAG, MESSAGE) } - verify(exactly = 0) { logger.w(TAG, MESSAGE) } - verify(exactly = 0) { logger.e(TAG, MESSAGE) } - } + @Test + fun noneLogLevelIgnore() { + Logger.setVerbosity(Logger.NONE) + Logger.v(TAG, MESSAGE) + Logger.d(TAG, MESSAGE) + Logger.w(TAG, MESSAGE) + Logger.e(TAG, MESSAGE) + verify(exactly = 0) { logger.v(TAG, MESSAGE) } + verify(exactly = 0) { logger.d(TAG, MESSAGE) } + verify(exactly = 0) { logger.w(TAG, MESSAGE) } + verify(exactly = 0) { logger.e(TAG, MESSAGE) } + } - companion object { - const val TAG: String = "TAG" - const val MESSAGE: String = "message" - } -} \ No newline at end of file + companion object { + const val TAG: String = "TAG" + const val MESSAGE: String = "message" + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsAttrsTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsAttrsTest.kt index ee8024257..1d478b0c5 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsAttrsTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsAttrsTest.kt @@ -16,86 +16,86 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class MapboxMapOptionsAttrsTest { - @RelaxedMockK - private lateinit var options: MapboxMapOptions + @RelaxedMockK + private lateinit var options: MapboxMapOptions - @RelaxedMockK - private lateinit var typedArray: TypedArray + @RelaxedMockK + private lateinit var typedArray: TypedArray - @RelaxedMockK - private lateinit var context: Context + @RelaxedMockK + private lateinit var context: Context - @RelaxedMockK - private lateinit var resources: Resources + @RelaxedMockK + private lateinit var resources: Resources - @Before - fun setUp() { - MockKAnnotations.init(this) - every { - context.resources - }.returns(resources) - } - - @Test - fun enabledLocalIdeographFontFamily() { - mockEnableLocalIdeograph(enabled = true) - - val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) - - verify(exactly = 1) { - options.localIdeographFontFamily(any()) + @Before + fun setUp() { + MockKAnnotations.init(this) + every { + context.resources + }.returns(resources) } - } - @Test - fun localIdeographFontFamily() { - mockEnableLocalIdeograph(enabled = true) + @Test + fun enabledLocalIdeographFontFamily() { + mockEnableLocalIdeograph(enabled = true) - val font = "foo" - mockLocalIdeographString(font) + val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) - val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) - - verify(exactly = 1) { - options.localIdeographFontFamily(font) + verify(exactly = 1) { + options.localIdeographFontFamily(any()) + } } - } - @Test - fun localIdeographFontFamilies() { - mockEnableLocalIdeograph(enabled = true) + @Test + fun localIdeographFontFamily() { + mockEnableLocalIdeograph(enabled = true) - val fonts = arrayOf("foo", "bar") - mockLocalIdeographStringArray(fonts) + val font = "foo" + mockLocalIdeographString(font) - val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) + val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) - verify(exactly = 1) { - options.localIdeographFontFamily(*fonts) + verify(exactly = 1) { + options.localIdeographFontFamily(font) + } } - } - private fun mockEnableLocalIdeograph(enabled: Boolean) { - every { - typedArray.getBoolean(R.styleable.mapbox_MapView_mapbox_localIdeographEnabled, true) - }.returns(enabled) - } + @Test + fun localIdeographFontFamilies() { + mockEnableLocalIdeograph(enabled = true) - private fun mockLocalIdeographString(font: String) { - every { - typedArray.getString(R.styleable.mapbox_MapView_mapbox_localIdeographFontFamily) - }.returns(font) - } + val fonts = arrayOf("foo", "bar") + mockLocalIdeographStringArray(fonts) - private fun mockLocalIdeographStringArray(fonts: Array) { - val resId = 9000 + val options = MapboxMapOptions.createFromAttributes(options, context, typedArray) - every { - typedArray.getResourceId(R.styleable.mapbox_MapView_mapbox_localIdeographFontFamilies, 0) - }.returns(resId) + verify(exactly = 1) { + options.localIdeographFontFamily(*fonts) + } + } - every { - resources.getStringArray(resId) - }.returns(fonts) - } -} \ No newline at end of file + private fun mockEnableLocalIdeograph(enabled: Boolean) { + every { + typedArray.getBoolean(R.styleable.mapbox_MapView_mapbox_localIdeographEnabled, true) + }.returns(enabled) + } + + private fun mockLocalIdeographString(font: String) { + every { + typedArray.getString(R.styleable.mapbox_MapView_mapbox_localIdeographFontFamily) + }.returns(font) + } + + private fun mockLocalIdeographStringArray(fonts: Array) { + val resId = 9000 + + every { + typedArray.getResourceId(R.styleable.mapbox_MapView_mapbox_localIdeographFontFamilies, 0) + }.returns(resId) + + every { + resources.getStringArray(resId) + }.returns(fonts) + } +} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.kt b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.kt index d78579223..54ec46f66 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.kt +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.kt @@ -16,211 +16,211 @@ import org.robolectric.RobolectricTestRunner @RunWith(RobolectricTestRunner::class) class MapboxMapTest { - private lateinit var mapboxMap: MapboxMap + private lateinit var mapboxMap: MapboxMap - private lateinit var nativeMapView: NativeMap + private lateinit var nativeMapView: NativeMap - private lateinit var transform: Transform + private lateinit var transform: Transform - private lateinit var cameraChangeDispatcher: CameraChangeDispatcher + private lateinit var cameraChangeDispatcher: CameraChangeDispatcher - private lateinit var developerAnimationListener: MapboxMap.OnDeveloperAnimationListener + private lateinit var developerAnimationListener: MapboxMap.OnDeveloperAnimationListener - @Before - fun setup() { - cameraChangeDispatcher = spyk() - developerAnimationListener = mockk(relaxed = true) - nativeMapView = mockk(relaxed = true) - transform = mockk(relaxed = true) - mapboxMap = MapboxMap(nativeMapView, transform, mockk(relaxed = true), null, null, cameraChangeDispatcher, listOf(developerAnimationListener)) - every { nativeMapView.isDestroyed } returns false - every { nativeMapView.nativePtr } returns 5 - mapboxMap.injectLocationComponent(spyk()) - mapboxMap.setStyle(Style.MAPBOX_STREETS) - mapboxMap.onFinishLoadingStyle() - } + @Before + fun setup() { + cameraChangeDispatcher = spyk() + developerAnimationListener = mockk(relaxed = true) + nativeMapView = mockk(relaxed = true) + transform = mockk(relaxed = true) + mapboxMap = MapboxMap(nativeMapView, transform, mockk(relaxed = true), null, null, cameraChangeDispatcher, listOf(developerAnimationListener)) + every { nativeMapView.isDestroyed } returns false + every { nativeMapView.nativePtr } returns 5 + mapboxMap.injectLocationComponent(spyk()) + mapboxMap.setStyle(Style.MAPBOX_STREETS) + mapboxMap.onFinishLoadingStyle() + } - @Test - fun testTransitionOptions() { - val expected = TransitionOptions(100, 200) - mapboxMap.style?.transition = expected - verify { nativeMapView.transitionOptions = expected } - } + @Test + fun testTransitionOptions() { + val expected = TransitionOptions(100, 200) + mapboxMap.style?.transition = expected + verify { nativeMapView.transitionOptions = expected } + } - @Test - fun testMoveCamera() { - val callback = mockk() - val target = LatLng(1.0, 2.0) - val expected = CameraPosition.Builder().target(target).build() - val update = CameraUpdateFactory.newCameraPosition(expected) - mapboxMap.moveCamera(update, callback) - verify { transform.moveCamera(mapboxMap, update, callback) } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testMoveCamera() { + val callback = mockk() + val target = LatLng(1.0, 2.0) + val expected = CameraPosition.Builder().target(target).build() + val update = CameraUpdateFactory.newCameraPosition(expected) + mapboxMap.moveCamera(update, callback) + verify { transform.moveCamera(mapboxMap, update, callback) } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testEaseCamera() { - val callback = mockk() - val target = LatLng(1.0, 2.0) - val expected = CameraPosition.Builder().target(target).build() - val update = CameraUpdateFactory.newCameraPosition(expected) - mapboxMap.easeCamera(update, callback) - verify { transform.easeCamera(mapboxMap, update, MapboxConstants.ANIMATION_DURATION, true, callback) } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testEaseCamera() { + val callback = mockk() + val target = LatLng(1.0, 2.0) + val expected = CameraPosition.Builder().target(target).build() + val update = CameraUpdateFactory.newCameraPosition(expected) + mapboxMap.easeCamera(update, callback) + verify { transform.easeCamera(mapboxMap, update, MapboxConstants.ANIMATION_DURATION, true, callback) } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testAnimateCamera() { - val callback = mockk() - val target = LatLng(1.0, 2.0) - val expected = CameraPosition.Builder().target(target).build() - val update = CameraUpdateFactory.newCameraPosition(expected) - mapboxMap.animateCamera(update, callback) - verify { transform.animateCamera(mapboxMap, update, MapboxConstants.ANIMATION_DURATION, callback) } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testAnimateCamera() { + val callback = mockk() + val target = LatLng(1.0, 2.0) + val expected = CameraPosition.Builder().target(target).build() + val update = CameraUpdateFactory.newCameraPosition(expected) + mapboxMap.animateCamera(update, callback) + verify { transform.animateCamera(mapboxMap, update, MapboxConstants.ANIMATION_DURATION, callback) } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testScrollBy() { - mapboxMap.scrollBy(100f, 200f) - verify { nativeMapView.moveBy(100.0, 200.0, 0) } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testScrollBy() { + mapboxMap.scrollBy(100f, 200f) + verify { nativeMapView.moveBy(100.0, 200.0, 0) } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testResetNorth() { - mapboxMap.resetNorth() - verify { transform.resetNorth() } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testResetNorth() { + mapboxMap.resetNorth() + verify { transform.resetNorth() } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testFocalBearing() { - mapboxMap.setFocalBearing(35.0, 100f, 200f, 1000) - verify { transform.setBearing(35.0, 100f, 200f, 1000) } - verify { developerAnimationListener.onDeveloperAnimationStarted() } - } + @Test + fun testFocalBearing() { + mapboxMap.setFocalBearing(35.0, 100f, 200f, 1000) + verify { transform.setBearing(35.0, 100f, 200f, 1000) } + verify { developerAnimationListener.onDeveloperAnimationStarted() } + } - @Test - fun testMinZoom() { - mapboxMap.setMinZoomPreference(10.0) - verify { transform.minZoom = 10.0 } - } + @Test + fun testMinZoom() { + mapboxMap.setMinZoomPreference(10.0) + verify { transform.minZoom = 10.0 } + } - @Test - fun testMaxZoom() { - mapboxMap.setMaxZoomPreference(10.0) - verify { transform.maxZoom = 10.0 } - } + @Test + fun testMaxZoom() { + mapboxMap.setMaxZoomPreference(10.0) + verify { transform.maxZoom = 10.0 } + } - @Test - fun testMinPitch() { - mapboxMap.setMinPitchPreference(10.0) - verify { transform.minPitch = 10.0 } - } + @Test + fun testMinPitch() { + mapboxMap.setMinPitchPreference(10.0) + verify { transform.minPitch = 10.0 } + } - @Test - fun testMaxPitch() { - mapboxMap.setMaxPitchPreference(10.0) - verify { transform.maxPitch = 10.0 } - } + @Test + fun testMaxPitch() { + mapboxMap.setMaxPitchPreference(10.0) + verify { transform.maxPitch = 10.0 } + } - @Test - fun testFpsListener() { - val fpsChangedListener = mockk() - mapboxMap.onFpsChangedListener = fpsChangedListener - assertEquals("Listener should match", fpsChangedListener, mapboxMap.onFpsChangedListener) - } + @Test + fun testFpsListener() { + val fpsChangedListener = mockk() + mapboxMap.onFpsChangedListener = fpsChangedListener + assertEquals("Listener should match", fpsChangedListener, mapboxMap.onFpsChangedListener) + } - @Test - fun testTilePrefetch() { - mapboxMap.prefetchesTiles = true - verify { nativeMapView.prefetchTiles = true } - } + @Test + fun testTilePrefetch() { + mapboxMap.prefetchesTiles = true + verify { nativeMapView.prefetchTiles = true } + } - @Test - fun testGetPrefetchZoomDelta() { - every { nativeMapView.prefetchZoomDelta } answers { 3 } - assertEquals(3, mapboxMap.prefetchZoomDelta) - } + @Test + fun testGetPrefetchZoomDelta() { + every { nativeMapView.prefetchZoomDelta } answers { 3 } + assertEquals(3, mapboxMap.prefetchZoomDelta) + } - @Test - fun testSetPrefetchZoomDelta() { - mapboxMap.prefetchZoomDelta = 2 - verify { nativeMapView.prefetchZoomDelta = 2 } - } + @Test + fun testSetPrefetchZoomDelta() { + mapboxMap.prefetchZoomDelta = 2 + verify { nativeMapView.prefetchZoomDelta = 2 } + } - @Test - fun testCameraForLatLngBounds() { - val bounds = LatLngBounds.Builder().include(LatLng()).include(LatLng(1.0, 1.0)).build() - mapboxMap.setLatLngBoundsForCameraTarget(bounds) - verify { nativeMapView.setLatLngBounds(bounds) } - } + @Test + fun testCameraForLatLngBounds() { + val bounds = LatLngBounds.Builder().include(LatLng()).include(LatLng(1.0, 1.0)).build() + mapboxMap.setLatLngBoundsForCameraTarget(bounds) + verify { nativeMapView.setLatLngBounds(bounds) } + } - @Test(expected = IllegalArgumentException::class) - fun testAnimateCameraChecksDurationPositive() { - mapboxMap.animateCamera(CameraUpdateFactory.newLatLng(LatLng(30.0, 30.0)), 0, null) - } + @Test(expected = IllegalArgumentException::class) + fun testAnimateCameraChecksDurationPositive() { + mapboxMap.animateCamera(CameraUpdateFactory.newLatLng(LatLng(30.0, 30.0)), 0, null) + } - @Test(expected = IllegalArgumentException::class) - fun testEaseCameraChecksDurationPositive() { - mapboxMap.easeCamera(CameraUpdateFactory.newLatLng(LatLng(30.0, 30.0)), 0, null) - } + @Test(expected = IllegalArgumentException::class) + fun testEaseCameraChecksDurationPositive() { + mapboxMap.easeCamera(CameraUpdateFactory.newLatLng(LatLng(30.0, 30.0)), 0, null) + } - @Test - fun testGetNativeMapPtr() { - assertEquals(5, mapboxMap.nativeMapPtr) - } + @Test + fun testGetNativeMapPtr() { + assertEquals(5, mapboxMap.nativeMapPtr) + } - @Test - fun testNativeMapIsNotCalledOnStateSave() { - clearMocks(nativeMapView) - mapboxMap.onSaveInstanceState(mockk(relaxed = true)) - verify { nativeMapView wasNot Called } - } + @Test + fun testNativeMapIsNotCalledOnStateSave() { + clearMocks(nativeMapView) + mapboxMap.onSaveInstanceState(mockk(relaxed = true)) + verify { nativeMapView wasNot Called } + } - @Test - fun testCameraChangeDispatcherCleared() { - mapboxMap.onDestroy() - verify { cameraChangeDispatcher.onDestroy() } - } + @Test + fun testCameraChangeDispatcherCleared() { + mapboxMap.onDestroy() + verify { cameraChangeDispatcher.onDestroy() } + } - @Test - fun testStyleClearedOnDestroy() { - val style = mockk