[android] reworked MoveCameraTestupstream/lp-enable-camera-tests

2 files changed, 205 insertions, 79 deletions

diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraEaseTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraEaseTest.java
index ac8339e48e..d51c7661be 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraEaseTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraEaseTest.java
@@ -14,7 +14,6 @@ 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;
@@ -285,6 +284,8 @@ public class CameraEaseTest extends BaseActivityTest {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final float zoomTo = 2.45f;
+
+      animationIdlingResource.increment();
       mapboxMap.easeCamera(CameraUpdateFactory.zoomTo(zoomTo), new MapboxMap.CancelableCallback() {
         @Override
         public void onCancel() {
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraMoveTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraMoveTest.java
index 2eeb01f430..15d52f2576 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraMoveTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraMoveTest.java
@@ -2,16 +2,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;
@@ -19,13 +22,21 @@ import static org.junit.Assert.assertEquals;
 
 public class CameraMoveTest 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 testMoveToCameraPositionTarget() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -35,36 +46,53 @@ public class CameraMoveTest 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.moveCamera(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.moveCamera(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 testMoveToCameraPositionTargetZoom() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final float moveZoom = 15.5f;
       final LatLng moveTarget = new LatLng(1.0000000001, 1.0000000003);
-      mapboxMap.moveCamera(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.moveCamera(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 testMoveToCameraPosition() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -73,28 +101,33 @@ public class CameraMoveTest extends BaseActivityTest {
       final float moveTilt = 45.5f;
       final float moveBearing = 12.5f;
 
+      animationIdlingResource.increment();
       mapboxMap.moveCamera(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 testMoveToBounds() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
@@ -104,96 +137,188 @@ public class CameraMoveTest extends BaseActivityTest {
       final LatLngBounds.Builder builder = new LatLngBounds.Builder();
       builder.include(cornerOne);
       builder.include(cornerTwo);
-      mapboxMap.moveCamera(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.moveCamera(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 testMoveToMoveBy() {
     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);
+
+      animationIdlingResource.increment();
       mapboxMap.moveCamera(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);
+        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 testMoveToZoomIn() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       float zoom = 1.0f;
-      mapboxMap.moveCamera(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.moveCamera(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 testMoveToZoomOut() {
+    float zoom = 10.0f;
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
-      float zoom = 10.0f;
-      mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(), zoom));
-      uiController.loopMainThreadForAtLeast(TestConstants.ANIMATION_TEST_TIME);
-      mapboxMap.moveCamera(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.moveCamera(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, mapboxMap) -> {
+      animationIdlingResource.increment();
+      mapboxMap.moveCamera(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 testMoveToZoomBy() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       float zoom = 1.0f;
       final float zoomBy = 2.45f;
-      mapboxMap.moveCamera(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.moveCamera(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 testMoveToZoomTo() {
     validateTestSetup();
     invoke(mapboxMap, (uiController, mapboxMap) -> {
       final float zoomTo = 2.45f;
-      mapboxMap.moveCamera(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.moveCamera(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);
+  }
+}