[android] data driven style implementation

1 files changed, 880 insertions, 189 deletions

diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java
index db47474814..7ac23daa66 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/LineLayerTest.java
@@ -1,12 +1,23 @@
-package com.mapbox.mapboxsdk.testapp.style;
 // This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.
 
+package com.mapbox.mapboxsdk.testapp.style;
+
 import android.graphics.Color;
 import android.support.test.espresso.Espresso;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
+import timber.log.Timber;
 
 import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.style.functions.CompositeFunction;
+import com.mapbox.mapboxsdk.style.functions.CameraFunction;
+import com.mapbox.mapboxsdk.style.functions.SourceFunction;
+import com.mapbox.mapboxsdk.style.functions.stops.CategoricalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.CompositeStops;
+import com.mapbox.mapboxsdk.style.functions.stops.ExponentialStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IdentityStops;
+import com.mapbox.mapboxsdk.style.functions.stops.IntervalStops;
+import com.mapbox.mapboxsdk.style.functions.stops.Stops;
 import com.mapbox.mapboxsdk.style.layers.LineLayer;
 import com.mapbox.mapboxsdk.testapp.R;
 import com.mapbox.mapboxsdk.testapp.activity.style.RuntimeStyleTestActivity;
@@ -18,30 +29,14 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import timber.log.Timber;
+import java.util.Map;
 
