tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[android] reworked CameraAnimateTest

Browse Source
This commit is contained in:
Łukasz Paczos
2018-09-21 18:57:18 +02:00
committed by Łukasz Paczos
parent 7ff85374a7
commit 652c66e665
1 changed files with 207 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/camera/CameraAnimateTest.java
View File

@@ -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);
}
}