Merge branch 'master' into ls-android-readme-tweaksupstream/ls-android-readme-tweaks

9 files changed, 1291 insertions, 14 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 6ee5c157b9..7a28d846ea 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,6 +5,7 @@ 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;
@@ -24,11 +25,13 @@ 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);
   }
 
@@ -80,7 +83,7 @@ public class MapboxTest {
   }
 
   private void injectMapboxSingleton(String accessToken) {
-    Mapbox mapbox = new Mapbox(appContext, accessToken);
+    Mapbox mapbox = new Mapbox(appContext, accessToken, locationSource);
     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 8d9a360714..c3d13f0c66 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,6 +2,7 @@ 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;
 
@@ -74,15 +75,6 @@ public class LatLngBoundsTest {
   }
 
   @Test
-  public void emptySpan() {
-    latLngBounds = new LatLngBounds.Builder()
-      .include(LAT_LNG_NOT_NULL_ISLAND)
-      .include(LAT_LNG_NOT_NULL_ISLAND)
-      .build();
-    assertTrue("Should be empty", latLngBounds.isEmptySpan());
-  }
-
-  @Test
   public void notEmptySpan() {
     latLngBounds = new LatLngBounds.Builder()
       .include(LAT_LNG_NOT_NULL_ISLAND)
@@ -281,4 +273,20 @@ 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);
+
+  }
 }
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/AnnotationManagerTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/AnnotationManagerTest.java
index 0d592f9bb3..239ad7392b 100644
--- a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/AnnotationManagerTest.java
+++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/AnnotationManagerTest.java
@@ -10,6 +10,7 @@ import com.mapbox.mapboxsdk.annotations.MarkerViewManager;
 import com.mapbox.mapboxsdk.geometry.LatLng;
 
 import org.junit.Test;
+import org.mockito.ArgumentMatchers;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -32,8 +33,9 @@ public class AnnotationManagerTest {
     Markers markers = new MarkerContainer(aNativeMapView, aMapView, annotationsArray, aIconManager, aMarkerViewManager);
     Polygons polygons = new PolygonContainer(aNativeMapView, annotationsArray);
     Polylines polylines = new PolylineContainer(aNativeMapView, annotationsArray);
+    ShapeAnnotations shapeAnnotations = new ShapeAnnotationContainer(aNativeMapView, annotationsArray);
     AnnotationManager annotationManager = new AnnotationManager(aNativeMapView, aMapView, annotationsArray,
-      aMarkerViewManager, aIconManager, annotations, markers, polygons, polylines);
+      aMarkerViewManager, aIconManager, annotations, markers, polygons, polylines, shapeAnnotations);
     Marker aMarker = mock(Marker.class);
     long aId = 5L;
     when(aNativeMapView.addMarker(aMarker)).thenReturn(aId);
@@ -58,18 +60,23 @@ public class AnnotationManagerTest {
     Markers markers = new MarkerContainer(aNativeMapView, aMapView, annotationsArray, aIconManager, aMarkerViewManager);
     Polygons polygons = new PolygonContainer(aNativeMapView, annotationsArray);
     Polylines polylines = new PolylineContainer(aNativeMapView, annotationsArray);
+    ShapeAnnotations shapeAnnotations = new ShapeAnnotationContainer(aNativeMapView, annotationsArray);
     AnnotationManager annotationManager = new AnnotationManager(aNativeMapView, aMapView, annotationsArray,
-      aMarkerViewManager, aIconManager, annotations, markers, polygons, polylines);
+      aMarkerViewManager, aIconManager, annotations, markers, polygons, polylines, shapeAnnotations);
     long firstId = 1L;
     long secondId = 2L;
     List<BaseMarkerOptions> markerList = new ArrayList<>();
     MarkerOptions firstMarkerOption = new MarkerOptions().position(new LatLng()).title("first");
     MarkerOptions secondMarkerOption = new MarkerOptions().position(new LatLng()).title("second");