-import static com.mapbox.mapboxsdk.style.layers.Property.LINE_CAP_BUTT;
-import static com.mapbox.mapboxsdk.style.layers.Property.LINE_JOIN_BEVEL;
-import static com.mapbox.mapboxsdk.style.layers.Property.LINE_TRANSLATE_ANCHOR_MAP;
-import static com.mapbox.mapboxsdk.style.layers.Property.NONE;
-import static com.mapbox.mapboxsdk.style.layers.Property.VISIBLE;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineBlur;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineCap;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineColor;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineDasharray;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineGapWidth;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineJoin;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineMiterLimit;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineOffset;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineOpacity;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.linePattern;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineRoundLimit;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineTranslate;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineTranslateAnchor;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.lineWidth;
-import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.visibility;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static com.mapbox.mapboxsdk.style.functions.Function.*;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stop.stop;
+import static com.mapbox.mapboxsdk.style.functions.stops.Stops.*;
+import static org.junit.Assert.*;
+import static com.mapbox.mapboxsdk.style.layers.Property.*;
+import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;
 
 /**
  * Basic smoke tests for LineLayer
@@ -62,12 +57,6 @@ public class LineLayerTest extends BaseStyleTest {
   public void setup() {
     idlingResource = new OnMapReadyIdlingResource(rule.getActivity());
     Espresso.registerIdlingResources(idlingResource);
-  }
-
-  @Test
-  public void testSetVisibility() {
-    checkViewIsDisplayed(R.id.mapView);
-
     mapboxMap = rule.getActivity().getMapboxMap();
 
     if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
@@ -78,7 +67,12 @@ public class LineLayerTest extends BaseStyleTest {
       // Layer reference is now stale, get new reference
       layer = mapboxMap.getLayerAs("my-layer");
     }
-    Timber.i("visibility");
+  }
+
+  @Test
+  public void testSetVisibility() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("Visibility");
     assertNotNull(layer);
 
     // Get initial
@@ -90,19 +84,8 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineCap() {
+  public void testLineCapAsConstant() {
     checkViewIsDisplayed(R.id.mapView);
-
-    mapboxMap = rule.getActivity().getMapboxMap();
-
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
     Timber.i("line-cap");
     assertNotNull(layer);
 
@@ -112,19 +95,33 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineJoin() {
+  public void testLineCapAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-cap");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineCap(
+        zoom(
+          interval(
+            stop(2, lineCap(LINE_CAP_BUTT))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineCap());
+    assertNotNull(layer.getLineCap().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineCap().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getLineCap().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getLineCap().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineJoinAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-join");
     assertNotNull(layer);
 
@@ -134,19 +131,33 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineMiterLimit() {
+  public void testLineJoinAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-join");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineJoin(
+        zoom(
+          interval(
+            stop(2, lineJoin(LINE_JOIN_BEVEL))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineJoin());
+    assertNotNull(layer.getLineJoin().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineJoin().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getLineJoin().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getLineJoin().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineMiterLimitAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-miter-limit");
     assertNotNull(layer);
 
@@ -156,19 +167,34 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineRoundLimit() {
+  public void testLineMiterLimitAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-miter-limit");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineMiterLimit(
+        zoom(
+          exponential(
+            stop(2, lineMiterLimit(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineMiterLimit());
+    assertNotNull(layer.getLineMiterLimit().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineMiterLimit().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineMiterLimit().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineMiterLimit().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineMiterLimit().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineRoundLimitAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-round-limit");
     assertNotNull(layer);
 
@@ -178,19 +204,34 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineOpacity() {
+  public void testLineRoundLimitAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-round-limit");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineRoundLimit(
+        zoom(
+          exponential(
+            stop(2, lineRoundLimit(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineRoundLimit());
+    assertNotNull(layer.getLineRoundLimit().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineRoundLimit().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineRoundLimit().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineRoundLimit().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineRoundLimit().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineOpacityAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-opacity");
     assertNotNull(layer);
 
@@ -200,19 +241,142 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineColor() {
+  public void testLineOpacityAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-opacity");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineOpacity(
+        zoom(
+          exponential(
+            stop(2, lineOpacity(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOpacity());
+    assertNotNull(layer.getLineOpacity().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineOpacity().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineOpacity().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineOpacity().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineOpacity().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineOpacityAsIdentitySourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-opacity");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOpacity(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOpacity());
+    assertNotNull(layer.getLineOpacity().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOpacity().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOpacity().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getLineOpacity().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineOpacityAsExponentialSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-opacity");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOpacity(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, lineOpacity(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOpacity());
+    assertNotNull(layer.getLineOpacity().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOpacity().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOpacity().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getLineOpacity().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineOpacityAsCategoricalSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-opacity");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOpacity(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, lineOpacity(0.3f))
+          )
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOpacity());
+    assertNotNull(layer.getLineOpacity().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOpacity().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOpacity().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getLineOpacity().getFunction().getStops().getClass());
+    assertEquals(0.3f, ((SourceFunction) layer.getLineOpacity().getFunction()).getDefaultValue());
+  }
+
+  @Test
+  public void testLineOpacityAsCompositeFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-opacity");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOpacity(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, lineOpacity(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOpacity());
+    assertNotNull(layer.getLineOpacity().getFunction());
+    assertEquals(CompositeFunction.class, layer.getLineOpacity().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getLineOpacity().getFunction()).getProperty());
+    assertEquals(CompositeStops.class, layer.getLineOpacity().getFunction().getStops().getClass());
+    assertEquals(1, ((CompositeStops) layer.getLineOpacity().getFunction().getStops()).size());
+
+    CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>> stops =
+      (CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>>) layer.getLineOpacity().getFunction().getStops();
+    Map.Entry<Float, ExponentialStops<Float, Float>> stop = stops.iterator().next();
+    assertEquals(ExponentialStops.class, stop.getValue().getClass());
+    assertEquals(0f, stop.getKey(), 0.001);
+    assertEquals(1, stop.getValue().size());
+    assertEquals(0.3f, stop.getValue().iterator().next().in, 0.001f);
+    assertEquals(0.9f, stop.getValue().iterator().next().out, 0.001f);
+  }
+
+  @Test
+  public void testLineColorAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-color");
     assertNotNull(layer);
 
@@ -222,19 +386,105 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineColorAsInt() {
+  public void testLineColorAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-color");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineColor(
+        zoom(
+          exponential(
+            stop(2, lineColor("rgba(0, 0, 0, 1)"))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineColor());
+    assertNotNull(layer.getLineColor().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineColor().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineColor().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineColor().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineColor().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineColorAsIdentitySourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineColor(property("FeaturePropertyA", Stops.<String>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getLineColor());
+    assertNotNull(layer.getLineColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineColor().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getLineColor().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineColorAsExponentialSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineColor(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(Color.RED, lineColor(Color.RED))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineColor());
+    assertNotNull(layer.getLineColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineColor().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getLineColor().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineColorAsCategoricalSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-color");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineColor(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop("valueA", lineColor(Color.RED))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineColor());
+    assertNotNull(layer.getLineColor().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineColor().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineColor().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getLineColor().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineColorAsIntConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-color");
     assertNotNull(layer);
 
@@ -244,41 +494,45 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineTranslate() {
+  public void testLineTranslateAsConstant() {
     checkViewIsDisplayed(R.id.mapView);
-
-    mapboxMap = rule.getActivity().getMapboxMap();
-
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
     Timber.i("line-translate");
     assertNotNull(layer);
 
     // Set and Get
-    layer.setProperties(lineTranslate(new Float[] {0f, 0f}));
-    assertEquals((Float[]) layer.getLineTranslate().getValue(), (Float[]) new Float[] {0f, 0f});
+    layer.setProperties(lineTranslate(new Float[]{0f,0f}));
+    assertEquals((Float[]) layer.getLineTranslate().getValue(), (Float[]) new Float[]{0f,0f});
   }
 
   @Test
-  public void testLineTranslateAnchor() {
+  public void testLineTranslateAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-translate");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineTranslate(
+        zoom(
+          exponential(
+            stop(2, lineTranslate(new Float[]{0f,0f}))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineTranslate());
+    assertNotNull(layer.getLineTranslate().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineTranslate().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineTranslate().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineTranslate().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineTranslate().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineTranslateAnchorAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-translate-anchor");
     assertNotNull(layer);
 
@@ -288,19 +542,33 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineWidth() {
+  public void testLineTranslateAnchorAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-translate-anchor");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineTranslateAnchor(
+        zoom(
+          interval(
+            stop(2, lineTranslateAnchor(LINE_TRANSLATE_ANCHOR_MAP))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineTranslateAnchor());
+    assertNotNull(layer.getLineTranslateAnchor().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineTranslateAnchor().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getLineTranslateAnchor().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getLineTranslateAnchor().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineWidthAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-width");
     assertNotNull(layer);
 
@@ -310,19 +578,34 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineGapWidth() {
+  public void testLineWidthAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-width");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineWidth(
+        zoom(
+          exponential(
+            stop(2, lineWidth(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineWidth());
+    assertNotNull(layer.getLineWidth().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineWidth().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineWidth().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineWidth().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineWidth().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineGapWidthAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-gap-width");
     assertNotNull(layer);
 
@@ -332,19 +615,142 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineOffset() {
+  public void testLineGapWidthAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-gap-width");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineGapWidth(
+        zoom(
+          exponential(
+            stop(2, lineGapWidth(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineGapWidth());
+    assertNotNull(layer.getLineGapWidth().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineGapWidth().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineGapWidth().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineGapWidth().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineGapWidth().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineGapWidthAsIdentitySourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-gap-width");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineGapWidth(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getLineGapWidth());
+    assertNotNull(layer.getLineGapWidth().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineGapWidth().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineGapWidth().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getLineGapWidth().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineGapWidthAsExponentialSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-gap-width");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineGapWidth(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, lineGapWidth(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineGapWidth());
+    assertNotNull(layer.getLineGapWidth().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineGapWidth().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineGapWidth().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getLineGapWidth().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineGapWidthAsCategoricalSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-gap-width");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineGapWidth(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, lineGapWidth(0.3f))
+          )
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineGapWidth());
+    assertNotNull(layer.getLineGapWidth().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineGapWidth().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineGapWidth().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getLineGapWidth().getFunction().getStops().getClass());
+    assertEquals(0.3f, ((SourceFunction) layer.getLineGapWidth().getFunction()).getDefaultValue());
+  }
+
+  @Test
+  public void testLineGapWidthAsCompositeFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-gap-width");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineGapWidth(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, lineGapWidth(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineGapWidth());
+    assertNotNull(layer.getLineGapWidth().getFunction());
+    assertEquals(CompositeFunction.class, layer.getLineGapWidth().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getLineGapWidth().getFunction()).getProperty());
+    assertEquals(CompositeStops.class, layer.getLineGapWidth().getFunction().getStops().getClass());
+    assertEquals(1, ((CompositeStops) layer.getLineGapWidth().getFunction().getStops()).size());
+
+    CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>> stops =
+      (CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>>) layer.getLineGapWidth().getFunction().getStops();
+    Map.Entry<Float, ExponentialStops<Float, Float>> stop = stops.iterator().next();
+    assertEquals(ExponentialStops.class, stop.getValue().getClass());
+    assertEquals(0f, stop.getKey(), 0.001);
+    assertEquals(1, stop.getValue().size());
+    assertEquals(0.3f, stop.getValue().iterator().next().in, 0.001f);
+    assertEquals(0.9f, stop.getValue().iterator().next().out, 0.001f);
+  }
+
+  @Test
+  public void testLineOffsetAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-offset");
     assertNotNull(layer);
 
@@ -354,19 +760,142 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineBlur() {
+  public void testLineOffsetAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-offset");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineOffset(
+        zoom(
+          exponential(
+            stop(2, lineOffset(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOffset());
+    assertNotNull(layer.getLineOffset().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineOffset().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineOffset().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineOffset().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineOffset().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineOffsetAsIdentitySourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-offset");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOffset(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOffset());
+    assertNotNull(layer.getLineOffset().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOffset().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOffset().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getLineOffset().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineOffsetAsExponentialSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-offset");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOffset(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, lineOffset(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOffset());
+    assertNotNull(layer.getLineOffset().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOffset().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOffset().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getLineOffset().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineOffsetAsCategoricalSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-offset");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOffset(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, lineOffset(0.3f))
+          )
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOffset());
+    assertNotNull(layer.getLineOffset().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineOffset().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineOffset().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getLineOffset().getFunction().getStops().getClass());
+    assertEquals(0.3f, ((SourceFunction) layer.getLineOffset().getFunction()).getDefaultValue());
+  }
+
+  @Test
+  public void testLineOffsetAsCompositeFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-offset");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineOffset(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, lineOffset(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineOffset());
+    assertNotNull(layer.getLineOffset().getFunction());
+    assertEquals(CompositeFunction.class, layer.getLineOffset().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getLineOffset().getFunction()).getProperty());
+    assertEquals(CompositeStops.class, layer.getLineOffset().getFunction().getStops().getClass());
+    assertEquals(1, ((CompositeStops) layer.getLineOffset().getFunction().getStops()).size());
+
+    CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>> stops =
+      (CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>>) layer.getLineOffset().getFunction().getStops();
+    Map.Entry<Float, ExponentialStops<Float, Float>> stop = stops.iterator().next();
+    assertEquals(ExponentialStops.class, stop.getValue().getClass());
+    assertEquals(0f, stop.getKey(), 0.001);
+    assertEquals(1, stop.getValue().size());
+    assertEquals(0.3f, stop.getValue().iterator().next().in, 0.001f);
+    assertEquals(0.9f, stop.getValue().iterator().next().out, 0.001f);
+  }
+
+  @Test
+  public void testLineBlurAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-blur");
     assertNotNull(layer);
 
@@ -376,41 +905,178 @@ public class LineLayerTest extends BaseStyleTest {
   }
 
   @Test
-  public void testLineDasharray() {
+  public void testLineBlurAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-blur");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineBlur(
+        zoom(
+          exponential(
+            stop(2, lineBlur(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineBlur());
+    assertNotNull(layer.getLineBlur().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineBlur().getFunction().getClass());
+    assertEquals(ExponentialStops.class, layer.getLineBlur().getFunction().getStops().getClass());
+    assertEquals(0.5f, ((ExponentialStops) layer.getLineBlur().getFunction().getStops()).getBase(), 0.001);
+    assertEquals(1, ((ExponentialStops) layer.getLineBlur().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLineBlurAsIdentitySourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-blur");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineBlur(property("FeaturePropertyA", Stops.<Float>identity()))
+    );
+
+    // Verify
+    assertNotNull(layer.getLineBlur());
+    assertNotNull(layer.getLineBlur().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineBlur().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineBlur().getFunction()).getProperty());
+    assertEquals(IdentityStops.class, layer.getLineBlur().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineBlurAsExponentialSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-blur");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineBlur(
+        property(
+          "FeaturePropertyA",
+          exponential(
+            stop(0.3f, lineBlur(0.3f))
+          ).withBase(0.5f)
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineBlur());
+    assertNotNull(layer.getLineBlur().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineBlur().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineBlur().getFunction()).getProperty());
+    assertEquals(ExponentialStops.class, layer.getLineBlur().getFunction().getStops().getClass());
+  }
+
+  @Test
+  public void testLineBlurAsCategoricalSourceFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-blur");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineBlur(
+        property(
+          "FeaturePropertyA",
+          categorical(
+            stop(1.0f, lineBlur(0.3f))
+          )
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineBlur());
+    assertNotNull(layer.getLineBlur().getFunction());
+    assertEquals(SourceFunction.class, layer.getLineBlur().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((SourceFunction) layer.getLineBlur().getFunction()).getProperty());
+    assertEquals(CategoricalStops.class, layer.getLineBlur().getFunction().getStops().getClass());
+    assertEquals(0.3f, ((SourceFunction) layer.getLineBlur().getFunction()).getDefaultValue());
+  }
+
+  @Test
+  public void testLineBlurAsCompositeFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-blur");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      lineBlur(
+        composite(
+          "FeaturePropertyA",
+          exponential(
+            stop(0, 0.3f, lineBlur(0.9f))
+          ).withBase(0.5f)
+        ).withDefaultValue(0.3f)
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineBlur());
+    assertNotNull(layer.getLineBlur().getFunction());
+    assertEquals(CompositeFunction.class, layer.getLineBlur().getFunction().getClass());
+    assertEquals("FeaturePropertyA", ((CompositeFunction) layer.getLineBlur().getFunction()).getProperty());
+    assertEquals(CompositeStops.class, layer.getLineBlur().getFunction().getStops().getClass());
+    assertEquals(1, ((CompositeStops) layer.getLineBlur().getFunction().getStops()).size());
+
+    CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>> stops =
+      (CompositeStops<Float, Float, Float, ExponentialStops<Float, Float>>) layer.getLineBlur().getFunction().getStops();
+    Map.Entry<Float, ExponentialStops<Float, Float>> stop = stops.iterator().next();
+    assertEquals(ExponentialStops.class, stop.getValue().getClass());
+    assertEquals(0f, stop.getKey(), 0.001);
+    assertEquals(1, stop.getValue().size());
+    assertEquals(0.3f, stop.getValue().iterator().next().in, 0.001f);
+    assertEquals(0.9f, stop.getValue().iterator().next().out, 0.001f);
+  }
+
+  @Test
+  public void testLineDasharrayAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-dasharray");
     assertNotNull(layer);
 
     // Set and Get
-    layer.setProperties(lineDasharray(new Float[] {}));
-    assertEquals((Float[]) layer.getLineDasharray().getValue(), (Float[]) new Float[] {});
+    layer.setProperties(lineDasharray(new Float[]{}));
+    assertEquals((Float[]) layer.getLineDasharray().getValue(), (Float[]) new Float[]{});
   }
 
   @Test
-  public void testLinePattern() {
+  public void testLineDasharrayAsCameraFunction() {
     checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-dasharray");
+    assertNotNull(layer);
 
-    mapboxMap = rule.getActivity().getMapboxMap();
+    // Set
+    layer.setProperties(
+      lineDasharray(
+        zoom(
+          interval(
+            stop(2, lineDasharray(new Float[]{}))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLineDasharray());
+    assertNotNull(layer.getLineDasharray().getFunction());
+    assertEquals(CameraFunction.class, layer.getLineDasharray().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getLineDasharray().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getLineDasharray().getFunction().getStops()).size());
+  }
 
-    if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
-      Timber.i("Adding layer");
-      layer = new LineLayer("my-layer", "composite");
-      layer.setSourceLayer("composite");
-      mapboxMap.addLayer(layer);
-      // Layer reference is now stale, get new reference
-      layer = mapboxMap.getLayerAs("my-layer");
-    }
+  @Test
+  public void testLinePatternAsConstant() {
+    checkViewIsDisplayed(R.id.mapView);
     Timber.i("line-pattern");
     assertNotNull(layer);
 
@@ -419,6 +1085,31 @@ public class LineLayerTest extends BaseStyleTest {
     assertEquals((String) layer.getLinePattern().getValue(), (String) "pedestrian-polygon");
   }
 
+  @Test
+  public void testLinePatternAsCameraFunction() {
+    checkViewIsDisplayed(R.id.mapView);
+    Timber.i("line-pattern");
+    assertNotNull(layer);
+
+    // Set
+    layer.setProperties(
+      linePattern(
+        zoom(
+          interval(
+            stop(2, linePattern("pedestrian-polygon"))
+          )
+        )
+      )
+    );
+
+    // Verify
+    assertNotNull(layer.getLinePattern());
+    assertNotNull(layer.getLinePattern().getFunction());
+    assertEquals(CameraFunction.class, layer.getLinePattern().getFunction().getClass());
+    assertEquals(IntervalStops.class, layer.getLinePattern().getFunction().getStops().getClass());
+    assertEquals(1, ((IntervalStops) layer.getLinePattern().getFunction().getStops()).size());
+  }
+
 
   @After
   public void unregisterIntentServiceIdlingResource() {