diff options
Diffstat (limited to 'platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com')
14 files changed, 871 insertions, 96 deletions
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/IconTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/IconTest.java new file mode 100644 index 0000000000..9e95451cb1 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/IconTest.java @@ -0,0 +1,55 @@ +package com.mapbox.mapboxsdk.annotations; + +import android.graphics.Bitmap; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertNotSame; + +public class IconTest { + + @Mock + Bitmap mBitmap; + + @Before + public void beforeTest() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testId() { + String id = "test"; + Icon icon = IconFactory.recreate(id, Bitmap.createBitmap(0, 0, Bitmap.Config.ALPHA_8)); + assertEquals("id should match", id, icon.getId()); + } + + @Test + public void testBitmap() { + Icon icon = IconFactory.recreate("test", mBitmap); + assertEquals("bitmap should match", mBitmap, icon.getBitmap()); + } + + @Test + public void testEquals() { + Icon icon1 = IconFactory.recreate("test", mBitmap); + Icon icon2 = IconFactory.recreate("test", mBitmap); + assertEquals("icons should not match", icon1, icon2); + } + + @Test + public void testEqualsObject() { + Icon icon = IconFactory.recreate("test", Bitmap.createBitmap(0, 0, Bitmap.Config.ALPHA_8)); + assertNotSame("icon should not match", new Object(), icon); + } + + @Test + public void testHashcode() { + Icon icon = IconFactory.recreate("test", mBitmap); + long expectedHashcode = 31 * mBitmap.hashCode() + "test".hashCode(); + assertEquals("hashcode should match", expectedHashcode, icon.hashCode()); + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/InfoWindowTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/InfoWindowTest.java new file mode 100644 index 0000000000..11ab8173fd --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/InfoWindowTest.java @@ -0,0 +1,86 @@ +package com.mapbox.mapboxsdk.annotations; + +import android.graphics.PointF; + +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.Projection; + +import org.junit.Test; +import org.mockito.InjectMocks; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class InfoWindowTest { + + @InjectMocks + MapView mMapView = mock(MapView.class); + + @InjectMocks + MapboxMap mMapboxMap = mock(MapboxMap.class); + + @Test + public void testSanity() { + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap); + assertNotNull("infoWindow should exist", infoWindow); + } + + @Test + public void testBoundMarker() { + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = markerOptions.getMarker(); + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap).setBoundMarker(marker); + assertEquals("marker should match", marker, infoWindow.getBoundMarker()); + } + + @Test + public void testClose() { + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap); + infoWindow.close(); + assertEquals("infowindow should not be visible", false, infoWindow.isVisible()); + } + + + @Test + public void testOpen() { + LatLng latLng = new LatLng(0, 0); + Projection projection = mock(Projection.class); + when(mMapboxMap.getProjection()).thenReturn(projection); + when(projection.toScreenLocation(latLng)).thenReturn(new PointF(0, 0)); + + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap); + infoWindow.open(mMapView, new MarkerOptions().getMarker(), latLng, 0, 0); + assertEquals("infowindow should not be visible", true, infoWindow.isVisible()); + } + + @Test + public void testOpenClose() { + LatLng latLng = new LatLng(0, 0); + Projection projection = mock(Projection.class); + when(mMapboxMap.getProjection()).thenReturn(projection); + when(projection.toScreenLocation(latLng)).thenReturn(new PointF(0, 0)); + + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap); + infoWindow.open(mMapView, new MarkerOptions().getMarker(), latLng, 0, 0); + infoWindow.close(); + assertEquals("infowindow should not be visible", false, infoWindow.isVisible()); + } + + + @Test + public void testUpdate() { + LatLng latLng = new LatLng(0, 0); + Projection projection = mock(Projection.class); + when(mMapboxMap.getProjection()).thenReturn(projection); + when(projection.toScreenLocation(latLng)).thenReturn(new PointF(0, 0)); + + InfoWindow infoWindow = new InfoWindow(mMapView, mMapboxMap); + infoWindow.open(mMapView, new MarkerOptions().position(latLng).getMarker(), latLng, 0, 0); + infoWindow.update(); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/MarkerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/MarkerTest.java new file mode 100644 index 0000000000..76e29c208b --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/MarkerTest.java @@ -0,0 +1,119 @@ +package com.mapbox.mapboxsdk.annotations; + +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; + +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; + +public class MarkerTest { + + @Test + public void testSanity() { + MarkerOptions markerOptions = new MarkerOptions(); + assertNotNull("markerOptions should not be null", markerOptions); + } + + @Test + public void testMarker() { + MarkerOptions markerOptions = new MarkerOptions(); + assertNotNull("marker should not be null", markerOptions.getMarker()); + } + + @Test + public void testPosition() { + MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(10, 12)); + Marker marker = markerOptions.getMarker(); + assertEquals(marker.getPosition(), new LatLng(10, 12)); + assertEquals(markerOptions.getPosition(), new LatLng(10, 12)); + } + + @Test + public void testTitle() { + MarkerOptions markerOptions = new MarkerOptions().title("Mapbox"); + Marker marker = markerOptions.getMarker(); + assertEquals(marker.getTitle(), "Mapbox"); + assertEquals(markerOptions.getTitle(), "Mapbox"); + } + + @Test + public void testSnippet() { + MarkerOptions markerOptions = new MarkerOptions().snippet("Mapbox"); + Marker marker = markerOptions.getMarker(); + assertEquals(marker.getSnippet(), "Mapbox"); + } + + @Test + public void testBuilder() { + Marker marker = new MarkerOptions().title("title").snippet("snippet").position(new LatLng(10, 12)).getMarker(); + assertEquals(marker.getSnippet(), "snippet"); + + assertEquals(marker.getPosition(), new LatLng(10, 12)); + } + + @Test + public void testIcon() { + Bitmap bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_4444); + Icon icon = IconFactory.recreate("test", bitmap); + MarkerOptions markerOptions = new MarkerOptions().icon(icon); + Marker marker = markerOptions.getMarker(); + assertEquals("Icon should match", icon, marker.getIcon()); + assertEquals("Icon should match", icon, markerOptions.getIcon()); + } + + @Test + public void testHashCode() { + Marker marker = new MarkerOptions().position(new LatLng(10, 12)).getMarker(); + assertEquals("hash code should match", marker.hashCode(), -1946419200); + } + + @Test + public void testHashCodeBuilder() { + MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(10, 12)); + assertEquals("hash code should match", markerOptions.hashCode(), 579999617); + } + + @Test + public void testEquals() { + Marker markerOne = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); + Marker markerTwo = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); + assertEquals(markerOne, markerTwo); + } + + @Test + public void testEqualsItself() { + MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(0, 0)); + Marker marker = markerOptions.getMarker(); + assertEquals("Marker should match", marker, marker); + assertEquals("MarkerOptions should match", markerOptions, markerOptions); + } + + @Test + public void testNotEquals() { + MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(0, 0)); + Marker marker = markerOptions.getMarker(); + assertNotEquals("MarkerOptions should match", markerOptions, new Object()); + assertNotEquals("Marker should match", marker, new Object()); + } + + @Test + public void testEqualityBuilder() { + MarkerOptions markerOne = new MarkerOptions().position(new LatLng(0, 0)); + MarkerOptions markerTwo = new MarkerOptions().position(new LatLng(0, 0)); + assertEquals(markerOne, markerTwo); + } + + @Test + public void testToString() { + Marker marker = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); + assertEquals(marker.toString(), "Marker [position[" + "LatLng [longitude=0.0, latitude=0.0, altitude=0.0]" + "]]"); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/PolygonTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/PolygonTest.java index 281277692f..744bf55c07 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/PolygonTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/PolygonTest.java @@ -1,4 +1,4 @@ -package com.mapbox.mapboxsdk.maps; +package com.mapbox.mapboxsdk.annotations; import com.mapbox.mapboxsdk.annotations.Polygon; import com.mapbox.mapboxsdk.annotations.PolygonOptions; diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/PolylineTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/PolylineTest.java index 78af961e02..b95c9dba2a 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/PolylineTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/annotations/PolylineTest.java @@ -1,4 +1,4 @@ -package com.mapbox.mapboxsdk.maps; +package com.mapbox.mapboxsdk.annotations; import com.mapbox.mapboxsdk.annotations.Polyline; import com.mapbox.mapboxsdk.annotations.PolylineOptions; diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/camera/CameraPositionTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/camera/CameraPositionTest.java new file mode 100644 index 0000000000..e2109adf47 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/camera/CameraPositionTest.java @@ -0,0 +1,77 @@ +package com.mapbox.mapboxsdk.camera; + +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.constants.MathConstants; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.utils.MathUtils; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +public class CameraPositionTest { + + @Test + public void testSanity() { + LatLng latLng = new LatLng(1, 2); + CameraPosition cameraPosition = new CameraPosition(latLng, 3, 4, 5); + assertNotNull("cameraPosition should not be null", cameraPosition); + } + + @Test + public void testToString() { + LatLng latLng = new LatLng(1, 2); + CameraPosition cameraPosition = new CameraPosition(latLng, 3, 4, 5); + assertEquals("toString should match", "Target: LatLng [longitude=2.0, latitude=1.0, altitude=0.0], Zoom:3.0, Bearing:5.0, Tilt:4.0", cameraPosition.toString()); + } + + @Test + public void testHashcode() { + LatLng latLng = new LatLng(1, 2); + CameraPosition cameraPosition = new CameraPosition(latLng, 3, 4, 5); + assertEquals("toString should match", -1007681505, cameraPosition.hashCode()); + } + + @Test + public void testRadiantBuilder() { + LatLng latLng = new LatLng(1, 2); + CameraPosition.Builder builder = new CameraPosition.Builder(true); + builder.target(latLng); + builder.zoom(3); + builder.tilt(4); + builder.bearing(5); + CameraPosition cameraPosition = new CameraPosition(latLng, 3, 4, 5); + assertEquals("CameraPosition should match", cameraPosition, builder.build()); + } + + @Test + public void testDegreesRadiantBuilder() { + LatLng latLng = new LatLng(1, 2); + float tilt = 4; + float bearing = 5; + float bearingRadiant = (float) (-bearing * MathConstants.DEG2RAD); + float tiltRadiant = (float) (MathUtils.clamp(tilt, MapboxConstants.MINIMUM_TILT, MapboxConstants.MAXIMUM_TILT) * MathConstants.DEG2RAD); + + CameraPosition.Builder degreeBuilder = new CameraPosition.Builder(false); + degreeBuilder.target(latLng); + degreeBuilder.zoom(3); + degreeBuilder.tilt(tilt); + degreeBuilder.bearing(bearing); + + CameraPosition.Builder radiantBuilder = new CameraPosition.Builder(true); + radiantBuilder.target(latLng); + radiantBuilder.zoom(3); + radiantBuilder.tilt(tiltRadiant); + radiantBuilder.bearing(bearingRadiant); + assertEquals("CameraPosition should match", radiantBuilder.build(), degreeBuilder.build()); + } + + @Test + public void testZoomUpdateBuilder() { + float zoomLevel = 5; + CameraPosition.Builder builder = new CameraPosition.Builder( + (CameraUpdateFactory.ZoomUpdate) CameraUpdateFactory.zoomTo(zoomLevel)); + assertEquals("zoom should match", zoomLevel, builder.build().zoom, 0); + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java index 451d774a78..e3870b63e2 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java @@ -2,9 +2,11 @@ package com.mapbox.mapboxsdk.geometry; import com.mapbox.mapboxsdk.exceptions.InvalidLatLngBoundsException; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -85,6 +87,18 @@ public class LatLngBoundsTest { } @Test + public void testToLatLngs() { + mLatLngBounds = new LatLngBounds.Builder() + .include(LAT_LNG_NOT_NULL_ISLAND) + .include(LAT_LNG_NULL_ISLAND) + .build(); + + assertArrayEquals("LatLngs should match", + new LatLng[]{LAT_LNG_NOT_NULL_ISLAND, LAT_LNG_NULL_ISLAND}, + mLatLngBounds.toLatLngs()); + } + + @Test public void testIncluding() { assertTrue("LatLng should be included", mLatLngBounds.including(new LatLng(1, 1))); } @@ -106,6 +120,7 @@ public class LatLngBoundsTest { .include(LAT_LNG_NOT_NULL_ISLAND) .build(); assertEquals("equality should match", mLatLngBounds, latLngBounds); + assertEquals("not equal to a different object type", mLatLngBounds.equals(LAT_LNG_NOT_NULL_ISLAND), false); } @Test diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngSpanTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngSpanTest.java index 452046082e..7bf164166c 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngSpanTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngSpanTest.java @@ -10,6 +10,7 @@ import static org.junit.Assert.assertNotNull; public class LatLngSpanTest { private static final double DELTA = 1e-15; + private static final LatLng LAT_LNG_NULL_ISLAND = new LatLng(0, 0); @Test public void testSanity() { @@ -18,6 +19,12 @@ public class LatLngSpanTest { } @Test + public void testEquality() { + LatLngSpan latLngSpan = new LatLngSpan(0.0, 0.0); + assertEquals("latLngSpan is not equal to a LatLng", latLngSpan.equals(LAT_LNG_NULL_ISLAND), false); + } + + @Test public void testLatitudeConstructor() { double latitude = 1.23; LatLngSpan latLngSpan = new LatLngSpan(latitude, 0.0); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/ProjectedMetersTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/ProjectedMetersTest.java index 057cbaed56..bd40221706 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/ProjectedMetersTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/ProjectedMetersTest.java @@ -1,17 +1,55 @@ package com.mapbox.mapboxsdk.geometry; -import com.mapbox.mapboxsdk.geometry.ProjectedMeters; - import org.junit.Test; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; public class ProjectedMetersTest { + private static final LatLng LAT_LNG_NULL_ISLAND = new LatLng(0, 0); + @Test public void testSanity() { ProjectedMeters projectedMeters = new ProjectedMeters(0.0, 0.0); assertNotNull("projectedMeters should not be null", projectedMeters); } + @Test + public void testEquality() { + ProjectedMeters projectedMeters = new ProjectedMeters(0.0, 0.0); + assertEquals("projectedMeters is not equal to a LatLng", projectedMeters.equals(LAT_LNG_NULL_ISLAND), false); + assertEquals("projectedMeters is equal to itself", projectedMeters.equals(projectedMeters), true); + } + + @Test + public void testNorthing() { + ProjectedMeters projectedMeters = new ProjectedMeters(1.0, 0.0); + assertEquals("northing should be 1", 1, projectedMeters.getNorthing(), 0); + } + + @Test + public void testEasting() { + ProjectedMeters projectedMeters = new ProjectedMeters(0.0, 1.0); + assertEquals("easting should be 1", 1, projectedMeters.getEasting(), 0); + } + + @Test + public void testConstructor() { + ProjectedMeters projectedMeters1 = new ProjectedMeters(1, 2); + ProjectedMeters projectedMeters2 = new ProjectedMeters(projectedMeters1); + assertEquals("projectedmeters should match", projectedMeters1, projectedMeters2); + } + + @Test + public void testHashcode() { + ProjectedMeters meters = new ProjectedMeters(1, 2); + assertEquals("hashcode should match", -1048576, meters.hashCode()); + } + + @Test + public void testToString(){ + ProjectedMeters meters = new ProjectedMeters(1, 1); + assertEquals("toString should match","ProjectedMeters [northing=1.0, easting=1.0]",meters.toString()); + } } diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/VisibleRegionTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/VisibleRegionTest.java index 9423108214..83cfa37841 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/VisibleRegionTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/geometry/VisibleRegionTest.java @@ -20,6 +20,13 @@ public class VisibleRegionTest { } @Test + public void testEquality() { + VisibleRegion region = new VisibleRegion(FAR_LEFT, FAR_RIGHT, NEAR_LEFT, NEAR_RIGHT, BOUNDS); + assertEquals("visibleRegion is not equal to a LatLng", region.equals(FAR_LEFT), false); + assertEquals("visibleRegion is equal to itself", region.equals(region), true); + } + + @Test public void testFarLeftConstructor() { VisibleRegion region = new VisibleRegion(FAR_LEFT, FAR_RIGHT, NEAR_LEFT, NEAR_RIGHT, BOUNDS); assertEquals("LatLng should match", region.farLeft, FAR_LEFT); @@ -57,6 +64,12 @@ public class VisibleRegionTest { } @Test + public void testHashcode() { + VisibleRegion region = new VisibleRegion(FAR_LEFT, FAR_RIGHT, NEAR_LEFT, NEAR_RIGHT, BOUNDS); + assertEquals("hashcode should match", -923534102, region.hashCode()); + } + + @Test public void testToString() { VisibleRegion region = new VisibleRegion(FAR_LEFT, FAR_RIGHT, NEAR_LEFT, NEAR_RIGHT, BOUNDS); assertEquals("string should match", diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java index 0f75655dc9..2fac586da1 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java @@ -1,11 +1,17 @@ package com.mapbox.mapboxsdk.maps; +import android.graphics.Color; import android.graphics.Point; import com.mapbox.mapboxsdk.annotations.Marker; import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.annotations.Polygon; +import com.mapbox.mapboxsdk.annotations.PolygonOptions; +import com.mapbox.mapboxsdk.annotations.Polyline; +import com.mapbox.mapboxsdk.annotations.PolylineOptions; import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; import com.mapbox.mapboxsdk.constants.Style; import com.mapbox.mapboxsdk.geometry.LatLng; @@ -15,9 +21,13 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import java.util.ArrayList; +import java.util.List; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.matches; import static org.mockito.Mockito.mock; import static org.junit.Assert.assertNotNull; @@ -35,6 +45,39 @@ public class MapboxMapTest { @Mock MapboxMap.OnMarkerClickListener mOnMarkerClickListener; + @Mock + MapboxMap.OnCameraChangeListener mOnCameraChangeListener; + + @Mock + MapboxMap.InfoWindowAdapter mInfoWindowAdapter; + + @Mock + MapboxMap.OnScrollListener mScrollListener; + + @Mock + MapboxMap.OnFlingListener mFlingListener; + + @Mock + MapboxMap.OnFpsChangedListener mFpsChangedListener; + + @Mock + MapboxMap.OnInfoWindowClickListener mWindowClickListener; + + @Mock + MapboxMap.OnInfoWindowCloseListener mWindowCloseListener; + + @Mock + MapboxMap.OnInfoWindowLongClickListener mWindowLongClickListener; + + @Mock + MapboxMap.OnMyLocationChangeListener mLocationChangeListener; + + @Mock + MapboxMap.OnMyLocationTrackingModeChangeListener mMyLocationTrackingModeChangeListener; + + @Mock + MapboxMap.OnMyBearingTrackingModeChangeListener mMyBearingTrackingModeChangeListener; + @Before public void beforeTest() { MockitoAnnotations.initMocks(this); @@ -46,6 +89,16 @@ public class MapboxMapTest { assertNotNull("mMapboxMap should not be null", mMapboxMap); } + @Test + public void testMock() { + assertNotNull("mMapView should be mocked", mMapView); + } + + @Test + public void testGetMapView() { + assertNotNull("MapView should be non null", mMapboxMap.getMapView()); + } + // // UiSettings // @@ -56,15 +109,22 @@ public class MapboxMapTest { } // - // Projection + // TrackingSettings // @Test - public void testProjection(){ - assertNotNull("Projection should not be null",mMapboxMap.getProjection()); + public void testTrackingSettings() { + assertNotNull("TrackingSettings should not be null", mMapboxMap.getTrackingSettings()); } + // + // Projection + // + @Test + public void testProjection() { + assertNotNull("Projection should not be null", mMapboxMap.getProjection()); + } // // InfoWindow @@ -82,31 +142,97 @@ public class MapboxMapTest { assertFalse("ConcurrentWindows should be false", mMapboxMap.isAllowConcurrentMultipleOpenInfoWindows()); } + @Test + public void testInfoWindowAdapter() { + mMapboxMap.setInfoWindowAdapter(mInfoWindowAdapter); + assertEquals("InfoWindowAdpter should be the same", mInfoWindowAdapter, mMapboxMap.getInfoWindowAdapter()); + } + // // Location // @Test public void testMyLocationEnabled() { - try { - mMapboxMap.setMyLocationEnabled(true); - assertTrue("MyLocationEnabled should be true", mMapboxMap.isMyLocationEnabled()); - } catch (SecurityException e) { - assertTrue(false); - } + when(mMapView.isPermissionsAccepted()).thenReturn(true); + mMapboxMap.setMyLocationEnabled(true); + assertTrue("MyLocationEnabled should be true", mMapboxMap.isMyLocationEnabled()); + } @Test public void testMyLocationDisabled() { - try { - mMapboxMap.setMyLocationEnabled(false); - assertFalse("MyLocationEnabled should be false", mMapboxMap.isMyLocationEnabled()); - } catch (SecurityException e) { - assertTrue(false); - } + when(mMapView.isPermissionsAccepted()).thenReturn(true); + mMapboxMap.setMyLocationEnabled(false); + assertFalse("MyLocationEnabled should be false", mMapboxMap.isMyLocationEnabled()); + } + + // + // padding + // + + @Test + public void testPadding() { + mMapboxMap.setOnCameraChangeListener(mOnCameraChangeListener); + CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build(); + mMapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(position)); + mMapboxMap.setPadding(0, 0, 0, 0); + verify(mOnCameraChangeListener, times(2)).onCameraChange(position); } // + // setters/getters interfaces + // + + @Test + public void testScrollListener() { + mMapboxMap.setOnScrollListener(mScrollListener); + assertEquals("ScrollListener should match", mScrollListener, mMapboxMap.getOnScrollListener()); + } + + @Test + public void testFlingListener() { + mMapboxMap.setOnFlingListener(mFlingListener); + assertEquals("FlingListener should match", mFlingListener, mMapboxMap.getOnFlingListener()); + } + + @Test + public void testFpsListener() { + mMapboxMap.setOnFpsChangedListener(mFpsChangedListener); + assertEquals("FpsListener should match", mFpsChangedListener, mMapboxMap.getOnFpsChangedListener()); + } + + @Test + public void testInfoWindowClickListener() { + mMapboxMap.setOnInfoWindowClickListener(mWindowClickListener); + assertEquals("InfoWidowClickListener should match", mWindowClickListener, mMapboxMap.getOnInfoWindowClickListener()); + } + + @Test + public void testInfoWindowCloseListener() { + mMapboxMap.setOnInfoWindowCloseListener(mWindowCloseListener); + assertEquals("InfoWindowCloseListener should match", mWindowCloseListener, mMapboxMap.getOnInfoWindowCloseListener()); + } + + @Test + public void testInfoWindowLongClickListener() { + mMapboxMap.setOnInfoWindowLongClickListener(mWindowLongClickListener); + assertEquals("InfoWindowLongClickListener should match", mWindowLongClickListener, mMapboxMap.getOnInfoWindowLongClickListener()); + } + + @Test + public void testOnBearingTrackingModeChangeListener(){ + mMapboxMap.setOnMyBearingTrackingModeChangeListener(mMyBearingTrackingModeChangeListener); + assertEquals("MyBearingTrackingChangeListerner should match",mMyBearingTrackingModeChangeListener, mMapboxMap.getOnMyBearingTrackingModeChangeListener()); + } + + @Test + public void testOnLocationTrackingModeChangeListener(){ + mMapboxMap.setOnMyLocationTrackingModeChangeListener(mMyLocationTrackingModeChangeListener); + assertEquals("MyLocationTrackigChangeListener should match",mMyLocationTrackingModeChangeListener, mMapboxMap.getOnMyLocationTrackingModeChangeListener()); + } + + // // Style // @@ -183,7 +309,7 @@ public class MapboxMapTest { @Test public void testNewCameraPositionEaseCamera() { CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build(); - mMapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(position), 1000); + mMapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(position)); assertEquals("CameraPosition should be same", position, mMapboxMap.getCameraPosition()); } @@ -369,6 +495,238 @@ public class MapboxMapTest { } // + // OnCameraChangeListener + // + + @Test + public void testOnCameraChangeListener() { + CameraPosition position = new CameraPosition.Builder().bearing(1).tilt(2).zoom(3).target(new LatLng(4, 5)).build(); + mMapboxMap.setOnCameraChangeListener(mOnCameraChangeListener); + mMapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(position)); + verify(mOnCameraChangeListener, times(1)).onCameraChange(position); + } + + // + // Annotations + // + + @Test + public void testAddMarker() { + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = mMapboxMap.addMarker(markerOptions); + assertTrue("Marker should be contained", mMapboxMap.getMarkers().contains(marker)); + } + + @Test + public void testAddMarkers() { + List<MarkerOptions> markerList = new ArrayList<>(); + MarkerOptions markerOptions1 = new MarkerOptions().title("a"); + MarkerOptions markerOptions2 = new MarkerOptions().title("b"); + markerList.add(markerOptions1); + markerList.add(markerOptions2); + mMapboxMap.addMarkers(markerList); + assertEquals("Markers size should be 2", 2, mMapboxMap.getMarkers().size()); + assertTrue(mMapboxMap.getMarkers().contains(markerOptions1.getMarker())); + assertTrue(mMapboxMap.getMarkers().contains(markerOptions2.getMarker())); + } + + @Test + public void testAddPolygon() { + PolygonOptions polygonOptions = new PolygonOptions().add(new LatLng()); + Polygon polygon = mMapboxMap.addPolygon(polygonOptions); + assertTrue("Polygon should be contained", mMapboxMap.getPolygons().contains(polygon)); + } + + @Test + public void testAddEmptyPolygon() { + PolygonOptions polygonOptions = new PolygonOptions(); + Polygon polygon = mMapboxMap.addPolygon(polygonOptions); + assertTrue("Polygon should be ignored", !mMapboxMap.getPolygons().contains(polygon)); + } + + @Test + public void testAddPolygons() { + List<PolygonOptions> polygonList = new ArrayList<>(); + PolygonOptions polygonOptions1 = new PolygonOptions().fillColor(Color.BLACK).add(new LatLng()); + PolygonOptions polygonOptions2 = new PolygonOptions().fillColor(Color.WHITE).add(new LatLng()); + PolygonOptions polygonOptions3 = new PolygonOptions(); + polygonList.add(polygonOptions1); + polygonList.add(polygonOptions2); + polygonList.add(polygonOptions3); + mMapboxMap.addPolygons(polygonList); + assertEquals("Polygons size should be 2", 2, mMapboxMap.getPolygons().size()); + assertTrue(mMapboxMap.getPolygons().contains(polygonOptions1.getPolygon())); + assertTrue(mMapboxMap.getPolygons().contains(polygonOptions2.getPolygon())); + assertTrue("Polygon should be ignored", !mMapboxMap.getPolygons().contains(polygonOptions3.getPolygon())); + } + + @Test + public void testAddPolyline() { + PolylineOptions polylineOptions = new PolylineOptions().add(new LatLng()); + Polyline polyline = mMapboxMap.addPolyline(polylineOptions); + assertTrue("Polyline should be contained", mMapboxMap.getPolylines().contains(polyline)); + } + + @Test + public void testAddEmptyPolyline() { + PolylineOptions polylineOptions = new PolylineOptions(); + Polyline polyline = mMapboxMap.addPolyline(polylineOptions); + assertTrue("Polyline should be ignored", !mMapboxMap.getPolylines().contains(polyline)); + } + + @Test + public void testAddPolylines() { + List<PolylineOptions> polylineList = new ArrayList<>(); + PolylineOptions polygonOptions1 = new PolylineOptions().color(Color.BLACK).add(new LatLng()); + PolylineOptions polygonOptions2 = new PolylineOptions().color(Color.WHITE).add(new LatLng()); + PolylineOptions polygonOptions3 = new PolylineOptions(); + polylineList.add(polygonOptions1); + polylineList.add(polygonOptions2); + polylineList.add(polygonOptions3); + mMapboxMap.addPolylines(polylineList); + assertEquals("Polygons size should be 2", 2, mMapboxMap.getPolylines().size()); + assertTrue(mMapboxMap.getPolylines().contains(polygonOptions1.getPolyline())); + assertTrue(mMapboxMap.getPolylines().contains(polygonOptions2.getPolyline())); + assertTrue("Polyline should be ignored", !mMapboxMap.getPolylines().contains(polygonOptions3.getPolyline())); + } + + @Test + public void testRemoveMarker() { + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = mMapboxMap.addMarker(markerOptions); + mMapboxMap.removeMarker(marker); + assertTrue("Markers should be empty", mMapboxMap.getMarkers().isEmpty()); + } + + @Test + public void testRemovePolygon() { + PolygonOptions polygonOptions = new PolygonOptions(); + Polygon polygon = mMapboxMap.addPolygon(polygonOptions); + mMapboxMap.removePolygon(polygon); + assertTrue("Polygons should be empty", mMapboxMap.getPolylines().isEmpty()); + } + + @Test + public void testRemovePolyline() { + PolylineOptions polylineOptions = new PolylineOptions(); + Polyline polyline = mMapboxMap.addPolyline(polylineOptions); + mMapboxMap.removePolyline(polyline); + assertTrue("Polylines should be empty", mMapboxMap.getPolylines().isEmpty()); + } + + @Test + public void testRemoveAnnotation() { + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = mMapboxMap.addMarker(markerOptions); + mMapboxMap.removeAnnotation(marker); + assertTrue("Annotations should be empty", mMapboxMap.getAnnotations().isEmpty()); + } + + @Test + public void testRemoveAnnotationById() { + MarkerOptions markerOptions = new MarkerOptions(); + mMapboxMap.addMarker(markerOptions); + // id will always be 0 in unit tests + mMapboxMap.removeAnnotation(0); + assertTrue("Annotations should be empty", mMapboxMap.getAnnotations().isEmpty()); + } + + @Test + public void testRemoveAnnotations() { + List<MarkerOptions> markerList = new ArrayList<>(); + MarkerOptions markerOptions1 = new MarkerOptions().title("a"); + MarkerOptions markerOptions2 = new MarkerOptions().title("b"); + markerList.add(markerOptions1); + markerList.add(markerOptions2); + mMapboxMap.addMarkers(markerList); + mMapboxMap.removeAnnotations(); + assertTrue("Annotations should be empty", mMapboxMap.getAnnotations().isEmpty()); + } + + @Test + public void testRemoveAnnotationsByList() { + List<MarkerOptions> markerList = new ArrayList<>(); + MarkerOptions markerOptions1 = new MarkerOptions().title("a"); + MarkerOptions markerOptions2 = new MarkerOptions().title("b"); + markerList.add(markerOptions1); + markerList.add(markerOptions2); + List<Marker> markers = mMapboxMap.addMarkers(markerList); + Marker marker = mMapboxMap.addMarker(new MarkerOptions().title("c")); + mMapboxMap.removeAnnotations(markers); + assertTrue("Annotations should not be empty", mMapboxMap.getAnnotations().size() == 1); + assertTrue("Marker should be contained", mMapboxMap.getAnnotations().contains(marker)); + } + + @Test + public void testGetAnnotationById() { + MarkerOptions markerOptions = new MarkerOptions(); + Marker initialMarker = mMapboxMap.addMarker(markerOptions); + Marker retrievedMarker = (Marker) mMapboxMap.getAnnotation(0); + assertEquals("Markers should match", initialMarker, retrievedMarker); + } + + @Test + public void testGetAnnotations() { + assertNotNull("Annotations should be non null", mMapboxMap.getAnnotations()); + } + + @Test + public void testGetMarkers() { + assertNotNull("Markers should be non null", mMapboxMap.getMarkers()); + } + + @Test + public void testGetPolygons() { + assertNotNull("Polygons should be non null", mMapboxMap.getPolygons()); + } + + @Test + public void testGetPolylines() { + assertNotNull("Polylines should be non null", mMapboxMap.getPolylines()); + } + + @Test + public void testGetSelectedMarkers() { + assertNotNull("Selected markers should be non null", mMapboxMap.getSelectedMarkers()); + } + + @Test + public void testSelectMarker() { + mMapboxMap.setOnMarkerClickListener(mOnMarkerClickListener); + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = mMapboxMap.addMarker(markerOptions); + when(mOnMarkerClickListener.onMarkerClick(marker)).thenReturn(true); + mMapboxMap.selectMarker(marker); + assertTrue("Marker should be contained", mMapboxMap.getSelectedMarkers().contains(marker)); + } + + @Test + public void testDeselectMarker() { + mMapboxMap.setOnMarkerClickListener(mOnMarkerClickListener); + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker = mMapboxMap.addMarker(markerOptions); + when(mOnMarkerClickListener.onMarkerClick(marker)).thenReturn(true); + mMapboxMap.selectMarker(marker); + mMapboxMap.deselectMarker(marker); + assertTrue("Selected markers should be empty", mMapboxMap.getSelectedMarkers().isEmpty()); + } + + @Test + public void testDeselectMarkers() { + mMapboxMap.setOnMarkerClickListener(mOnMarkerClickListener); + MarkerOptions markerOptions = new MarkerOptions(); + Marker marker1 = mMapboxMap.addMarker(markerOptions); + Marker marker2 = mMapboxMap.addMarker(markerOptions); + when(mOnMarkerClickListener.onMarkerClick(marker1)).thenReturn(true); + when(mOnMarkerClickListener.onMarkerClick(marker2)).thenReturn(true); + mMapboxMap.selectMarker(marker1); + mMapboxMap.selectMarker(marker2); + mMapboxMap.deselectMarkers(); + assertTrue("Selected markers should be empty", mMapboxMap.getSelectedMarkers().isEmpty()); + } + + + // // OnMarkerClick interface // diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MarkerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MarkerTest.java deleted file mode 100644 index efe94e5396..0000000000 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/MarkerTest.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.mapbox.mapboxsdk.maps; - -import com.mapbox.mapboxsdk.annotations.Marker; -import com.mapbox.mapboxsdk.annotations.MarkerOptions; -import com.mapbox.mapboxsdk.geometry.LatLng; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class MarkerTest { - - @Test - public void testSanity() { - MarkerOptions markerOptions = new MarkerOptions(); - assertNotNull("markerOptions should not be null", markerOptions); - } - - @Test - public void testMarker() { - MarkerOptions markerOptions = new MarkerOptions(); - assertNotNull("marker should not be null", markerOptions.getMarker()); - } - - @Test - public void testPosition() { - Marker marker = new MarkerOptions().position(new LatLng(10, 12)).getMarker(); - assertEquals(marker.getPosition(), new LatLng(10, 12)); - } - - @Test - public void testTitle() { - Marker marker = new MarkerOptions().title("Mapbox").getMarker(); - assertEquals(marker.getTitle(), "Mapbox"); - } - - @Test - public void testSnippet() { - Marker marker = new MarkerOptions().snippet("Mapbox").getMarker(); - assertEquals(marker.getSnippet(), "Mapbox"); - } - - @Test - public void testBuilder() { - Marker marker = new MarkerOptions().title("title").snippet("snippet").position(new LatLng(10, 12)).getMarker(); - assertEquals(marker.getTitle(), "title"); - assertEquals(marker.getSnippet(), "snippet"); - assertEquals(marker.getPosition(), new LatLng(10, 12)); - } - - @Test - public void testIcon() { - // find a way to test Icon - } - - @Test - public void testHashCode() { - Marker marker = new MarkerOptions().position(new LatLng(10, 12)).getMarker(); - assertEquals("hash code should match", marker.hashCode(), -1946419200); - } - - @Test - public void testEquality() { - Marker markerOne = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); - Marker markerTwo = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); - assertEquals(markerOne, markerTwo); - } - - @Test - public void testToString() { - Marker marker = new MarkerOptions().position(new LatLng(0, 0)).getMarker(); - assertEquals(marker.toString(), "Marker [position[" + "LatLng [longitude=0.0, latitude=0.0, altitude=0.0]" + "]]"); - } - -} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java new file mode 100644 index 0000000000..266bbadd95 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java @@ -0,0 +1,53 @@ +package com.mapbox.mapboxsdk.maps; + +import com.mapbox.mapboxsdk.constants.MyBearingTracking; +import com.mapbox.mapboxsdk.constants.MyLocationTracking; + +import org.junit.Test; +import org.mockito.InjectMocks; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.mock; + +public class TrackingSettingsTest { + + @InjectMocks + MapView mMapView = mock(MapView.class); + + @Test + public void testSanity() { + TrackingSettings trackingSettings = new TrackingSettings(mMapView, new UiSettings(mMapView)); + assertNotNull("trackingsettings should not be null", trackingSettings); + } + + @Test + public void testMyLocationTrackingMode() { + TrackingSettings trackingSettings = new TrackingSettings(mMapView, new UiSettings(mMapView)); + trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); + assertEquals("MyLocationTrackingMode should match", MyLocationTracking.TRACKING_FOLLOW, trackingSettings.getMyLocationTrackingMode()); + } + + @Test + public void testMyBearingTrackingMode() { + TrackingSettings trackingSettings = new TrackingSettings(mMapView, new UiSettings(mMapView)); + trackingSettings.setMyBearingTrackingMode(MyBearingTracking.COMPASS); + assertEquals("MyLocationTrackingMode should match", MyBearingTracking.COMPASS, trackingSettings.getMyBearingTrackingMode()); + } + + @Test + public void testDismissTrackingModesOnGesture() { + TrackingSettings trackingSettings = new TrackingSettings(mMapView, new UiSettings(mMapView)); + trackingSettings.setDismissTrackingOnGesture(false); + assertFalse("DismissTrackingOnGesture should be false", trackingSettings.isDismissTrackingOnGesture()); + } + + @Test + public void testValidateGesturesForTrackingModes(){ + TrackingSettings trackingSettings = new TrackingSettings(mMapView, new UiSettings(mMapView)); + trackingSettings.setDismissTrackingOnGesture(false); + trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); + assertFalse("DismissTrackingOnGesture should be false", trackingSettings.isDismissTrackingOnGesture()); + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java index 9c867bf776..cb9031c66e 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java @@ -22,6 +22,30 @@ public class UiSettingsTest { } @Test + public void testMinZoom() { + double zoom = 10; + UiSettings uiSettings = new UiSettings(mMapView); + uiSettings.setMinZoom(zoom); + assertEquals("MinZoom should match", zoom, uiSettings.getMinZoom(), 0); + } + + @Test + public void testMaxZoom() { + double zoom = 10; + UiSettings uiSettings = new UiSettings(mMapView); + uiSettings.setMaxZoom(zoom); + assertEquals("MaxZoom should match", zoom, uiSettings.getMaxZoom(), 0); + } + + @Test + public void testInitialZoomLevels() { + //we are mocking MapView we expect a value of 0 to be returned + UiSettings uiSettings = new UiSettings(mMapView); + assertEquals("MaxZoom should match", 0, uiSettings.getMaxZoom(), 0); + assertEquals("MinZoom should match", 0, uiSettings.getMinZoom(), 0); + } + + @Test public void testCompassEnabled() { UiSettings uiSettings = new UiSettings(mMapView); uiSettings.setCompassEnabled(true); @@ -204,4 +228,10 @@ public class UiSettingsTest { assertEquals("Scroll gesture should be disabled", false, uiSettings.isScrollGesturesEnabled()); } + @Test + public void testInvalidate() { + UiSettings uiSettings = new UiSettings(mMapView); + uiSettings.invalidate(); + } + }
\ No newline at end of file |