+
     markerList.add(firstMarkerOption);
     markerList.add(secondMarkerOption);
     MapboxMap aMapboxMap = mock(MapboxMap.class);
     when(aNativeMapView.addMarker(any(Marker.class))).thenReturn(firstId, secondId);
 
+    when(aNativeMapView.addMarkers(ArgumentMatchers.<Marker>anyList()))
+            .thenReturn(new long[]{firstId, secondId});
+
     annotationManager.addMarkers(markerList, aMapboxMap);
 
     assertEquals(2, annotationManager.getAnnotations().size());
diff --git a/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/CameraChangeDispatcherTest.java b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/CameraChangeDispatcherTest.java
new file mode 100644
index 0000000000..090d274fe7
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/CameraChangeDispatcherTest.java
@@ -0,0 +1,87 @@
+package com.mapbox.mapboxsdk.maps;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class CameraChangeDispatcherTest {
+
+  @Test
+  public void testSetCameraIdleListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraIdleListener listener = mock(MapboxMap.OnCameraIdleListener.class);
+    dispatcher.setOnCameraIdleListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraIdle();
+    verify(listener).onCameraIdle();
+  }
+
+  @Test
+  public void testSetCameraMoveStartedListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveStartedListener listener = mock(MapboxMap.OnCameraMoveStartedListener.class);
+    dispatcher.setOnCameraMoveStartedListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    verify(listener).onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+  }
+
+  @Test
+  public void testSetCameraMoveCancelListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveCanceledListener listener = mock(MapboxMap.OnCameraMoveCanceledListener.class);
+    dispatcher.setOnCameraMoveCanceledListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraMoveCanceled();
+    verify(listener).onCameraMoveCanceled();
+  }
+
+  @Test
+  public void testSetCameraMoveListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveListener listener = mock(MapboxMap.OnCameraMoveListener.class);
+    dispatcher.setOnCameraMoveListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraMove();
+    verify(listener).onCameraMove();
+  }
+
+  @Test
+  public void testAddCameraIdleListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraIdleListener listener = mock(MapboxMap.OnCameraIdleListener.class);
+    dispatcher.addOnCameraIdleListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraIdle();
+    verify(listener).onCameraIdle();
+  }
+
+  @Test
+  public void testAddCameraMoveStartedListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveStartedListener listener = mock(MapboxMap.OnCameraMoveStartedListener.class);
+    dispatcher.addOnCameraMoveStartedListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    verify(listener).onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+  }
+
+  @Test
+  public void testAddCameraMoveCancelListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveCanceledListener listener = mock(MapboxMap.OnCameraMoveCanceledListener.class);
+    dispatcher.addOnCameraMoveCancelListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraMoveCanceled();
+    verify(listener).onCameraMoveCanceled();
+  }
+
+  @Test
+  public void testAddCameraMoveListener() {
+    CameraChangeDispatcher dispatcher = new CameraChangeDispatcher();
+    MapboxMap.OnCameraMoveListener listener = mock(MapboxMap.OnCameraMoveListener.class);
+    dispatcher.addOnCameraMoveListener(listener);
+    dispatcher.onCameraMoveStarted(MapboxMap.OnCameraMoveStartedListener.REASON_API_GESTURE);
+    dispatcher.onCameraMove();
+    verify(listener).onCameraMove();
+  }
+}
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
new file mode 100644
index 0000000000..eeb00355bd
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapTouchListenersTest.java
@@ -0,0 +1,95 @@
+package com.mapbox.mapboxsdk.maps;
+
+import android.graphics.PointF;
+
+import com.mapbox.mapboxsdk.geometry.LatLng;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class MapTouchListenersTest {
+
+  @Test
+  public void onMapClickListenerTest() 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.OnMapClickListener listener = mock(MapboxMap.OnMapClickListener.class);
+    mapGestureDetector.addOnMapClickListener(listener);
+    mapGestureDetector.notifyOnMapClickListeners(pointF);
+    verify(listener, times(1)).onMapClick(latLng);
+
+    mapGestureDetector.removeOnMapClickListener(listener);
+    mapGestureDetector.notifyOnMapClickListeners(pointF);
+    verify(listener, times(1)).onMapClick(latLng);
+  }
+
+  @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);
+    verify(listener, times(1)).onMapLongClick(latLng);
+
+    mapGestureDetector.removeOnMapLongClickListener(listener);
+    mapGestureDetector.notifyOnMapLongClickListeners(pointF);
+    verify(listener, times(1)).onMapLongClick(latLng);
+  }
+
+  @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();
+    verify(listener, times(1)).onFling();
+
+    mapGestureDetector.removeOnFlingListener(listener);
+    mapGestureDetector.notifyOnFlingListeners();
+    verify(listener, times(1)).onFling();
+  }
+
+  @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();
+    verify(listener, times(1)).onScroll();
+
+    mapGestureDetector.removeOnScrollListener(listener);
+    mapGestureDetector.notifyOnScrollListeners();
+    verify(listener, times(1)).onScroll();
+  }
+}
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 ce0cb00b0b..4f929641f3 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
@@ -186,5 +186,15 @@ public class MapboxMapOptionsTest {
     assertEquals(Color.BLUE, new MapboxMapOptions()
       .myLocationBackgroundTintColor(Color.BLUE).getMyLocationBackgroundTintColor());
   }
