[android] reworked CameraAnimateTest

1 files changed, 207 insertions, 78 deletions

diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraAnimateTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraAnimateTest.java
index 55a27ca02d..d4283669f3 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraAnimateTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraAnimateTest.java
@@ -1,16 +1,19 @@
 package com.mapbox.mapboxsdk.testapp.camera;
 
 import android.graphics.PointF;
+import android.support.test.espresso.Espresso;
+import android.support.test.espresso.IdlingRegistry;
+import android.support.test.espresso.idling.CountingIdlingResource;
 
 import com.mapbox.mapboxsdk.camera.CameraPosition;
 import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
 import com.mapbox.mapboxsdk.geometry.LatLng;
 import com.mapbox.mapboxsdk.geometry.LatLngBounds;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
 import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;
 import com.mapbox.mapboxsdk.testapp.activity.espresso.DeviceIndependentTestActivity;
 import com.mapbox.mapboxsdk.testapp.utils.TestConstants;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
 import static com.mapbox.mapboxsdk.testapp.action.MapboxMapAction.invoke;
@@ -18,13 +21,21 @@ import static org.junit.Assert.assertEquals;
 
 public class CameraAnimateTest extends BaseActivityTest {
 
+  private final CountingIdlingResource animationIdlingResource =
+    new CountingIdlingResource("animation_idling_resource");
+
   @Override
   protected Class getActivityClass() {
     return DeviceIndependentTestActivity.class;
   }
 
+  @Override
+  public void beforeTest() {
+    super.beforeTest();
+    IdlingRegistry.getInstance().register(animationIdlingResource);
+  }
+
   @Test
-  @Ignore
   public void testAnimateToCameraPositionTarget() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -34,36 +45,54 @@ public class CameraAnimateTest extends BaseActivityTest {
         new LatLng()).zoom(zoom).bearing(0).tilt(0).build();
       CameraPosition cameraPosition = mapboxMap.getCameraPosition();
       assertEquals("Default camera position should match default", cameraPosition, initialPosition);
-      mapboxMap.animateCamera(CameraUpdateFactory.newLatLng(moveTarget));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera position latitude should match", cameraPosition.target.getLatitude(),
-        moveTarget.getLatitude(), TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved camera position longitude should match", cameraPosition.target.getLongitude(),
-        moveTarget.getLongitude(), TestConstants.LAT_LNG_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.newLatLng(moveTarget), new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, moveTarget, zoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, moveTarget, zoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToCameraPositionTargetZoom() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final float moveZoom = 15.5f;
       final LatLng moveTarget = new LatLng(1.0000000001, 1.0000000003);
-      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(moveTarget, moveZoom));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera position latitude should match", cameraPosition.target.getLatitude(),
-        moveTarget.getLatitude(), TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved camera position longitude should match", cameraPosition.target.getLongitude(),
-        moveTarget.getLongitude(), TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved zoom should match", cameraPosition.zoom, moveZoom, TestConstants.ZOOM_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(moveTarget, moveZoom), new MapboxMap
+        .CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, moveTarget, moveZoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, moveTarget, moveZoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToCameraPosition() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -72,28 +101,33 @@ public class CameraAnimateTest extends BaseActivityTest {
       final float moveTilt = 45.5f;
       final float moveBearing = 12.5f;
 
+      animationIdlingResource.increment();
       mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(
         new CameraPosition.Builder()
           .target(moveTarget)
           .zoom(moveZoom)
           .tilt(moveTilt)
           .bearing(moveBearing)
-          .build())
-      );
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera position latitude should match", cameraPosition.target.getLatitude(),
-        moveTarget.getLatitude(), TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved camera position longitude should match", cameraPosition.target.getLongitude(),
-        moveTarget.getLongitude(), TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved zoom should match", cameraPosition.zoom, moveZoom, TestConstants.ZOOM_DELTA);
-      assertEquals("Moved zoom should match", cameraPosition.tilt, moveTilt, TestConstants.TILT_DELTA);
-      assertEquals("Moved bearing should match", cameraPosition.bearing, moveBearing, TestConstants.BEARING_DELTA);
+          .build()),
+        new MapboxMap.CancelableCallback() {
+          @Override
+          public void onCancel() {
+            verifyCameraPosition(mapboxMap, moveTarget, moveZoom, moveBearing, moveTilt);
+            animationIdlingResource.decrement();
+          }
+
+          @Override
+          public void onFinish() {
+            verifyCameraPosition(mapboxMap, moveTarget, moveZoom, moveBearing, moveTilt);
+            animationIdlingResource.decrement();
+          }
+        });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToBounds() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -103,96 +137,191 @@ public class CameraAnimateTest extends BaseActivityTest {
       final LatLngBounds.Builder builder = new LatLngBounds.Builder();
       builder.include(cornerOne);
       builder.include(cornerTwo);
-      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), 0));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera position latitude should match center bounds",
-        cameraPosition.target.getLatitude(),
-        centerBounds.getLatitude(),
-        TestConstants.LAT_LNG_DELTA);
-      assertEquals("Moved camera position longitude should match center bounds",
-        cameraPosition.target.getLongitude(),
-        centerBounds.getLongitude(),
-        TestConstants.LAT_LNG_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), 0), new MapboxMap
+        .CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, centerBounds, mapboxMap.getCameraPosition().zoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, centerBounds, mapboxMap.getCameraPosition().zoom, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToMoveBy() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final PointF centerPoint = mapboxMap.getProjection().toScreenLocation(mapboxMap.getCameraPosition().target);
       final LatLng moveTarget = new LatLng(2, 2);
       final PointF moveTargetPoint = mapboxMap.getProjection().toScreenLocation(moveTarget);
