diff options
Diffstat (limited to 'platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox')
13 files changed, 1656 insertions, 474 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxTest.java index 7a28d846ea..6ee5c157b9 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxTest.java @@ -5,7 +5,6 @@ import android.net.ConnectivityManager; import android.net.NetworkInfo; import com.mapbox.mapboxsdk.exceptions.MapboxConfigurationException; -import com.mapbox.services.android.telemetry.location.LocationEngine; import org.junit.Before; import org.junit.Test; @@ -25,13 +24,11 @@ public class MapboxTest { private Context context; private Context appContext; - private LocationEngine locationSource; @Before public void before() { context = mock(Context.class); appContext = mock(Context.class); - locationSource = mock(LocationEngine.class); when(context.getApplicationContext()).thenReturn(appContext); } @@ -83,7 +80,7 @@ public class MapboxTest { } private void injectMapboxSingleton(String accessToken) { - Mapbox mapbox = new Mapbox(appContext, accessToken, locationSource); + Mapbox mapbox = new Mapbox(appContext, accessToken); try { Field field = Mapbox.class.getDeclaredField("INSTANCE"); field.setAccessible(true); diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java index bb96c9939d..c66e4b6fda 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java @@ -2,11 +2,14 @@ package com.mapbox.mapboxsdk.geometry; import android.os.Parcelable; +import com.mapbox.mapboxsdk.constants.GeometryConstants; import com.mapbox.mapboxsdk.exceptions.InvalidLatLngBoundsException; import com.mapbox.mapboxsdk.utils.MockParcel; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; +import org.junit.rules.ExpectedException; import java.util.ArrayList; import java.util.List; @@ -68,6 +71,103 @@ public class LatLngBoundsTest { } @Test + public void dateLineSpanBuilder1() { + latLngBounds = new LatLngBounds.Builder() + .include(new LatLng(10, -170)) + .include(new LatLng(-10, 170)) + .build(); + + LatLngSpan latLngSpan = latLngBounds.getSpan(); + assertEquals("LatLngSpan should be shortest distance", new LatLngSpan(20, 20), + latLngSpan); + } + + @Test + public void dateLineSpanBuilder2() { + latLngBounds = new LatLngBounds.Builder() + .include(new LatLng(-10, -170)) + .include(new LatLng(10, 170)) + .build(); + + LatLngSpan latLngSpan = latLngBounds.getSpan(); + assertEquals("LatLngSpan should be shortest distance", new LatLngSpan(20, 20), + latLngSpan); + } + + @Test + public void dateLineSpanFrom1() { + latLngBounds = LatLngBounds.from(10, -170, -10, 170); + LatLngSpan latLngSpan = latLngBounds.getSpan(); + assertEquals("LatLngSpan should be shortest distance", new LatLngSpan(20, 20), + latLngSpan); + } + + @Test + public void dateLineSpanFrom2() { + latLngBounds = LatLngBounds.from(10, 170, -10, -170); + LatLngSpan latLngSpan = latLngBounds.getSpan(); + assertEquals("LatLngSpan should be shortest distance", new LatLngSpan(20, 340), + latLngSpan); + } + + @Test + public void zeroLongitudeSpan() { + latLngBounds = LatLngBounds.from(10, 10, -10, 10); + LatLngSpan latLngSpan = latLngBounds.getSpan(); + assertEquals("LatLngSpan should be shortest distance", new LatLngSpan(20, 0), + latLngSpan); + } + + @Test + public void nearDateLineCenter1() { + latLngBounds = LatLngBounds.from(10, -175, -10, 165); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, 175), center); + } + + @Test + public void nearDateLineCenter2() { + latLngBounds = LatLngBounds.from(10, -165, -10, 175); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, -175), center); + } + + @Test + public void nearDateLineCenter3() { + latLngBounds = LatLngBounds.from(10, -170, -10, 170); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, -180), center); + } + + @Test + public void nearDateLineCenter4() { + latLngBounds = LatLngBounds.from(10, -180, -10, 0); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, 90), center); + } + + @Test + public void nearDateLineCenter5() { + latLngBounds = LatLngBounds.from(10, 180, -10, 0); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, 90), center); + } + + @Test + public void centerForBoundsWithSameLongitude() { + latLngBounds = LatLngBounds.from(10, 10, -10, 10); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(0, 10), center); + } + + @Test + public void centerForBoundsWithSameLatitude() { + latLngBounds = LatLngBounds.from(10, 10, 10, -10); + LatLng center = latLngBounds.getCenter(); + assertEquals("Center should match", new LatLng(10, 0), center); + } + + @Test public void center() { LatLng center = latLngBounds.getCenter(); assertEquals("Center should match", new LatLng(1, 1), center); @@ -118,6 +218,67 @@ public class LatLngBoundsTest { } @Test + public void includesOrderDoesNotMatter() { + LatLngBounds sameLongitudeFirst = new LatLngBounds.Builder() + .include(new LatLng(50, 10)) // southWest + .include(new LatLng(60, 10)) + .include(new LatLng(60, 20)) // northEast + .include(new LatLng(50, 20)) + .include(new LatLng(50, 10)) // southWest again + .build(); + + LatLngBounds sameLatitudeFirst = new LatLngBounds.Builder() + .include(new LatLng(50, 20)) + .include(new LatLng(50, 10)) // southWest + .include(new LatLng(60, 10)) + .include(new LatLng(60, 20)) // northEast + .include(new LatLng(50, 20)) + .build(); + + assertEquals(sameLatitudeFirst, sameLongitudeFirst); + } + + @Test + public void includesOverDateline1() { + + LatLngBounds latLngBounds = new LatLngBounds.Builder() + .include(new LatLng(10, -170)) + .include(new LatLng(-10, -175)) + .include(new LatLng(0, 170)) + .build(); + + assertEquals("LatLngSpan should be the same", + new LatLngSpan(20, 20), latLngBounds.getSpan()); + } + + @Test + public void includesOverDateline2() { + + LatLngBounds latLngBounds = new LatLngBounds.Builder() + .include(new LatLng(10, 170)) + .include(new LatLng(-10, 175)) + .include(new LatLng(0, -170)) + .build(); + + assertEquals("LatLngSpan should be the same", + new LatLngSpan(20, 20), latLngBounds.getSpan()); + } + + @Test + public void includesOverDateline3() { + + LatLngBounds latLngBounds = new LatLngBounds.Builder() + .include(new LatLng(10, 170)) + .include(new LatLng(-10, -170)) + .include(new LatLng(0, -180)) + .include(new LatLng(5, 180)) + .build(); + + assertEquals("LatLngSpan should be the same", + new LatLngSpan(20, 20), latLngBounds.getSpan()); + } + + @Test public void containsNot() { assertFalse("LatLng should not be included", latLngBounds.contains(new LatLng(3, 1))); } @@ -128,6 +289,21 @@ public class LatLngBoundsTest { } @Test + public void worldSpan() { + assertEquals("LatLngBounds world span should be 180, 360", + GeometryConstants.LATITUDE_SPAN, LatLngBounds.world().getLatitudeSpan(), DELTA); + assertEquals("LatLngBounds world span should be 180, 360", + GeometryConstants.LONGITUDE_SPAN, LatLngBounds.world().getLongitudeSpan(), DELTA); + } + + @Test + public void emptySpan() { + LatLngBounds latLngBounds = LatLngBounds.from(GeometryConstants.MIN_LATITUDE, GeometryConstants.MAX_LONGITUDE, + GeometryConstants.MIN_LATITUDE, GeometryConstants.MAX_LONGITUDE); + assertTrue("LatLngBounds empty span", latLngBounds.isEmptySpan()); + } + + @Test public void containsBounds() { LatLngBounds inner = new LatLngBounds.Builder() .include(new LatLng(-5, -5)) @@ -204,6 +380,27 @@ public class LatLngBoundsTest { } @Test + public void unionOverDateLine() { + LatLngBounds latLngBounds1 = new LatLngBounds.Builder() + .include(new LatLng(10, 170)) + .include(new LatLng(0, 160)) + .build(); + + LatLngBounds latLngBounds2 = new LatLngBounds.Builder() + .include(new LatLng(0, -170)) + .include(new LatLng(-10, -160)) + .build(); + + assertEquals("outer union should match", + latLngBounds1.union(latLngBounds2), + new LatLngBounds.Builder() + .include(new LatLng(10, 160)) + .include(new LatLng(-10, -160)) + .build()); + } + + + @Test public void northWest() { double minLat = 5; double minLon = 6; @@ -272,4 +469,100 @@ public class LatLngBoundsTest { Parcelable parcel = MockParcel.obtain(latLngBounds); assertEquals("Parcel should match original object", parcel, latLngBounds); } + + @Test + public void fromTileID() { + LatLngBounds bounds = LatLngBounds.from(0, 0, 0); + assertEquals(GeometryConstants.MIN_LONGITUDE, bounds.getLonWest(), DELTA); + assertEquals(GeometryConstants.MIN_MERCATOR_LATITUDE, bounds.getLatSouth(), DELTA); + assertEquals(GeometryConstants.MAX_LONGITUDE, bounds.getLonEast(), DELTA); + assertEquals(GeometryConstants.MAX_MERCATOR_LATITUDE, bounds.getLatNorth(), DELTA); + + bounds = LatLngBounds.from(10, 288, 385); + assertEquals(-78.75, bounds.getLonWest(), DELTA); + assertEquals(40.446947059600497, bounds.getLatSouth(), DELTA); + assertEquals(-78.3984375, bounds.getLonEast(), DELTA); + assertEquals(40.713955826286039, bounds.getLatNorth(), DELTA); + + } + + @Rule + public final ExpectedException exception = ExpectedException.none(); + + @Test + public void testConstructorChecksNorthLatitudeNaN() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must not be NaN"); + LatLngBounds.from(Double.NaN, 0, -20, -20); + } + + @Test + public void testConstructorChecksEastLongitudeNaN() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("longitude must not be NaN"); + LatLngBounds.from(0, Double.NaN, -20, -20); + } + + @Test + public void testConstructorChecksNorthLatitudeGreaterThan90() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must be between -90 and 90"); + LatLngBounds.from(95, 0, -20, -20); + } + + @Test + public void testConstructorChecksNorthLatitudeLessThanThanNegative90() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must be between -90 and 90"); + LatLngBounds.from(-95, 0, -20, -20); + } + + @Test + public void testConstructorChecksEastLongitudeInfinity() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("longitude must not be infinite"); + LatLngBounds.from(0, Double.POSITIVE_INFINITY, -20, -20); + } + + @Test + public void testConstructorChecksSouthLatitudeNaN() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must not be NaN"); + LatLngBounds.from(20, 20, Double.NaN, 0); + } + + @Test + public void testConstructorChecksWesttLongitudeNaN() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("longitude must not be NaN"); + LatLngBounds.from(20, 20, 0, Double.NaN); + } + + @Test + public void testConstructorChecksSouthLatitudeGreaterThan90() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must be between -90 and 90"); + LatLngBounds.from(20, 20, 95, 0); + } + + @Test + public void testConstructorChecksSouthLatitudeLessThanThanNegative90() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("latitude must be between -90 and 90"); + LatLngBounds.from(20, 20, -95, 0); + } + + @Test + public void testConstructorChecksWestLongitudeInfinity() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("longitude must not be infinite"); + LatLngBounds.from(20, 20, 0, Double.POSITIVE_INFINITY); + } + + @Test + public void testConstructorCheckLatSouthGreaterLatNorth() { + exception.expect(IllegalArgumentException.class); + exception.expectMessage("LatSouth cannot be less than latNorth"); + LatLngBounds.from(0, 20, 20, 0); + } } diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngTest.java index 06e93b9d2f..8e47f069c3 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngTest.java @@ -12,6 +12,7 @@ import org.junit.rules.ExpectedException; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -255,8 +256,17 @@ public class LatLngTest { @Test public void testWrapped() { - LatLng latLng = new LatLng(45.0, -185.0).wrap(); - assertEquals("longitude wrapped value", latLng.getLongitude(), 175.0, DELTA); + LatLng originalLatLng = new LatLng(45.0, -185.0); + LatLng newLatlng = originalLatLng.wrap(); + assertNotSame(" new wrapped LatLng is created", originalLatLng, newLatlng); + assertEquals("longitude wrapped value", originalLatLng.getLongitude(), -185.0, DELTA); + assertEquals("longitude wrapped value", newLatlng.getLongitude(), 175.0, DELTA); + + newLatlng = new LatLng(45.0, 180.0).wrap(); + assertEquals("longitude wrapped max value", newLatlng.getLongitude(), 180.0, DELTA); + + newLatlng = new LatLng(45.0, -180.0).wrap(); + assertEquals("longitude wrapped min value", newLatlng.getLongitude(), -180.0, DELTA); } @Test diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapTouchListenersTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapTouchListenersTest.java index eeb00355bd..5de55f47c9 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapTouchListenersTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapTouchListenersTest.java @@ -2,8 +2,13 @@ package com.mapbox.mapboxsdk.maps; import android.graphics.PointF; +import com.mapbox.android.gestures.MoveGestureDetector; +import com.mapbox.android.gestures.RotateGestureDetector; +import com.mapbox.android.gestures.ShoveGestureDetector; +import com.mapbox.android.gestures.StandardScaleGestureDetector; import com.mapbox.mapboxsdk.geometry.LatLng; +import org.junit.Before; import org.junit.Test; import static org.mockito.Mockito.mock; @@ -13,16 +18,23 @@ import static org.mockito.Mockito.when; public class MapTouchListenersTest { - @Test - public void onMapClickListenerTest() throws Exception { - LatLng latLng = new LatLng(); - PointF pointF = new PointF(); + private MapGestureDetector mapGestureDetector; + private LatLng latLng; + private PointF pointF; + + @Before + public void setUp() throws Exception { + latLng = new LatLng(); + pointF = new PointF(); Projection projection = mock(Projection.class); when(projection.fromScreenLocation(pointF)).thenReturn(latLng); - MapGestureDetector mapGestureDetector = new MapGestureDetector(null, - null, projection, null, null, null, null); + mapGestureDetector = new MapGestureDetector(null, + null, projection, null, null, null); + } + @Test + public void onMapClickListenerTest() throws Exception { MapboxMap.OnMapClickListener listener = mock(MapboxMap.OnMapClickListener.class); mapGestureDetector.addOnMapClickListener(listener); mapGestureDetector.notifyOnMapClickListeners(pointF); @@ -35,14 +47,6 @@ public class MapTouchListenersTest { @Test public void onMapLongClickListenerTest() throws Exception { - LatLng latLng = new LatLng(); - PointF pointF = new PointF(); - - Projection projection = mock(Projection.class); - when(projection.fromScreenLocation(pointF)).thenReturn(latLng); - MapGestureDetector mapGestureDetector = new MapGestureDetector(null, - null, projection, null, null, null, null); - MapboxMap.OnMapLongClickListener listener = mock(MapboxMap.OnMapLongClickListener.class); mapGestureDetector.addOnMapLongClickListener(listener); mapGestureDetector.notifyOnMapLongClickListeners(pointF); @@ -55,14 +59,6 @@ public class MapTouchListenersTest { @Test public void onFlingListenerTest() throws Exception { - LatLng latLng = new LatLng(); - PointF pointF = new PointF(); - - Projection projection = mock(Projection.class); - when(projection.fromScreenLocation(pointF)).thenReturn(latLng); - MapGestureDetector mapGestureDetector = new MapGestureDetector(null, - null, projection, null, null, null, null); - MapboxMap.OnFlingListener listener = mock(MapboxMap.OnFlingListener.class); mapGestureDetector.addOnFlingListener(listener); mapGestureDetector.notifyOnFlingListeners(); @@ -75,14 +71,6 @@ public class MapTouchListenersTest { @Test public void onScrollListenerTest() throws Exception { - LatLng latLng = new LatLng(); - PointF pointF = new PointF(); - - Projection projection = mock(Projection.class); - when(projection.fromScreenLocation(pointF)).thenReturn(latLng); - MapGestureDetector mapGestureDetector = new MapGestureDetector(null, - null, projection, null, null, null, null); - MapboxMap.OnScrollListener listener = mock(MapboxMap.OnScrollListener.class); mapGestureDetector.addOnScrollListener(listener); mapGestureDetector.notifyOnScrollListeners(); @@ -92,4 +80,88 @@ public class MapTouchListenersTest { mapGestureDetector.notifyOnScrollListeners(); verify(listener, times(1)).onScroll(); } + + @Test + public void onMoveListenerTest() throws Exception { + MapboxMap.OnMoveListener listener = mock(MapboxMap.OnMoveListener.class); + MoveGestureDetector detector = mock(MoveGestureDetector.class); + mapGestureDetector.addOnMoveListener(listener); + mapGestureDetector.notifyOnMoveBeginListeners(detector); + mapGestureDetector.notifyOnMoveListeners(detector); + mapGestureDetector.notifyOnMoveEndListeners(detector); + verify(listener, times(1)).onMoveBegin(detector); + verify(listener, times(1)).onMove(detector); + verify(listener, times(1)).onMoveEnd(detector); + + mapGestureDetector.removeOnMoveListener(listener); + mapGestureDetector.notifyOnMoveBeginListeners(detector); + mapGestureDetector.notifyOnMoveListeners(detector); + mapGestureDetector.notifyOnMoveEndListeners(detector); + verify(listener, times(1)).onMoveBegin(detector); + verify(listener, times(1)).onMove(detector); + verify(listener, times(1)).onMoveEnd(detector); + } + + @Test + public void onRotateListenerTest() throws Exception { + MapboxMap.OnRotateListener listener = mock(MapboxMap.OnRotateListener.class); + RotateGestureDetector detector = mock(RotateGestureDetector.class); + mapGestureDetector.addOnRotateListener(listener); + mapGestureDetector.notifyOnRotateBeginListeners(detector); + mapGestureDetector.notifyOnRotateListeners(detector); + mapGestureDetector.notifyOnRotateEndListeners(detector); + verify(listener, times(1)).onRotateBegin(detector); + verify(listener, times(1)).onRotate(detector); + verify(listener, times(1)).onRotateEnd(detector); + + mapGestureDetector.removeOnRotateListener(listener); + mapGestureDetector.notifyOnRotateBeginListeners(detector); + mapGestureDetector.notifyOnRotateListeners(detector); + mapGestureDetector.notifyOnRotateEndListeners(detector); + verify(listener, times(1)).onRotateBegin(detector); + verify(listener, times(1)).onRotate(detector); + verify(listener, times(1)).onRotateEnd(detector); + } + + @Test + public void onScaleListenerTest() throws Exception { + MapboxMap.OnScaleListener listener = mock(MapboxMap.OnScaleListener.class); + StandardScaleGestureDetector detector = mock(StandardScaleGestureDetector.class); + mapGestureDetector.addOnScaleListener(listener); + mapGestureDetector.notifyOnScaleBeginListeners(detector); + mapGestureDetector.notifyOnScaleListeners(detector); + mapGestureDetector.notifyOnScaleEndListeners(detector); + verify(listener, times(1)).onScaleBegin(detector); + verify(listener, times(1)).onScale(detector); + verify(listener, times(1)).onScaleEnd(detector); + + mapGestureDetector.removeOnScaleListener(listener); + mapGestureDetector.notifyOnScaleBeginListeners(detector); + mapGestureDetector.notifyOnScaleListeners(detector); + mapGestureDetector.notifyOnScaleEndListeners(detector); + verify(listener, times(1)).onScaleBegin(detector); + verify(listener, times(1)).onScale(detector); + verify(listener, times(1)).onScaleEnd(detector); + } + + @Test + public void onShoveListenerTest() throws Exception { + MapboxMap.OnShoveListener listener = mock(MapboxMap.OnShoveListener.class); + ShoveGestureDetector detector = mock(ShoveGestureDetector.class); + mapGestureDetector.addShoveListener(listener); + mapGestureDetector.notifyOnShoveBeginListeners(detector); + mapGestureDetector.notifyOnShoveListeners(detector); + mapGestureDetector.notifyOnShoveEndListeners(detector); + verify(listener, times(1)).onShoveBegin(detector); + verify(listener, times(1)).onShove(detector); + verify(listener, times(1)).onShoveEnd(detector); + + mapGestureDetector.removeShoveListener(listener); + mapGestureDetector.notifyOnShoveBeginListeners(detector); + mapGestureDetector.notifyOnShoveListeners(detector); + mapGestureDetector.notifyOnShoveEndListeners(detector); + verify(listener, times(1)).onShoveBegin(detector); + verify(listener, times(1)).onShove(detector); + verify(listener, times(1)).onShoveEnd(detector); + } } diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsTest.java index 65bdff41ab..9dd0ca9285 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapOptionsTest.java @@ -119,13 +119,6 @@ public class MapboxMapOptionsTest { } @Test - public void testLocationEnabled() { - assertFalse(new MapboxMapOptions().getLocationEnabled()); - assertTrue(new MapboxMapOptions().locationEnabled(true).getLocationEnabled()); - assertFalse(new MapboxMapOptions().locationEnabled(false).getLocationEnabled()); - } - - @Test public void testTiltGesturesEnabled() { assertTrue(new MapboxMapOptions().getTiltGesturesEnabled()); assertTrue(new MapboxMapOptions().tiltGesturesEnabled(true).getTiltGesturesEnabled()); @@ -176,18 +169,6 @@ public class MapboxMapOptionsTest { } @Test - public void testMyLocationForegroundTint() { - assertEquals(Color.BLUE, new MapboxMapOptions() - .myLocationForegroundTintColor(Color.BLUE).getMyLocationForegroundTintColor()); - } - - @Test - public void testMyLocationBackgroundTint() { - assertEquals(Color.BLUE, new MapboxMapOptions() - .myLocationBackgroundTintColor(Color.BLUE).getMyLocationBackgroundTintColor()); - } - - @Test public void testPrefetchesTiles() { // Default value assertTrue(new MapboxMapOptions().getPrefetchesTiles()); diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java index 5e9f94db28..9a323a1d75 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java @@ -2,7 +2,6 @@ package com.mapbox.mapboxsdk.maps; import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; import com.mapbox.mapboxsdk.geometry.LatLng; -import com.mapbox.mapboxsdk.maps.widgets.MyLocationViewSettings; import org.junit.After; import org.junit.Before; @@ -20,10 +19,8 @@ public class MapboxMapTest { mapboxMap = new MapboxMap(mock(NativeMapView.class), mock(Transform.class), mock(UiSettings.class), - mock(TrackingSettings.class), - mock(MyLocationViewSettings.class), mock(Projection.class), - mock(MapboxMap.OnRegisterTouchListener.class), + mock(MapboxMap.OnGesturesManagerInteractionListener.class), mock(AnnotationManager.class), mock(CameraChangeDispatcher.class)); } diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java deleted file mode 100644 index de5f364a5b..0000000000 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/TrackingSettingsTest.java +++ /dev/null @@ -1,99 +0,0 @@ -package com.mapbox.mapboxsdk.maps; - -import android.Manifest; -import android.content.Context; -import android.content.pm.PackageManager; -import android.graphics.PointF; - -import com.mapbox.mapboxsdk.constants.MyLocationTracking; -import com.mapbox.mapboxsdk.maps.widgets.MyLocationView; - -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.atLeast; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -public class TrackingSettingsTest { - - @InjectMocks - MyLocationView myLocationView = mock(MyLocationView.class); - - @InjectMocks - UiSettings uiSettings = mock(UiSettings.class); - - @InjectMocks - FocalPointChangeListener focalPointChangeListener = mock(FocalPointChangeListener.class); - - @InjectMocks - TrackingSettings.CameraZoomInvalidator zoomInvalidator = mock(TrackingSettings.CameraZoomInvalidator.class); - - private TrackingSettings trackingSettings; - - @Before - public void beforeTest() { - trackingSettings = new TrackingSettings(myLocationView, uiSettings, focalPointChangeListener, zoomInvalidator); - } - - @Test - public void testSanity() { - assertNotNull("trackingsettings should not be null", trackingSettings); - } - - @Test - public void testDismissTrackingModesOnGesture() { - trackingSettings.setDismissAllTrackingOnGesture(false); - assertFalse("DismissTrackingOnGesture should be false", trackingSettings.isAllDismissTrackingOnGesture()); - } - - @Test - public void testValidateGesturesForTrackingModes() { - trackingSettings.setDismissAllTrackingOnGesture(false); - trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); - assertFalse("DismissTrackingOnGesture should be false", trackingSettings.isAllDismissTrackingOnGesture()); - } - - @Test - public void testMyLocationEnabled() { - // setup mock context to provide accepted location permission - Context context = mock(Context.class); - when(myLocationView.getContext()).thenReturn(context); - when(context.checkPermission(eq(Manifest.permission.ACCESS_COARSE_LOCATION), anyInt(), - anyInt())).thenReturn(PackageManager.PERMISSION_GRANTED); - - assertFalse("Location should be disabled by default.", trackingSettings.isMyLocationEnabled()); - trackingSettings.setMyLocationEnabled(true); - assertTrue("Location should be enabled", trackingSettings.isMyLocationEnabled()); - } - - @Test - public void testCameraZoomTo2forTracking() { - trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); - verify(zoomInvalidator, atLeast(1)).zoomTo(2.0); - } - - @Test - public void testFocalPointChangeForTracking() { - final float centerX = 32.3f; - final float centerY = 46.3f; - final PointF pointF = new PointF(centerX, centerY); - when(myLocationView.getCenter()).thenReturn(pointF); - - trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); - verify(focalPointChangeListener, atLeast(1)).onFocalPointChanged(pointF); - } - - @Test - public void testFocalPointChangeForNonTracking() { - trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_NONE); - verify(focalPointChangeListener, atLeast(1)).onFocalPointChanged(null); - } -} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java index fbe00b4dce..cfce56e6e9 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/UiSettingsTest.java @@ -181,13 +181,6 @@ public class UiSettingsTest { } @Test - public void testRotateGestureChange() { - assertEquals("Default state should be true", true, uiSettings.isRotateGestureChangeAllowed()); - uiSettings.setRotateGestureChangeAllowed(false); - assertEquals("State should have been changed", false, uiSettings.isRotateGestureChangeAllowed()); - } - - @Test public void testRotateGestureChangeAllowed() { uiSettings.setRotateGesturesEnabled(false); assertEquals("Rotate gesture should be false", false, uiSettings.isRotateGesturesEnabled()); @@ -196,14 +189,6 @@ public class UiSettingsTest { } @Test - public void testRotateGestureChangeDisallowed() { - assertEquals("Rotate gesture should be true", true, uiSettings.isRotateGesturesEnabled()); - uiSettings.setRotateGestureChangeAllowed(false); - uiSettings.setRotateGesturesEnabled(false); - assertEquals("Rotate gesture change should be ignored", true, uiSettings.isRotateGesturesEnabled()); - } - - @Test public void testTiltGesturesEnabled() { uiSettings.setTiltGesturesEnabled(true); assertEquals("Tilt gesture should be enabled", true, uiSettings.isTiltGesturesEnabled()); @@ -216,13 +201,6 @@ public class UiSettingsTest { } @Test - public void testTiltGestureChange() { - assertEquals("Default state should be true", true, uiSettings.isTiltGestureChangeAllowed()); - uiSettings.setTiltGestureChangeAllowed(false); - assertEquals("State should have been changed", false, uiSettings.isTiltGestureChangeAllowed()); - } - - @Test public void testTiltGestureChangeAllowed() { uiSettings.setTiltGesturesEnabled(false); assertEquals("Tilt gesture should be false", false, uiSettings.isTiltGesturesEnabled()); @@ -231,14 +209,6 @@ public class UiSettingsTest { } @Test - public void testTiltGestureChangeDisallowed() { - assertEquals("Tilt gesture should be true", true, uiSettings.isTiltGesturesEnabled()); - uiSettings.setTiltGestureChangeAllowed(false); - uiSettings.setTiltGesturesEnabled(false); - assertEquals("Tilt gesture change should be ignored", true, uiSettings.isTiltGesturesEnabled()); - } - - @Test public void testZoomGesturesEnabled() { uiSettings.setZoomGesturesEnabled(true); assertEquals("Zoom gesture should be enabled", true, uiSettings.isZoomGesturesEnabled()); @@ -251,13 +221,6 @@ public class UiSettingsTest { } @Test - public void testZoomGestureChange() { - assertEquals("Default state should be true", true, uiSettings.isZoomGestureChangeAllowed()); - uiSettings.setZoomGestureChangeAllowed(false); - assertEquals("State should have been changed", false, uiSettings.isZoomGestureChangeAllowed()); - } - - @Test public void testZoomGestureChangeAllowed() { uiSettings.setZoomGesturesEnabled(false); assertEquals("Zoom gesture should be false", false, uiSettings.isZoomGesturesEnabled()); @@ -266,14 +229,6 @@ public class UiSettingsTest { } @Test - public void testZoomGestureChangeDisallowed() { - assertEquals("Zoom gesture should be true", true, uiSettings.isZoomGesturesEnabled()); - uiSettings.setZoomGestureChangeAllowed(false); - uiSettings.setZoomGesturesEnabled(false); - assertEquals("Zooom gesture change should be ignored", true, uiSettings.isZoomGesturesEnabled()); - } - - @Test public void testZoomControlsEnabled() { uiSettings.setZoomControlsEnabled(true); assertEquals("Zoom controls should be enabled", true, uiSettings.isZoomControlsEnabled()); @@ -298,13 +253,6 @@ public class UiSettingsTest { } @Test - public void testDoubleTapGestureChange() { - assertEquals("Default state should be true", true, uiSettings.isDoubleTapGestureChangeAllowed()); - uiSettings.setDoubleTapGestureChangeAllowed(false); - assertEquals("State should have been changed", false, uiSettings.isDoubleTapGestureChangeAllowed()); - } - - @Test public void testDoubleTapGestureChangeAllowed() { uiSettings.setDoubleTapGesturesEnabled(false); assertEquals("DoubleTap gesture should be false", false, uiSettings.isDoubleTapGesturesEnabled()); @@ -313,14 +261,6 @@ public class UiSettingsTest { } @Test - public void testDoubleTapGestureChangeDisallowed() { - assertEquals("DoubleTap gesture should be true", true, uiSettings.isDoubleTapGesturesEnabled()); - uiSettings.setDoubleTapGestureChangeAllowed(false); - uiSettings.setDoubleTapGesturesEnabled(false); - assertEquals("DoubleTap gesture change should be ignored", true, uiSettings.isDoubleTapGesturesEnabled()); - } - - @Test public void testScrollGesturesEnabled() { uiSettings.setScrollGesturesEnabled(true); assertEquals("Scroll gesture should be enabled", true, uiSettings.isScrollGesturesEnabled()); @@ -333,13 +273,6 @@ public class UiSettingsTest { } @Test - public void testScrollGestureChange() { - assertEquals("Default state should be true", true, uiSettings.isScrollGestureChangeAllowed()); - uiSettings.setScrollGestureChangeAllowed(false); - assertEquals("State should have been changed", false, uiSettings.isScrollGestureChangeAllowed()); - } - - @Test public void testScrollGestureChangeAllowed() { uiSettings.setScrollGesturesEnabled(false); assertEquals("Scroll gesture should be false", false, uiSettings.isScrollGesturesEnabled()); @@ -348,11 +281,82 @@ public class UiSettingsTest { } @Test - public void testScrollGestureChangeDisallowed() { - assertEquals("Scroll gesture should be true", true, uiSettings.isScrollGesturesEnabled()); - uiSettings.setScrollGestureChangeAllowed(false); - uiSettings.setScrollGesturesEnabled(false); - assertEquals("Scroll gesture change should be ignored", true, uiSettings.isScrollGesturesEnabled()); + public void testScaleVelocityAnimationEnabled() { + uiSettings.setScaleVelocityAnimationEnabled(true); + assertEquals("Scale velocity animation should be enabled", true, uiSettings.isScaleVelocityAnimationEnabled()); + } + + @Test + public void testScaleVelocityAnimationDisabled() { + uiSettings.setScaleVelocityAnimationEnabled(false); + assertEquals("Scale velocity animation should be disabled", false, uiSettings.isScaleVelocityAnimationEnabled()); + } + + @Test + public void testRotateVelocityAnimationEnabled() { + uiSettings.setRotateVelocityAnimationEnabled(true); + assertEquals("Rotate velocity animation should be enabled", true, uiSettings.isRotateVelocityAnimationEnabled()); + } + + @Test + public void testRotateVelocityAnimationDisabled() { + uiSettings.setRotateVelocityAnimationEnabled(false); + assertEquals("Rotate velocity animation should be disabled", false, uiSettings.isRotateVelocityAnimationEnabled()); + } + + @Test + public void testFlingVelocityAnimationEnabled() { + uiSettings.setFlingVelocityAnimationEnabled(true); + assertEquals("Fling velocity animation should be enabled", true, uiSettings.isFlingVelocityAnimationEnabled()); + } + + @Test + public void testFlingVelocityAnimationDisabled() { + uiSettings.setFlingVelocityAnimationEnabled(false); + assertEquals("Fling velocity animation should be disabled", false, uiSettings.isFlingVelocityAnimationEnabled()); + } + + @Test + public void testAllVelocityAnimationsEnabled() { + uiSettings.setAllVelocityAnimationsEnabled(true); + assertEquals("Scale velocity animation should be enabled", true, uiSettings.isScaleVelocityAnimationEnabled()); + assertEquals("Rotate velocity animation should be enabled", true, uiSettings.isRotateVelocityAnimationEnabled()); + assertEquals("Fling velocity animation should be enabled", true, uiSettings.isFlingVelocityAnimationEnabled()); + } + + @Test + public void testAllVelocityAnimationsDisabled() { + uiSettings.setAllVelocityAnimationsEnabled(false); + assertEquals("Scale velocity animation should be disabled", false, uiSettings.isScaleVelocityAnimationEnabled()); + assertEquals("Rotate velocity animation should be disabled", false, uiSettings.isRotateVelocityAnimationEnabled()); + assertEquals("Fling velocity animation should be disabled", false, uiSettings.isFlingVelocityAnimationEnabled()); + } + + @Test + public void testIncreaseRotateThresholdWhenScalingEnabled() { + uiSettings.setIncreaseRotateThresholdWhenScaling(true); + assertEquals("Rotate threshold increase should be enabled", true, + uiSettings.isIncreaseRotateThresholdWhenScaling()); + } + + @Test + public void testIncreaseRotateThresholdWhenScalingDisabled() { + uiSettings.setIncreaseRotateThresholdWhenScaling(false); + assertEquals("Rotate threshold increase should be disabled", false, + uiSettings.isIncreaseRotateThresholdWhenScaling()); + } + + @Test + public void testIncreaseScaleThresholdWhenRotatingEnabled() { + uiSettings.setIncreaseScaleThresholdWhenRotating(true); + assertEquals("Scale threshold increase should be enabled", true, uiSettings.isIncreaseScaleThresholdWhenRotating()); + } + + @Test + public void testIncreaseScaleThresholdWhenRotatingDisabled() { + uiSettings.setIncreaseScaleThresholdWhenRotating(false); + assertEquals("Scale threshold increase should be disabled", false, + uiSettings.isIncreaseScaleThresholdWhenRotating()); } @Test diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/widgets/MyLocationViewSettingsTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/widgets/MyLocationViewSettingsTest.java deleted file mode 100644 index c9ce19dc85..0000000000 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/widgets/MyLocationViewSettingsTest.java +++ /dev/null @@ -1,106 +0,0 @@ -package com.mapbox.mapboxsdk.maps.widgets; - -import android.graphics.Color; -import android.graphics.drawable.Drawable; - -import com.mapbox.mapboxsdk.maps.FocalPointChangeListener; -import com.mapbox.mapboxsdk.maps.Projection; -import com.mapbox.mapboxsdk.maps.TrackingSettings; - -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; - -import java.util.Arrays; - -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertFalse; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -public class MyLocationViewSettingsTest { - - @InjectMocks - Projection projection = mock(Projection.class); - - @InjectMocks - MyLocationView myLocationView = mock(MyLocationView.class); - - @InjectMocks - TrackingSettings trackingSettings = mock(TrackingSettings.class); - - @InjectMocks - FocalPointChangeListener focalPointChangeListener = mock(FocalPointChangeListener.class); - - private MyLocationViewSettings locationViewSettings; - - @Before - public void beforeTest() { - locationViewSettings = new MyLocationViewSettings(myLocationView, projection, focalPointChangeListener); - } - - @Test - public void testSanity() { - assertNotNull("should not be null", locationViewSettings); - } - - @Test - public void testForegroundDrawables() { - Drawable foregroundDrawable = mock(Drawable.class); - Drawable foregroundBearingDrawable = mock(Drawable.class); - Drawable.ConstantState constantState = mock(Drawable.ConstantState.class); - when(foregroundDrawable.getConstantState()).thenReturn(constantState); - when(constantState.newDrawable()).thenReturn(foregroundDrawable); - locationViewSettings.setForegroundDrawable(foregroundDrawable, foregroundBearingDrawable); - assertEquals("foreground should match", foregroundDrawable, locationViewSettings.getForegroundDrawable()); - assertEquals("foreground bearing should match", foregroundBearingDrawable, - locationViewSettings.getForegroundBearingDrawable()); - } - - @Test - public void testBackgroundDrawable() { - Drawable backgroundDrawable = mock(Drawable.class); - int[] offset = new int[] {1, 2, 3, 4}; - locationViewSettings.setBackgroundDrawable(backgroundDrawable, offset); - assertEquals("foreground should match", backgroundDrawable, locationViewSettings.getBackgroundDrawable()); - assertTrue("offsets should match", Arrays.equals(offset, locationViewSettings.getBackgroundOffset())); - } - - @Test - public void testForegroundTint() { - int color = Color.RED; - locationViewSettings.setForegroundTintColor(Color.RED); - assertEquals("color should match", color, locationViewSettings.getForegroundTintColor()); - } - - @Test - public void testForegroundTransparentTint() { - int color = Color.TRANSPARENT; - locationViewSettings.setForegroundTintColor(Color.TRANSPARENT); - assertEquals("color should match", color, locationViewSettings.getForegroundTintColor()); - } - - @Test - public void testBackgroundTint() { - int color = Color.RED; - locationViewSettings.setBackgroundTintColor(Color.RED); - assertEquals("color should match", color, locationViewSettings.getBackgroundTintColor()); - } - - @Test - public void testBackgroundTransparentTint() { - int color = Color.TRANSPARENT; - locationViewSettings.setBackgroundTintColor(Color.TRANSPARENT); - assertEquals("color should match", color, locationViewSettings.getBackgroundTintColor()); - } - - @Test - public void testEnabled() { - assertFalse("initial state should be false", locationViewSettings.isEnabled()); - locationViewSettings.setEnabled(true); - assertTrue("state should be true", locationViewSettings.isEnabled()); - } -} - diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/expressions/ExpressionTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/expressions/ExpressionTest.java new file mode 100644 index 0000000000..45833e8556 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/expressions/ExpressionTest.java @@ -0,0 +1,1168 @@ +package com.mapbox.mapboxsdk.style.expressions; + +import android.graphics.Color; + +import org.junit.Test; + +import java.util.Arrays; + +import static com.mapbox.mapboxsdk.style.expressions.Expression.abs; +import static com.mapbox.mapboxsdk.style.expressions.Expression.acos; +import static com.mapbox.mapboxsdk.style.expressions.Expression.all; +import static com.mapbox.mapboxsdk.style.expressions.Expression.any; +import static com.mapbox.mapboxsdk.style.expressions.Expression.array; +import static com.mapbox.mapboxsdk.style.expressions.Expression.asin; +import static com.mapbox.mapboxsdk.style.expressions.Expression.at; +import static com.mapbox.mapboxsdk.style.expressions.Expression.atan; +import static com.mapbox.mapboxsdk.style.expressions.Expression.bool; +import static com.mapbox.mapboxsdk.style.expressions.Expression.ceil; +import static com.mapbox.mapboxsdk.style.expressions.Expression.coalesce; +import static com.mapbox.mapboxsdk.style.expressions.Expression.color; +import static com.mapbox.mapboxsdk.style.expressions.Expression.concat; +import static com.mapbox.mapboxsdk.style.expressions.Expression.cos; +import static com.mapbox.mapboxsdk.style.expressions.Expression.cubicBezier; +import static com.mapbox.mapboxsdk.style.expressions.Expression.division; +import static com.mapbox.mapboxsdk.style.expressions.Expression.downcase; +import static com.mapbox.mapboxsdk.style.expressions.Expression.e; +import static com.mapbox.mapboxsdk.style.expressions.Expression.eq; +import static com.mapbox.mapboxsdk.style.expressions.Expression.exponential; +import static com.mapbox.mapboxsdk.style.expressions.Expression.floor; +import static com.mapbox.mapboxsdk.style.expressions.Expression.geometryType; +import static com.mapbox.mapboxsdk.style.expressions.Expression.get; +import static com.mapbox.mapboxsdk.style.expressions.Expression.gt; +import static com.mapbox.mapboxsdk.style.expressions.Expression.gte; +import static com.mapbox.mapboxsdk.style.expressions.Expression.has; +import static com.mapbox.mapboxsdk.style.expressions.Expression.heatmapDensity; +import static com.mapbox.mapboxsdk.style.expressions.Expression.id; +import static com.mapbox.mapboxsdk.style.expressions.Expression.interpolate; +import static com.mapbox.mapboxsdk.style.expressions.Expression.length; +import static com.mapbox.mapboxsdk.style.expressions.Expression.let; +import static com.mapbox.mapboxsdk.style.expressions.Expression.linear; +import static com.mapbox.mapboxsdk.style.expressions.Expression.literal; +import static com.mapbox.mapboxsdk.style.expressions.Expression.ln; +import static com.mapbox.mapboxsdk.style.expressions.Expression.ln2; +import static com.mapbox.mapboxsdk.style.expressions.Expression.log10; +import static com.mapbox.mapboxsdk.style.expressions.Expression.log2; +import static com.mapbox.mapboxsdk.style.expressions.Expression.lt; +import static com.mapbox.mapboxsdk.style.expressions.Expression.lte; +import static com.mapbox.mapboxsdk.style.expressions.Expression.match; +import static com.mapbox.mapboxsdk.style.expressions.Expression.max; +import static com.mapbox.mapboxsdk.style.expressions.Expression.min; +import static com.mapbox.mapboxsdk.style.expressions.Expression.mod; +import static com.mapbox.mapboxsdk.style.expressions.Expression.neq; +import static com.mapbox.mapboxsdk.style.expressions.Expression.not; +import static com.mapbox.mapboxsdk.style.expressions.Expression.number; +import static com.mapbox.mapboxsdk.style.expressions.Expression.object; +import static com.mapbox.mapboxsdk.style.expressions.Expression.pi; +import static com.mapbox.mapboxsdk.style.expressions.Expression.pow; +import static com.mapbox.mapboxsdk.style.expressions.Expression.product; +import static com.mapbox.mapboxsdk.style.expressions.Expression.properties; +import static com.mapbox.mapboxsdk.style.expressions.Expression.rgb; +import static com.mapbox.mapboxsdk.style.expressions.Expression.rgba; +import static com.mapbox.mapboxsdk.style.expressions.Expression.round; +import static com.mapbox.mapboxsdk.style.expressions.Expression.sin; +import static com.mapbox.mapboxsdk.style.expressions.Expression.sqrt; +import static com.mapbox.mapboxsdk.style.expressions.Expression.step; +import static com.mapbox.mapboxsdk.style.expressions.Expression.stop; +import static com.mapbox.mapboxsdk.style.expressions.Expression.string; +import static com.mapbox.mapboxsdk.style.expressions.Expression.subtract; +import static com.mapbox.mapboxsdk.style.expressions.Expression.sum; +import static com.mapbox.mapboxsdk.style.expressions.Expression.switchCase; +import static com.mapbox.mapboxsdk.style.expressions.Expression.tan; +import static com.mapbox.mapboxsdk.style.expressions.Expression.toBool; +import static com.mapbox.mapboxsdk.style.expressions.Expression.toColor; +import static com.mapbox.mapboxsdk.style.expressions.Expression.toNumber; +import static com.mapbox.mapboxsdk.style.expressions.Expression.toRgba; +import static com.mapbox.mapboxsdk.style.expressions.Expression.typeOf; +import static com.mapbox.mapboxsdk.style.expressions.Expression.upcase; +import static com.mapbox.mapboxsdk.style.expressions.Expression.var; +import static com.mapbox.mapboxsdk.style.expressions.Expression.zoom; +import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineOpacity; +import static junit.framework.Assert.assertTrue; +import static org.junit.Assert.assertEquals; + +/** + * Expression unit tests that validate the expression output with the expected Object[]array representation. + */ +public class ExpressionTest { + + @Test + public void testRgb() throws Exception { + Object[] expected = new Object[] {"rgb", 0, 0, 0}; + Object[] actual = rgb(literal(0), literal(0), literal(0)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testRgbLiteral() throws Exception { + Object[] expected = new Object[] {"rgb", 0, 0, 0}; + Object[] actual = rgb(0, 0, 0).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testRgba() throws Exception { + Object[] expected = new Object[] {"rgba", 0, 0, 0, 1}; + Object[] actual = rgba(literal(0), literal(0), literal(0), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testRgbaLiteral() throws Exception { + Object[] expected = new Object[] {"rgba", 0, 0, 0, 1}; + Object[] actual = rgba(0, 0, 0, 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testToRgba() throws Exception { + Object[] expected = new Object[] {"to-rgba", new Object[] {"to-color", "rgba(255, 0, 0, 255)"}}; + Object[] actual = toRgba(color(Color.RED)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testEq() throws Exception { + Object[] expected = new Object[] {"==", 1, 1}; + Object[] actual = eq(literal(1), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testEqLiteral() throws Exception { + Object[] expected = new Object[] {"==", 1, 1}; + Object[] actual = eq(literal(1), 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testNeq() throws Exception { + Object[] expected = new Object[] {"!=", 0, 1}; + Object[] actual = neq(literal(0), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testNeqLiteral() throws Exception { + Object[] expected = new Object[] {"!=", 0, 1}; + Object[] actual = neq(literal(0), 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGt() throws Exception { + Object[] expected = new Object[] {">", 0, 1}; + Object[] actual = gt(literal(0), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGtLiteral() throws Exception { + Object[] expected = new Object[] {">", 0, 1}; + Object[] actual = gt(literal(0), 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLt() throws Exception { + Object[] expected = new Object[] {"<", 1, 0}; + Object[] actual = lt(literal(1), literal(0)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLtLiteral() throws Exception { + Object[] expected = new Object[] {"<", 1, 0}; + Object[] actual = lt(literal(1), 0).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGte() throws Exception { + Object[] expected = new Object[] {">=", 1, 1}; + Object[] actual = gte(literal(1), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGteLiteral() throws Exception { + Object[] expected = new Object[] {">=", 1, 1}; + Object[] actual = gte(literal(1), 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLte() throws Exception { + Object[] expected = new Object[] {"<=", 1, 1}; + Object[] actual = lte(literal(1), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLteLiteral() throws Exception { + Object[] expected = new Object[] {"<=", 1, 1}; + Object[] actual = lte(literal(1), 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAll() throws Exception { + Object[] expected = new Object[] {"all", true, true, true}; + Object[] actual = all(literal(true), literal(true), literal(true)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAny() throws Exception { + Object[] expected = new Object[] {"any", true, false, false}; + Object[] actual = any(literal(true), literal(false), literal(false)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testNot() throws Exception { + Object[] expected = new Object[] {"!", false}; + Object[] actual = not(literal(false)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testNotLiteral() throws Exception { + Object[] expected = new Object[] {"!", false}; + Object[] actual = not(false).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSwitchCase() throws Exception { + Object[] expectedCaseOneGet = new Object[] {"get", "key1"}; + Object[] expectedCaseOne = new Object[] {"==", expectedCaseOneGet, "value1"}; + Object[] expectedCaseTwoGet = new Object[] {"get", "key2"}; + Object[] expectedCaseTwo = new Object[] {"!=", expectedCaseTwoGet, "value2"}; + Object[] expected = new Object[] {"case", expectedCaseOne, expectedCaseTwo}; + + Object[] actual = switchCase( + eq(get(literal("key1")), literal("value1")), + neq(get(literal("key2")), literal("value2")) + ).toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSwitchCaseLiteral() throws Exception { + Object[] expectedCaseOneGet = new Object[] {"get", "key1"}; + Object[] expectedCaseOne = new Object[] {"==", expectedCaseOneGet, "value1"}; + Object[] expectedCaseTwoGet = new Object[] {"get", "key2"}; + Object[] expectedCaseTwo = new Object[] {"!=", expectedCaseTwoGet, "value2"}; + Object[] expected = new Object[] {"case", expectedCaseOne, expectedCaseTwo}; + + Object[] actual = switchCase( + eq(get("key1"), literal("value1")), + neq(get("key2"), literal("value2")) + ).toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMatch() throws Exception { + String input = "input"; + String[] labels = new String[] {"a", "b", "c"}; + String[] outputs = new String[] {"1", "2", "3"}; + String defaultOutput = "0"; + + Object[] expected = new Object[] {"match", input, + labels[0], outputs[0], + labels[1], outputs[1], + labels[2], outputs[2], + defaultOutput}; + + Object[] actual = match(literal(input), + literal(labels[0]), literal(outputs[0]), + literal(labels[1]), literal(outputs[1]), + literal(labels[2]), literal(outputs[2]), + literal(defaultOutput) + ).toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMatchWithStops() throws Exception { + String input = "input"; + String[] labels = new String[] {"a", "b", "c"}; + String[] outputs = new String[] {"1", "2", "3"}; + String defaultOutput = "0"; + + Object[] expected = new Object[] {"match", input, + labels[0], outputs[0], + labels[1], outputs[1], + labels[2], outputs[2], + defaultOutput}; + + Object[] actual = match(literal(input), literal(defaultOutput), + stop(labels[0], outputs[0]), + stop(labels[1], outputs[1]), + stop(labels[2], outputs[2])) + .toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCoalesce() throws Exception { + Object[] expectedGetOne = new Object[] {"get", "invalidKey"}; + Object[] expectedGetTwo = new Object[] {"get", "validKey"}; + Object[] expected = new Object[] {"coalesce", expectedGetOne, expectedGetTwo}; + + Object[] actual = coalesce( + get(literal("invalidKey")), + get(literal("validKey")) + ).toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCoalesceLiteral() throws Exception { + Object[] expectedGetOne = new Object[] {"get", "invalidKey"}; + Object[] expectedGetTwo = new Object[] {"get", "validKey"}; + Object[] expected = new Object[] {"coalesce", expectedGetOne, expectedGetTwo}; + + Object[] actual = coalesce( + get("invalidKey"), + get("validKey") + ).toArray(); + + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testProperties() throws Exception { + Object[] expected = new Object[] {"properties"}; + Object[] actual = properties().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGeometryType() throws Exception { + Object[] expected = new Object[] {"geometry-type"}; + Object[] actual = geometryType().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testId() throws Exception { + Object[] expected = new Object[] {"id"}; + Object[] actual = id().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHeatmapDensity() throws Exception { + Object[] expected = new Object[] {"heatmap-density"}; + Object[] actual = heatmapDensity().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAt() throws Exception { + Object[] expected = new Object[] {"at", 3, new Object[] {"literal", new Object[] {"one", "two"}}}; + Object[] actual = at(literal(3), literal(new Object[] {"one", "two"})).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAtLiteral() throws Exception { + Object[] expected = new Object[] {"at", 3, new Object[] {"literal", new Object[] {"one", "two"}}}; + Object[] actual = at(3, literal(new Object[] {"one", "two"})).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAtExpression() throws Exception { + Object[] expected = new Object[] {"at", 3, new Object[] {"properties"}}; + Object[] actual = at(literal(3), properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGet() throws Exception { + Object[] expected = new Object[] {"get", "key"}; + Object[] actual = get(literal("key")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGetLiteral() throws Exception { + Object[] expected = new Object[] {"get", "key"}; + Object[] actual = get("key").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGetObject() throws Exception { + Object[] expected = new Object[] {"get", "key", new Object[] {"properties"}}; + Object[] actual = get(literal("key"), properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testGetObjectLiteral() throws Exception { + Object[] expected = new Object[] {"get", "key", new Object[] {"properties"}}; + Object[] actual = get("key", properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHas() throws Exception { + Object[] expected = new Object[] {"has", "key"}; + Object[] actual = has(literal("key")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHasLiteral() throws Exception { + Object[] expected = new Object[] {"has", "key"}; + Object[] actual = has("key").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHasObject() throws Exception { + Object[] expected = new Object[] {"has", "key", new Object[] {"properties"}}; + Object[] actual = has(literal("key"), properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHasObjectLiteral() throws Exception { + Object[] expected = new Object[] {"has", "key", new Object[] {"properties"}}; + Object[] actual = has("key", properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHasExpression() throws Exception { + Object[] expected = new Object[] {"has", new Object[] {"get", "key"}, new Object[] {"properties"}}; + Object[] actual = has(get(literal("key")), properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testHasExpressionLiteral() throws Exception { + Object[] expected = new Object[] {"has", new Object[] {"get", "key"}, new Object[] {"properties"}}; + Object[] actual = has(get("key"), properties()).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLength() throws Exception { + Object[] expected = new Object[] {"length", "key"}; + Object[] actual = length(literal("key")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLengthLiteral() throws Exception { + Object[] expected = new Object[] {"length", "key"}; + Object[] actual = length("key").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLengthExpression() throws Exception { + Object[] expected = new Object[] {"length", new Object[] {"get", "key"}}; + Object[] actual = length(get(literal("key"))).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLn2() throws Exception { + Object[] expected = new Object[] {"ln2"}; + Object[] actual = ln2().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testPi() throws Exception { + Object[] expected = new Object[] {"pi"}; + Object[] actual = pi().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testE() throws Exception { + Object[] expected = new Object[] {"e"}; + Object[] actual = e().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSum() throws Exception { + Object[] expected = new Object[] {"+", 1, 2}; + Object[] actual = sum(literal(1), literal(2)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSumLiteral() throws Exception { + Object[] expected = new Object[] {"+", 1, 2}; + Object[] actual = sum(1, 2).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testProduct() throws Exception { + Object[] expected = new Object[] {"*", 1, 2}; + Object[] actual = product(literal(1), literal(2)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testProductLiteral() throws Exception { + Object[] expected = new Object[] {"*", 1, 2}; + Object[] actual = product(1, 2).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSubtract() throws Exception { + Object[] expected = new Object[] {"-", 2, 1}; + Object[] actual = subtract(literal(2), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSubtractLiteral() throws Exception { + Object[] expected = new Object[] {"-", 2, 1}; + Object[] actual = subtract(2, 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testDivision() throws Exception { + Object[] expected = new Object[] {"/", 2, 1}; + Object[] actual = division(literal(2), literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testDivisionLiteral() throws Exception { + Object[] expected = new Object[] {"/", 2, 1}; + Object[] actual = division(2, 1).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testDivisionWithNestedGet() throws Exception { + Object nestedGet = new Object[] {"get", "key"}; + Object[] expected = new Object[] {"/", 2, nestedGet}; + Object[] actual = division(literal(2), get(literal("key"))).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMod() throws Exception { + Object[] expected = new Object[] {"%", 1, 3}; + Object[] actual = mod(literal(1), literal(3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testModLiteral() throws Exception { + Object[] expected = new Object[] {"%", 1, 3}; + Object[] actual = mod(1, 3).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testPow() throws Exception { + Object[] expected = new Object[] {"^", 2, 3}; + Object[] actual = pow(literal(2), literal(3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testPowLiteral() throws Exception { + Object[] expected = new Object[] {"^", 2, 3}; + Object[] actual = pow(2, 3).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSqrt() throws Exception { + Object[] expected = new Object[] {"sqrt", 4}; + Object[] actual = sqrt(literal(4)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSqrtLiteral() throws Exception { + Object[] expected = new Object[] {"sqrt", 4}; + Object[] actual = sqrt(4).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLog10() throws Exception { + Object[] expected = new Object[] {"log10", 10}; + Object[] actual = log10(literal(10)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLog10Literal() throws Exception { + Object[] expected = new Object[] {"log10", 10}; + Object[] actual = log10(10).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLn() throws Exception { + Object[] expected = new Object[] {"ln", 2}; + Object[] actual = ln(literal(2)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLnLiteral() throws Exception { + Object[] expected = new Object[] {"ln", 2}; + Object[] actual = ln(2).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLog2() throws Exception { + Object[] expected = new Object[] {"log2", 16}; + Object[] actual = log2(literal(16)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLog2Literal() throws Exception { + Object[] expected = new Object[] {"log2", 16}; + Object[] actual = log2(16).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSin() throws Exception { + Object[] expected = new Object[] {"sin", 45}; + Object[] actual = sin(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testSinLiteral() throws Exception { + Object[] expected = new Object[] {"sin", 45}; + Object[] actual = sin(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCos() throws Exception { + Object[] expected = new Object[] {"cos", 45}; + Object[] actual = cos(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCosLiteral() throws Exception { + Object[] expected = new Object[] {"cos", 45}; + Object[] actual = cos(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testTan() throws Exception { + Object[] expected = new Object[] {"tan", 45}; + Object[] actual = tan(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testTanLiteral() throws Exception { + Object[] expected = new Object[] {"tan", 45}; + Object[] actual = tan(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAsin() throws Exception { + Object[] expected = new Object[] {"asin", 45}; + Object[] actual = asin(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAsinLiteral() throws Exception { + Object[] expected = new Object[] {"asin", 45}; + Object[] actual = asin(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAcos() throws Exception { + Object[] expected = new Object[] {"acos", 45}; + Object[] actual = acos(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAcosLiteral() throws Exception { + Object[] expected = new Object[] {"acos", 45}; + Object[] actual = acos(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAtan() throws Exception { + Object[] expected = new Object[] {"atan", 45}; + Object[] actual = atan(literal(45)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAtanLiteral() throws Exception { + Object[] expected = new Object[] {"atan", 45}; + Object[] actual = atan(45).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMin() throws Exception { + Object[] expected = new Object[] {"min", 0, 1, 2, 3}; + Object[] actual = min(literal(0), literal(1), literal(2), literal(3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMinLiteral() throws Exception { + Object[] expected = new Object[] {"min", 0, 1, 2, 3}; + Object[] actual = min(0, 1, 2, 3).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMax() throws Exception { + Object[] expected = new Object[] {"max", 0, 1, 2, 3}; + Object[] actual = max(literal(0), literal(1), literal(2), literal(3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testMaxLiteral() throws Exception { + Object[] expected = new Object[] {"max", 0, 1, 2, 3}; + Object[] actual = max(0, 1, 2, 3).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testUpcase() throws Exception { + Object[] expected = new Object[] {"upcase", "string"}; + Object[] actual = upcase(literal("string")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testUpcaseLiteral() throws Exception { + Object[] expected = new Object[] {"upcase", "string"}; + Object[] actual = upcase("string").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testDowncase() throws Exception { + Object[] expected = new Object[] {"downcase", "string"}; + Object[] actual = downcase(literal("string")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testDowncaseLiteral() throws Exception { + Object[] expected = new Object[] {"downcase", "string"}; + Object[] actual = downcase("string").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testConcat() throws Exception { + Object[] expected = new Object[] {"concat", "foo", "bar"}; + Object[] actual = concat(literal("foo"), literal("bar")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testConcatLiteral() throws Exception { + Object[] expected = new Object[] {"concat", "foo", "bar"}; + Object[] actual = concat("foo", "bar").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testArray() throws Exception { + Object[] get = new Object[] {"get", "keyToArray"}; + Object[] expected = new Object[] {"array", get}; + Object[] actual = array(get(literal("keyToArray"))).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testArrayLiteral() throws Exception { + Object[] get = new Object[] {"get", "keyToArray"}; + Object[] expected = new Object[] {"array", get}; + Object[] actual = array(get("keyToArray")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testTypeOf() throws Exception { + Object[] expected = new Object[] {"typeof", "value"}; + Object[] actual = typeOf(literal("value")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testString() throws Exception { + Object[] expected = new Object[] {"string", "value"}; + Object[] actual = string(literal("value")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testNumber() throws Exception { + Object[] expected = new Object[] {"number", 1}; + Object[] actual = number(literal(1)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testBool() throws Exception { + Object[] expected = new Object[] {"boolean", true}; + Object[] actual = bool(literal(true)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testObject() throws Exception { + Object object = new Object(); + Object[] expected = new Object[] {"object", object}; + Object[] actual = object(literal(object)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testToString() throws Exception { + Object[] expected = new Object[] {"to-string", 3}; + Object[] actual = Expression.toString(literal(3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testToNumber() throws Exception { + Object[] expected = new Object[] {"to-number", "3"}; + Object[] actual = toNumber(literal("3")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testToBool() throws Exception { + Object[] expected = new Object[] {"to-boolean", "true"}; + Object[] actual = toBool(literal("true")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testToColor() throws Exception { + Object[] expected = new Object[] {"to-color", "value"}; + Object[] actual = toColor(literal("value")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLet() throws Exception { + Object[] expected = new Object[] {"let", "letName", "value"}; + Object[] actual = let(literal("letName"), literal("value")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testVar() throws Exception { + Object[] expected = new Object[] {"var", "letName"}; + Object[] actual = var(literal("letName")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testVarLiteral() throws Exception { + Object[] expected = new Object[] {"var", "letName"}; + Object[] actual = var("letName").toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testVarExpression() throws Exception { + Object[] expected = new Object[] {"var", new Object[] {"get", "letName"}}; + Object[] actual = var(get(literal("letName"))).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testVarExpressionLiteral() throws Exception { + Object[] expected = new Object[] {"var", new Object[] {"get", "letName"}}; + Object[] actual = var(get("letName")).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testZoom() throws Exception { + Object[] expected = new Object[] {"zoom"}; + Object[] actual = zoom().toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testStepBasic() throws Exception { + Object[] expected = new Object[] {"step", 12, 11, 0, 111, 1, 1111}; + Object[] actual = step(literal(12), literal(11), literal(0), literal(111), literal(1), literal(1111)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testStepBasicLiteral() throws Exception { + Object[] expected = new Object[] {"step", new Object[] {"get", "line-width"}, 11, 0, 111, 1, 1111}; + Object[] actual = step(get("line-width"), literal(11), stop(0, 111), stop(1, 1111)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testStepExpression() throws Exception { + Object[] input = new Object[] {"get", "key"}; + Object[] number = new Object[] {"to-number", input}; + Object[] expected = new Object[] {"step", number, 11, 0, 111, 1, 1111}; + Object[] actual = step(toNumber(get(literal("key"))), + literal(11), literal(0), literal(111), literal(1), literal(1111)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testStepExpressionLiteral() throws Exception { + Object[] input = new Object[] {"get", "key"}; + Object[] number = new Object[] {"to-number", input}; + Object[] expected = new Object[] {"step", number, 11, 0, 111, 1, 1111}; + Object[] actual = step(toNumber(get("key")), literal(11), stop(0, 111), stop(1, 1111)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLinear() throws Exception { + Object[] expected = new Object[] {"interpolate", new Object[] {"linear"}, 12, 0, 1, 1, 2, 2, 3}; + Object[] actual = interpolate( + linear(), literal(12), + literal(0), literal(1), + literal(1), literal(2), + literal(2), literal(3)) + .toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLinearStops() throws Exception { + Object[] expected = new Object[] {"interpolate", new Object[] {"linear"}, 12, 0, 1, 1, 2, 2, 3}; + Object[] actual = interpolate(linear(), literal(12), stop(0, 1), stop(1, 2), stop(2, 3)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testExponential() throws Exception { + Object[] exponential = new Object[] {"exponential", 12}; + Object[] get = new Object[] {"get", "x"}; + Object[] expected = new Object[] {"interpolate", exponential, get, 0, 100, 200}; + Object[] actual = interpolate(exponential(literal(12)), + get(literal("x")), literal(0), literal(100), literal(200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testExponentialLiteral() throws Exception { + Object[] exponential = new Object[] {"exponential", 12}; + Object[] get = new Object[] {"get", "x"}; + Object[] expected = new Object[] {"interpolate", exponential, get, 0, 100, 100, 200}; + Object[] actual = interpolate(exponential(12), get("x"), stop(0, 100), stop(100, 200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testExponentialExpressionLiteral() throws Exception { + Object[] getX = new Object[] {"get", "x"}; + Object[] exponential = new Object[] {"exponential", getX}; + Object[] getY = new Object[] {"get", "y"}; + Object[] expected = new Object[] {"interpolate", exponential, getY, 0, 100, 100, 200}; + Object[] actual = interpolate(exponential(get("x")), get("y"), stop(0, 100), stop(100, 200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCubicBezier() throws Exception { + Object[] cubicBezier = new Object[] {"cubic-bezier", 1, 1, 1, 1}; + Object[] get = new Object[] {"get", "x"}; + Object[] expected = new Object[] {"interpolate", cubicBezier, get, 0, 100, 100, 200}; + Object[] actual = interpolate(cubicBezier(literal(1), literal(1), literal(1), literal(1)), + get(literal("x")), literal(0), literal(100), literal(100), literal(200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCubicBezierLiteral() throws Exception { + Object[] cubicBezier = new Object[] {"cubic-bezier", 1, 1, 1, 1}; + Object[] get = new Object[] {"get", "x"}; + Object[] expected = new Object[] {"interpolate", cubicBezier, get, 0, 100, 100, 200}; + Object[] actual = interpolate(cubicBezier(1, 1, 1, 1), get("x"), stop(0, 100), stop(100, 200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCubicBezierExpression() throws Exception { + Object[] getX = new Object[] {"get", "x"}; + Object[] getY = new Object[] {"get", "y"}; + Object[] getZ = new Object[] {"get", "z"}; + Object[] cubicBezier = new Object[] {"cubic-bezier", getZ, 1, getY, 1}; + Object[] expected = new Object[] {"interpolate", cubicBezier, getX, 0, 100, 200}; + Object[] actual = interpolate(cubicBezier(get(literal("z")), literal(1), + get(literal("y")), literal(1)), get(literal("x")), literal(0), literal(100), literal(200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCubicBezierExpressionLiteral() throws Exception { + Object[] getX = new Object[] {"get", "x"}; + Object[] getY = new Object[] {"get", "y"}; + Object[] getZ = new Object[] {"get", "z"}; + Object[] cubicBezier = new Object[] {"cubic-bezier", getZ, 1, getY, 1}; + Object[] expected = new Object[] {"interpolate", cubicBezier, getX, 0, 100, 100, 200}; + Object[] actual = interpolate(cubicBezier(get("z"), literal(1), get("y"), + literal(1)), get("x"), stop(0, 100), stop(100, 200)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testExpressionConcatToString() throws Exception { + String expected = "[\"concat\", foo, bar]"; + String actual = concat(literal("foo"), literal("bar")).toString(); + assertEquals("toString should match", expected, actual); + } + + @Test + public void testExpressionMinToString() throws Exception { + String expected = "[\"min\", 0, 1, 2, 3]"; + String actual = min(0, 1, 2, 3).toString(); + assertEquals("toString should match", expected, actual); + } + + @Test + public void testExpressionExponentialToString() throws Exception { + String expected = "[\"interpolate\", [\"cubic-bezier\", 1, 1, 1, 1], [\"get\", x], 0, 100, 100, 200]"; + String actual = interpolate(cubicBezier(literal(1), literal(1), literal(1), literal(1)), + get(literal("x")), literal(0), literal(100), literal(100), literal(200)).toString(); + assertEquals("toString should match", expected, actual); + } + + @Test + public void testLiteralArray() throws Exception { + Object[] array = new Object[] {1, "text"}; + Object[] expected = new Object[] {"literal", array}; + Object[] actual = literal(array).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testLiteralArrayString() throws Exception { + Object[] array = new Object[] {1, "text"}; + String expected = "[\"literal\"], [1, \"text\"]]"; + String actual = literal(array).toString(); + assertEquals("literal array should match", expected, actual); + } + + @Test + public void testLiteralPrimitiveArrayConversion() throws Exception { + float[] array = new float[] {0.2f, 0.5f}; + Object[] expected = new Object[] {"literal", new Object[] {0.2f, 0.5f}}; + Object[] actual = literal(array).toArray(); + assertEquals("primitive array should be converted", expected, actual); + } + + @Test + public void testColorConversion() { + Expression greenColor = color(0xFF00FF00); + Object[] expected = new Object[] {"to-color", "rgba(0, 255, 0, 255)"}; + assertTrue("expression should match", Arrays.deepEquals(expected, greenColor.toArray())); + } + + @Test(expected = IllegalArgumentException.class) + public void testThrowIllegalArgumentExceptionForPropertyValueLiteral() { + Expression expression = interpolate(exponential(1f), zoom(), + stop(17f, lineOpacity(1f)), + stop(16.5f, lineOpacity(0.5f)), + stop(16f, lineOpacity(0f)) + ); + expression.toArray(); + } + + @Test + public void testRound() { + Object[] expected = new Object[] {"round", 2.2f}; + Object[] actual = round(2.2f).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testRoundLiteral() { + Object[] expected = new Object[] {"round", 2.2f}; + Object[] actual = round(literal(2.2f)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAbs() { + Object[] expected = new Object[] {"abs", -2.2f}; + Object[] actual = abs(-2.2f).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testAbsLiteral() { + Object[] expected = new Object[] {"abs", -2.2f}; + Object[] actual = abs(literal(-2.2f)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCeil() { + Object[] expected = new Object[] {"ceil", 2.2f}; + Object[] actual = ceil(2.2f).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testCeilLiteral() { + Object[] expected = new Object[] {"ceil", 2.2f}; + Object[] actual = ceil(literal(2.2f)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testFloor() { + Object[] expected = new Object[] {"floor", 2.2f}; + Object[] actual = floor(2.2f).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } + + @Test + public void testFloorLiteral() { + Object[] expected = new Object[] {"floor", 2.2f}; + Object[] actual = floor(literal(2.2f)).toArray(); + assertTrue("expression should match", Arrays.deepEquals(expected, actual)); + } +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FilterTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FilterTest.java deleted file mode 100644 index 933bf05b39..0000000000 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FilterTest.java +++ /dev/null @@ -1,102 +0,0 @@ -package com.mapbox.mapboxsdk.style.layers; - -import org.junit.Test; - -import static com.mapbox.mapboxsdk.style.layers.Filter.all; -import static com.mapbox.mapboxsdk.style.layers.Filter.any; -import static com.mapbox.mapboxsdk.style.layers.Filter.eq; -import static com.mapbox.mapboxsdk.style.layers.Filter.gt; -import static com.mapbox.mapboxsdk.style.layers.Filter.gte; -import static com.mapbox.mapboxsdk.style.layers.Filter.has; -import static com.mapbox.mapboxsdk.style.layers.Filter.in; -import static com.mapbox.mapboxsdk.style.layers.Filter.lt; -import static com.mapbox.mapboxsdk.style.layers.Filter.lte; -import static com.mapbox.mapboxsdk.style.layers.Filter.neq; -import static com.mapbox.mapboxsdk.style.layers.Filter.none; -import static com.mapbox.mapboxsdk.style.layers.Filter.notHas; -import static com.mapbox.mapboxsdk.style.layers.Filter.notIn; -import static org.junit.Assert.assertArrayEquals; - -/** - * Tests for Filter - */ -public class FilterTest { - - @Test - public void testAll() { - assertArrayEquals(all().toArray(), new Object[] {"all"}); - assertArrayEquals( - all(eq("key", 2), neq("key", 3)).toArray(), - new Object[] {"all", new Object[] {"==", "key", 2}, new Object[] {"!=", "key", 3}} - ); - } - - @Test - public void testAny() { - assertArrayEquals(any().toArray(), new Object[] {"any"}); - assertArrayEquals( - any(eq("key", 2), neq("key", 3)).toArray(), - new Object[] {"any", new Object[] {"==", "key", 2}, new Object[] {"!=", "key", 3}} - ); - } - - @Test - public void testNone() { - assertArrayEquals(none().toArray(), new Object[] {"none"}); - assertArrayEquals( - none(eq("key", 2), neq("key", 3)).toArray(), - new Object[] {"none", new Object[] {"==", "key", 2}, new Object[] {"!=", "key", 3}} - ); - } - - @Test - public void testHas() { - assertArrayEquals(has("key").toArray(), new Object[] {"has", "key"}); - } - - @Test - public void testHasNot() { - assertArrayEquals(notHas("key").toArray(), new Object[] {"!has", "key"}); - } - - @Test - public void testEq() { - assertArrayEquals(eq("key", 1).toArray(), new Object[] {"==", "key", 1}); - - } - - @Test - public void testNeq() { - assertArrayEquals(neq("key", 1).toArray(), new Object[] {"!=", "key", 1}); - } - - @Test - public void testGt() { - assertArrayEquals(gt("key", 1).toArray(), new Object[] {">", "key", 1}); - } - - @Test - public void testGte() { - assertArrayEquals(gte("key", 1).toArray(), new Object[] {">=", "key", 1}); - } - - @Test - public void testLt() { - assertArrayEquals(lt("key", 1).toArray(), new Object[] {"<", "key", 1}); - } - - @Test - public void testLte() { - assertArrayEquals(lte("key", 1).toArray(), new Object[] {"<=", "key", 1}); - } - - @Test - public void testIn() { - assertArrayEquals(in("key", 1, 2, "Aap").toArray(), new Object[] {"in", "key", 1, 2, "Aap"}); - } - - @Test - public void testNotIn() { - assertArrayEquals(notIn("key", 1, 2, "Noot").toArray(), new Object[] {"!in", "key", 1, 2, "Noot"}); - } -} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FunctionTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FunctionTest.java deleted file mode 100644 index bac1154d62..0000000000 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/layers/FunctionTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.mapbox.mapboxsdk.style.layers; - -import com.mapbox.mapboxsdk.style.functions.Function; - -import org.junit.Test; - -import static com.mapbox.mapboxsdk.style.functions.Function.zoom; -import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop; -import static com.mapbox.mapboxsdk.style.functions.stops.Stops.interval; -import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineBlur; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertNotNull; - -/** - * Tests Function - */ -public class FunctionTest { - - @Test - public void testZoomFunction() { - Function<Float, Float> zoomF = zoom(interval( - stop(1f, lineBlur(1f)), - stop(10f, lineBlur(20f)) - ) - ); - - assertNotNull(zoomF.toValueObject()); - assertArrayEquals( - new Object[] {new Object[] {1f, 1f}, new Object[] {10f, 20f}}, - (Object[]) zoomF.toValueObject().get("stops") - ); - } - -} diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/telemetry/HttpTransportTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/telemetry/HttpTransportTest.java index 5b54496329..519124e1eb 100644 --- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/telemetry/HttpTransportTest.java +++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/telemetry/HttpTransportTest.java @@ -1,8 +1,9 @@ package com.mapbox.mapboxsdk.telemetry; +import com.mapbox.android.telemetry.TelemetryUtils; + import org.junit.Test; -import static com.mapbox.services.android.telemetry.utils.TelemetryUtils.toHumanReadableAscii; import static junit.framework.Assert.assertEquals; public class HttpTransportTest { @@ -14,6 +15,6 @@ public class HttpTransportTest { final String asciiVersion = "Sveriges Fj?ll/1.0/1 MapboxEventsAndroid/4.0.0-SNAPSHOT"; assertEquals("asciiVersion and swedishUserAgent should match", asciiVersion, - toHumanReadableAscii(swedishUserAgent)); + TelemetryUtils.toHumanReadableAscii(swedishUserAgent)); } } |