+
+  @Test
+  public void testPrefetchesTiles() {
+    // Default value
+    assertTrue(new MapboxMapOptions().getPrefetchesTiles());
+
+    // Check mutations
+    assertTrue(new MapboxMapOptions().setPrefetchesTiles(true).getPrefetchesTiles());
+    assertFalse(new MapboxMapOptions().setPrefetchesTiles(false).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
new file mode 100644
index 0000000000..5e9f94db28
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/maps/MapboxMapTest.java
@@ -0,0 +1,47 @@
+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;
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+
+public class MapboxMapTest {
+
+  private MapboxMap mapboxMap;
+
+  @Before
+  public void beforeTest() {
+
+    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(AnnotationManager.class),
+      mock(CameraChangeDispatcher.class));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testAnimateCameraChecksDurationPositive() {
+    mapboxMap.animateCamera(CameraUpdateFactory.newLatLng(new LatLng(30.0, 30.0)),
+      0, null);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testEaseCameraChecksDurationPositive() {
+    mapboxMap.easeCamera(CameraUpdateFactory.newLatLng(new LatLng(30.0, 30.0)),
+      0, null);
+  }
+
+  @After
+  public void afterTest() {
+    mapboxMap = null;
+  }
+}
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..eb1ce8bfaa
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/style/expressions/ExpressionTest.java
@@ -0,0 +1,1010 @@
+package com.mapbox.mapboxsdk.style.expressions;
+
+import android.graphics.Color;
+
+import com.mapbox.mapboxsdk.style.layers.PropertyFactory;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+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.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.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.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 junit.framework.Assert.assertTrue;
+
+/**
+ * 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", PropertyFactory.colorToRgbaString(Color.RED)};
+    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(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(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(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(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(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(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 {
+    Object[] labelZero = new Object[] {"a", "output"};
+    Object[] labelOne = new Object[] {"b", "output2"};
+    Object[] labelTwo = new Object[] {"c", "output3"};
+
+    Object[] expected = new Object[] {"match", labelZero, labelOne, labelTwo};
+    Object[] actual = match(literal(labelZero), literal(labelOne), literal(labelTwo)).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[] {"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[] {"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[] stopZero = new Object[] {0, 1};
+    Object[] stopOne = new Object[] {1, 2};
+    Object[] stopTwo = new Object[] {2, 3};
+    Object[] expected = new Object[] {"interpolate", new Object[] {"linear"}, 12, stopZero, stopOne, stopTwo};
+    Object[] actual = interpolate(linear(), literal(12),
+      literal(stopZero), literal(stopOne), literal(stopTwo)).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));
+  }
+}
\ No newline at end of file