-      mapboxMap.animateCamera(CameraUpdateFactory.scrollBy(
-        moveTargetPoint.x - centerPoint.x, moveTargetPoint.y - centerPoint.y));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera position latitude should match", cameraPosition.target.getLatitude(),
-        moveTarget.getLatitude(), TestConstants.LAT_LNG_DELTA_LARGE);
-      assertEquals("Moved camera position longitude should match", cameraPosition.target.getLongitude(),
-        moveTarget.getLongitude(), TestConstants.LAT_LNG_DELTA_LARGE);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(
+        CameraUpdateFactory.scrollBy(moveTargetPoint.x - centerPoint.x, moveTargetPoint.y - centerPoint.y),
+        new MapboxMap.CancelableCallback() {
+          @Override
+          public void onCancel() {
+            verifyCameraPosition(mapboxMap, moveTarget, mapboxMap.getCameraPosition().zoom, 0, 0);
+            animationIdlingResource.decrement();
+          }
+
+          @Override
+          public void onFinish() {
+            verifyCameraPosition(mapboxMap, moveTarget, mapboxMap.getCameraPosition().zoom, 0, 0);
+            animationIdlingResource.decrement();
+          }
+        });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToZoomIn() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       float zoom = 1.0f;
-      mapboxMap.animateCamera(CameraUpdateFactory.zoomIn());
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera zoom should match moved camera zoom", cameraPosition.zoom, zoom + 1,
-        TestConstants.ZOOM_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.zoomIn(), new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom + 1, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom + 1, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToZoomOut() {
     validateTestSetup();
+    float zoom = 10.0f;
     invoke(mapboxMap, (uiController, mapboxMap) -> {
-      float zoom = 10.0f;
-      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(), zoom));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      mapboxMap.animateCamera(CameraUpdateFactory.zoomOut());
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera zoom should match moved camera zoom", cameraPosition.zoom, zoom - 1,
-        TestConstants.ZOOM_DELTA);
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(
+        CameraUpdateFactory.newLatLngZoom(new LatLng(), zoom),
+        new MapboxMap.CancelableCallback() {
+          @Override
+          public void onCancel() {
+            verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom, 0, 0);
+            animationIdlingResource.decrement();
+          }
+
+          @Override
+          public void onFinish() {
+            verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom, 0, 0);
+            animationIdlingResource.decrement();
+          }
+        });
     });
+
+    invoke(mapboxMap, ((uiController, mapboxMap1) -> {
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.zoomOut(), new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom - 1, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom - 1, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
+    }));
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToZoomBy() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       float zoom = 1.0f;
       final float zoomBy = 2.45f;
-      mapboxMap.animateCamera(CameraUpdateFactory.zoomBy(zoomBy));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera zoom should match moved camera zoom", cameraPosition.zoom, zoom + zoomBy,
-        TestConstants.ZOOM_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.zoomBy(zoomBy), new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom + zoomBy, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoom + zoomBy, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
   }
 
   @Test
-  @Ignore
   public void testAnimateToZoomTo() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final float zoomTo = 2.45f;
-      mapboxMap.animateCamera(CameraUpdateFactory.zoomTo(zoomTo));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      CameraPosition cameraPosition = mapboxMap.getCameraPosition();
-      assertEquals("Moved camera zoom should match moved camera zoom", cameraPosition.zoom, zoomTo,
-        TestConstants.ZOOM_DELTA);
+
+      animationIdlingResource.increment();
+      mapboxMap.animateCamera(CameraUpdateFactory.zoomTo(zoomTo), new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoomTo, 0, 0);
+          animationIdlingResource.decrement();
+        }
+
+        @Override
+        public void onFinish() {
+          verifyCameraPosition(mapboxMap, mapboxMap.getCameraPosition().target, zoomTo, 0, 0);
+          animationIdlingResource.decrement();
+        }
+      });
     });
+
+    Espresso.onIdle();
+  }
+
+  @Override
+  public void afterTest() {
+    super.afterTest();
+    IdlingRegistry.getInstance().unregister(animationIdlingResource);
+  }
+
+  private void verifyCameraPosition(MapboxMap mapboxMap, LatLng moveTarget, double moveZoom, double moveBearing,
+                                    double moveTilt) {
+    CameraPosition cameraPosition = mapboxMap.getCameraPosition();
+    assertEquals("Moved camera position latitude should match", cameraPosition.target.getLatitude(),
+      moveTarget.getLatitude(), TestConstants.LAT_LNG_DELTA);
+    assertEquals("Moved camera position longitude should match", cameraPosition.target.getLongitude(),
+      moveTarget.getLongitude(), TestConstants.LAT_LNG_DELTA);
+    assertEquals("Moved zoom should match", cameraPosition.zoom, moveZoom, TestConstants.ZOOM_DELTA);
+    assertEquals("Moved zoom should match", cameraPosition.tilt, moveTilt, TestConstants.TILT_DELTA);
+    assertEquals("Moved bearing should match", cameraPosition.bearing, moveBearing, TestConstants.BEARING_DELTA);
   }
 }