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

13 files changed, 466 insertions, 183 deletions

diff --git a/platform/darwin/test/MGLAttributionInfoTests.m b/platform/darwin/test/MGLAttributionInfoTests.m
index ed4927d44b..eccc6ceece 100644
--- a/platform/darwin/test/MGLAttributionInfoTests.m
+++ b/platform/darwin/test/MGLAttributionInfoTests.m
@@ -51,12 +51,12 @@
     XCTAssertEqualObjects([infos[3] feedbackURLAtCenterCoordinate:mapbox zoomLevel:14],
                           [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.sdk.ios#/77.63680/12.98108/14.00/0.0/0"]);
     XCTAssertEqualObjects([infos[3] feedbackURLForStyleURL:styleURL atCenterCoordinate:mapbox zoomLevel:3.14159 direction:90.9 pitch:12.5],
-                          [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.sdk.ios&owner=mapbox&id=satellite-streets-v99&access_token#/77.63680/12.98108/3.14/90.9/13"]);
+                          [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.sdk.ios&owner=mapbox&id=satellite-streets-v99&access_token&map_sdk_version=1.0.0#/77.63680/12.98108/3.14/90.9/13"]);
 #else
     XCTAssertEqualObjects([infos[3] feedbackURLAtCenterCoordinate:mapbox zoomLevel:14],
                           [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.MapboxGL#/77.63680/12.98108/14.00/0.0/0"]);
     XCTAssertEqualObjects([infos[3] feedbackURLForStyleURL:styleURL atCenterCoordinate:mapbox zoomLevel:3.14159 direction:90.9 pitch:12.5],
-                          [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.MapboxGL&owner=mapbox&id=satellite-streets-v99&access_token#/77.63680/12.98108/3.14/90.9/13"]);
+                          [NSURL URLWithString:@"https://www.mapbox.com/feedback/?referrer=com.mapbox.MapboxGL&owner=mapbox&id=satellite-streets-v99&access_token&map_sdk_version=1.0.0#/77.63680/12.98108/3.14/90.9/13"]);
 #endif
 }
 
diff --git a/platform/darwin/test/MGLCircleStyleLayerTests.mm b/platform/darwin/test/MGLCircleStyleLayerTests.mm
index 2a2e9f2d4a..c0c503153a 100644
--- a/platform/darwin/test/MGLCircleStyleLayerTests.mm
+++ b/platform/darwin/test/MGLCircleStyleLayerTests.mm
@@ -246,6 +246,45 @@
         XCTAssertEqual(circleOpacityTransition.duration, transitionTest.duration);
     }
 
+    // circle-pitch-alignment
+    {
+        XCTAssertTrue(rawLayer->getCirclePitchAlignment().isUndefined(),
+                      @"circle-pitch-alignment should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.circlePitchAlignment;
+
+        MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLCirclePitchAlignment:MGLCirclePitchAlignmentViewport]];
+        layer.circlePitchAlignment = constantStyleValue;
+        mbgl::style::PropertyValue<mbgl::style::AlignmentType> propertyValue = { mbgl::style::AlignmentType::Viewport };
+        XCTAssertEqual(rawLayer->getCirclePitchAlignment(), propertyValue,
+                       @"Setting circlePitchAlignment to a constant value should update circle-pitch-alignment.");
+        XCTAssertEqualObjects(layer.circlePitchAlignment, constantStyleValue,
+                              @"circlePitchAlignment should round-trip constant values.");
+
+        MGLStyleValue<NSValue *> * functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
+        layer.circlePitchAlignment = functionStyleValue;
+
+        mbgl::style::IntervalStops<mbgl::style::AlignmentType> intervalStops = { {{18, mbgl::style::AlignmentType::Viewport}} };
+        propertyValue = mbgl::style::CameraFunction<mbgl::style::AlignmentType> { intervalStops };
+        
+        XCTAssertEqual(rawLayer->getCirclePitchAlignment(), propertyValue,
+                       @"Setting circlePitchAlignment to a camera function should update circle-pitch-alignment.");
+        XCTAssertEqualObjects(layer.circlePitchAlignment, functionStyleValue,
+                              @"circlePitchAlignment should round-trip camera functions.");
+
+                              
+
+        layer.circlePitchAlignment = nil;
+        XCTAssertTrue(rawLayer->getCirclePitchAlignment().isUndefined(),
+                      @"Unsetting circlePitchAlignment should return circle-pitch-alignment to the default value.");
+        XCTAssertEqualObjects(layer.circlePitchAlignment, defaultStyleValue,
+                              @"circlePitchAlignment should return the default value after being unset.");
+
+        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
+        XCTAssertThrowsSpecificNamed(layer.circlePitchAlignment = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
+        XCTAssertThrowsSpecificNamed(layer.circlePitchAlignment = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+    }
+
     // circle-radius
     {
         XCTAssertTrue(rawLayer->getCircleRadius().isUndefined(),
@@ -638,6 +677,7 @@
     [self testPropertyName:@"circle-blur" isBoolean:NO];
     [self testPropertyName:@"circle-color" isBoolean:NO];
     [self testPropertyName:@"circle-opacity" isBoolean:NO];
+    [self testPropertyName:@"circle-pitch-alignment" isBoolean:NO];
     [self testPropertyName:@"circle-radius" isBoolean:NO];
     [self testPropertyName:@"circle-scale-alignment" isBoolean:NO];
     [self testPropertyName:@"circle-stroke-color" isBoolean:NO];
@@ -648,6 +688,8 @@
 }
 
 - (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLCirclePitchAlignment:MGLCirclePitchAlignmentMap].MGLCirclePitchAlignmentValue, MGLCirclePitchAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLCirclePitchAlignment:MGLCirclePitchAlignmentViewport].MGLCirclePitchAlignmentValue, MGLCirclePitchAlignmentViewport);
     XCTAssertEqual([NSValue valueWithMGLCircleScaleAlignment:MGLCircleScaleAlignmentMap].MGLCircleScaleAlignmentValue, MGLCircleScaleAlignmentMap);
     XCTAssertEqual([NSValue valueWithMGLCircleScaleAlignment:MGLCircleScaleAlignmentViewport].MGLCircleScaleAlignmentValue, MGLCircleScaleAlignmentViewport);
     XCTAssertEqual([NSValue valueWithMGLCircleTranslationAnchor:MGLCircleTranslationAnchorMap].MGLCircleTranslationAnchorValue, MGLCircleTranslationAnchorMap);
diff --git a/platform/darwin/test/MGLComputedShapeSourceTests.m b/platform/darwin/test/MGLComputedShapeSourceTests.m
new file mode 100644
index 0000000000..6eb45913d6
--- /dev/null
+++ b/platform/darwin/test/MGLComputedShapeSourceTests.m
@@ -0,0 +1,24 @@
+#import <XCTest/XCTest.h>
+
+#import <Mapbox/Mapbox.h>
+
+
+@interface MGLComputedShapeSourceTests : XCTestCase
+@end
+
+@implementation MGLComputedShapeSourceTests
+
+- (void)testInitializer {
+    MGLComputedShapeSource *source = [[MGLComputedShapeSource alloc] initWithIdentifier:@"id" options:@{}];
+    XCTAssertNotNil(source);
+    XCTAssertNotNil(source.requestQueue);
+    XCTAssertNil(source.dataSource);
+}
+
+- (void)testNilOptions {
+    MGLComputedShapeSource *source = [[MGLComputedShapeSource alloc] initWithIdentifier:@"id" options:nil];
+    XCTAssertNotNil(source);
+}
+
+
+@end
diff --git a/platform/darwin/test/MGLDocumentationExampleTests.swift b/platform/darwin/test/MGLDocumentationExampleTests.swift
index ae72b35d82..8762af9ba4 100644
--- a/platform/darwin/test/MGLDocumentationExampleTests.swift
+++ b/platform/darwin/test/MGLDocumentationExampleTests.swift
@@ -103,6 +103,18 @@ class MGLDocumentationExampleTests: XCTestCase, MGLMapViewDelegate {
 
         XCTAssertNotNil(mapView.style?.source(withIdentifier: "pois"))
     }
+    
+    func testMGLPolyline() {
+        //#-example-code
+        let coordinates = [
+            CLLocationCoordinate2D(latitude: 35.68476, longitude: -220.24257),
+            CLLocationCoordinate2D(latitude: 37.78428, longitude: -122.41310)
+        ]
+        let polyline = MGLPolyline(coordinates: coordinates, count: UInt(coordinates.count))
+        //#-end-example-code
+        
+        XCTAssertNotNil(polyline)
+    }
 
     func testMGLImageSource() {
         //#-example-code
@@ -266,6 +278,24 @@ class MGLDocumentationExampleTests: XCTestCase, MGLMapViewDelegate {
         //#-end-example-code
     }
     
+    func testMGLMapSnapshotter() {
+        //#-example-code
+        let camera = MGLMapCamera(lookingAtCenter: CLLocationCoordinate2D(latitude: 37.7184, longitude: -122.4365), fromDistance: 100, pitch: 20, heading: 0)
+
+        let options = MGLMapSnapshotOptions(styleURL: MGLStyle.satelliteStreetsStyleURL(), camera: camera, size: CGSize(width: 320, height: 480))
+        options.zoomLevel = 10
+
+        let snapshotter = MGLMapSnapshotter(options: options)
+        snapshotter.start { (snapshot, error) in
+            if error != nil {
+                // error handler
+            } else {
+                // image handler
+            }
+        }
+        //#-end-example-code
+    }
+    
     // For testMGLMapView().
     func myCustomFunction() {}
 }
diff --git a/platform/darwin/test/MGLLightTest.mm b/platform/darwin/test/MGLLightTest.mm
index 2c3d1c7bd1..de64d57851 100644
--- a/platform/darwin/test/MGLLightTest.mm
+++ b/platform/darwin/test/MGLLightTest.mm
@@ -1,3 +1,5 @@
+// This file is generated.
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make darwin-style-code`.
 #import <XCTest/XCTest.h>
 #import <Mapbox/Mapbox.h>
 
@@ -16,197 +18,112 @@
 @implementation MGLLightTest
 
 - (void)testProperties {
-    
+
     MGLTransition defaultTransition = MGLTransitionMake(0, 0);
     MGLTransition transition = MGLTransitionMake(6, 3);
     mbgl::style::TransitionOptions transitionOptions { { MGLDurationFromTimeInterval(6) }, { MGLDurationFromTimeInterval(3) } };
-    
+
     // anchor
     {
         mbgl::style::Light light;
         MGLLight *mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
-        
-        NSAssert([mglLight.anchor isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.anchor isn’t a MGLConstantStyleValue.");
+        auto lightFromMGLlight = [mglLight mbglLight];
+
+        XCTAssertEqual(light.getDefaultAnchor(), lightFromMGLlight.getAnchor());
+        XCTAssert([mglLight.anchor isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.anchor isn’t a MGLConstantStyleValue.");
         NSValue *anchorValue = ((MGLConstantStyleValue *)mglLight.anchor).rawValue;
         XCTAssertEqual(anchorValue.MGLLightAnchorValue, MGLLightAnchorViewport);
-        XCTAssertEqual(mglLight.anchorTransition.delay, defaultTransition.delay);
-        XCTAssertEqual(mglLight.anchorTransition.duration, defaultTransition.duration);
-        
-        auto lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(light.getDefaultAnchor(), lightFromMGLlight.getAnchor().asConstant());
-        auto anchorTransition = lightFromMGLlight.getAnchorTransition();
-        XCTAssert(anchorTransition.delay && MGLTimeIntervalFromDuration(*anchorTransition.delay) == defaultTransition.delay);
-        XCTAssert(anchorTransition.duration && MGLTimeIntervalFromDuration(*anchorTransition.duration) == defaultTransition.duration);
-        
-        MGLStyleValue<NSValue *> *anchorStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLLightAnchor:MGLLightAnchorMap]];
-        mglLight.anchor = anchorStyleValue;
-        mglLight.anchorTransition = transition;
-        NSAssert([mglLight.anchor isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.anchor isn’t a MGLConstantStyleValue.");
-        anchorValue = ((MGLConstantStyleValue *)mglLight.anchor).rawValue;
-        
-        XCTAssertEqual(anchorValue.MGLLightAnchorValue, MGLLightAnchorMap);
-        XCTAssertEqual(mglLight.anchorTransition.delay, transition.delay);
-        XCTAssertEqual(mglLight.anchorTransition.duration, transition.duration);
-        
-        mbgl::style::PropertyValue<mbgl::style::LightAnchorType> anchorProperty = {  mbgl::style::LightAnchorType::Map  };
-        light.setAnchor(anchorProperty);
-        light.setAnchorTransition(transitionOptions);
-        
+
+        mbgl::style::PropertyValue<mbgl::style::LightAnchorType> propertyValue = { mbgl::style::LightAnchorType::Viewport };
+        light.setAnchor(propertyValue);
+        mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
         lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(light.getAnchor().asConstant(), lightFromMGLlight.getAnchor().asConstant());
-        anchorTransition = lightFromMGLlight.getAnchorTransition();
-        XCTAssert(anchorTransition.delay && MGLTimeIntervalFromDuration(*anchorTransition.delay) == transition.delay);
-        XCTAssert(anchorTransition.duration && MGLTimeIntervalFromDuration(*anchorTransition.duration) == transition.duration);
-        
+
+        XCTAssertEqual(light.getAnchor(), lightFromMGLlight.getAnchor());
     }
-    
+
     // position
     {
         mbgl::style::Light light;
         MGLLight *mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
-        NSAssert([mglLight.position isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.position isn’t a MGLConstantStyleValue.");
-        NSValue *positionValue = ((MGLConstantStyleValue *)mglLight.position).rawValue;
-        auto positionArray = light.getDefaultPosition().getSpherical();
-        MGLSphericalPosition defaultPosition = MGLSphericalPositionMake(positionArray[0], positionArray[1], positionArray[2]);
-        
-        XCTAssert(defaultPosition.radial == positionValue.MGLSphericalPositionValue.radial);
-        XCTAssert(defaultPosition.azimuthal == positionValue.MGLSphericalPositionValue.azimuthal);
-        XCTAssert(defaultPosition.polar == positionValue.MGLSphericalPositionValue.polar);
-        XCTAssertEqual(mglLight.positionTransiton.delay, defaultTransition.delay);
-        XCTAssertEqual(mglLight.positionTransiton.duration, defaultTransition.duration);
-        
         auto lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(positionArray, lightFromMGLlight.getPosition().asConstant().getSpherical());
+
+        XCTAssertEqual(light.getDefaultPosition(), lightFromMGLlight.getPosition());
         auto positionTransition = lightFromMGLlight.getPositionTransition();
         XCTAssert(positionTransition.delay && MGLTimeIntervalFromDuration(*positionTransition.delay) == defaultTransition.delay);
         XCTAssert(positionTransition.duration && MGLTimeIntervalFromDuration(*positionTransition.duration) == defaultTransition.duration);
-        
-        defaultPosition = MGLSphericalPositionMake(6, 180, 90);
-        MGLStyleValue<NSValue *> *positionStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLSphericalPosition:defaultPosition]];
-        mglLight.position = positionStyleValue;
-        mglLight.positionTransiton = transition;
-        
-        NSAssert([mglLight.position isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.position isn’t a MGLConstantStyleValue.");
-        positionValue = ((MGLConstantStyleValue *)mglLight.position).rawValue;
-        
-        XCTAssert(defaultPosition.radial == positionValue.MGLSphericalPositionValue.radial);
-        XCTAssert(defaultPosition.azimuthal == positionValue.MGLSphericalPositionValue.azimuthal);
-        XCTAssert(defaultPosition.polar == positionValue.MGLSphericalPositionValue.polar);
-        XCTAssertEqual(mglLight.positionTransiton.delay, transition.delay);
-        XCTAssertEqual(mglLight.positionTransiton.duration, transition.duration);
-        
-        lightFromMGLlight = [mglLight mbglLight];
-        
-        positionArray = { { 6, 180, 90 } };
+
+        std::array<float, 3> positionArray = { { 6, 180, 90 } };
         mbgl::style::Position position = { positionArray };
-        mbgl::style::PropertyValue<mbgl::style::Position> positionProperty = { position };
-        light.setPosition(positionProperty);
+        mbgl::style::PropertyValue<mbgl::style::Position> propertyValue = { position };
+        light.setPosition(propertyValue);
         light.setPositionTransition(transitionOptions);
 
-        XCTAssertEqual(positionArray, lightFromMGLlight.getPosition().asConstant().getSpherical());
+        mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
+        lightFromMGLlight = [mglLight mbglLight];
+
+        XCTAssertEqual(light.getPosition(), lightFromMGLlight.getPosition());
         positionTransition = lightFromMGLlight.getPositionTransition();
         XCTAssert(positionTransition.delay && MGLTimeIntervalFromDuration(*positionTransition.delay) == transition.delay);
         XCTAssert(positionTransition.duration && MGLTimeIntervalFromDuration(*positionTransition.duration) == transition.duration);
 
     }
-    
+
     // color
     {
         mbgl::style::Light light;
         MGLLight *mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
-        NSAssert([mglLight.color isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.color isn’t a MGLConstantStyleValue.");
-        MGLColor *colorValue = ((MGLConstantStyleValue *)mglLight.color).rawValue;
-        auto color = light.getDefaultColor();
-        const CGFloat *colorComponents = CGColorGetComponents(colorValue.CGColor);
-        
-        XCTAssert(color.r == colorComponents[0] && color.g == colorComponents[1] && color.b == colorComponents[2] &&
-                  color.a == colorComponents[3]);
-        XCTAssertEqual(mglLight.colorTransiton.delay, defaultTransition.delay);
-        XCTAssertEqual(mglLight.colorTransiton.duration, defaultTransition.duration);
-        
         auto lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(color, lightFromMGLlight.getColor().asConstant());
+
+        XCTAssertEqual(light.getDefaultColor(), lightFromMGLlight.getColor());
         auto colorTransition = lightFromMGLlight.getColorTransition();
         XCTAssert(colorTransition.delay && MGLTimeIntervalFromDuration(*colorTransition.delay) == defaultTransition.delay);
         XCTAssert(colorTransition.duration && MGLTimeIntervalFromDuration(*colorTransition.duration) == defaultTransition.duration);
-        
-        MGLStyleValue<MGLColor *> *colorStyleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor blackColor]];
-        mglLight.color = colorStyleValue;
-        mglLight.colorTransiton = transition;
-        
-        NSAssert([mglLight.color isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.color isn’t a MGLConstantStyleValue.");
-        colorValue = ((MGLConstantStyleValue *)mglLight.color).rawValue;
-        
-        XCTAssertEqual([MGLColor blackColor], colorValue);
-        XCTAssertEqual(mglLight.colorTransiton.delay, transition.delay);
-        XCTAssertEqual(mglLight.colorTransiton.duration, transition.duration);
-        
-        mbgl::style::PropertyValue<mbgl::Color> colorProperty = { { 0, 0, 0, 1 } };
-        light.setColor(colorProperty);
+
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { 1, 0, 0, 1 } };
+        light.setColor(propertyValue);
         light.setColorTransition(transitionOptions);
-        
+
+        mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
         lightFromMGLlight = [mglLight mbglLight];
-        
-        colorComponents = CGColorGetComponents(colorValue.CGColor);
-        color = lightFromMGLlight.getColor().asConstant();
-        XCTAssertEqual(light.getColor().asConstant(),lightFromMGLlight.getColor().asConstant());
+
+        XCTAssertEqual(light.getColor(), lightFromMGLlight.getColor());
         colorTransition = lightFromMGLlight.getColorTransition();
         XCTAssert(colorTransition.delay && MGLTimeIntervalFromDuration(*colorTransition.delay) == transition.delay);
         XCTAssert(colorTransition.duration && MGLTimeIntervalFromDuration(*colorTransition.duration) == transition.duration);
+
     }
-    
+
     // intensity
     {
         mbgl::style::Light light;
         MGLLight *mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
-        NSAssert([mglLight.intensity isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.intensity isn’t a MGLConstantStyleValue.");
-        NSNumber *intensityNumber = ((MGLConstantStyleValue *)mglLight.intensity).rawValue;
-        auto intensity = light.getDefaultIntensity();
-        
-        XCTAssert(intensityNumber.floatValue == intensity);
-        XCTAssertEqual(mglLight.intensityTransition.delay, defaultTransition.delay);
-        XCTAssertEqual(mglLight.intensityTransition.duration, defaultTransition.duration);
-        
         auto lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(intensity, lightFromMGLlight.getIntensity().asConstant());
+
+        XCTAssertEqual(light.getDefaultIntensity(), lightFromMGLlight.getIntensity());
         auto intensityTransition = lightFromMGLlight.getIntensityTransition();
         XCTAssert(intensityTransition.delay && MGLTimeIntervalFromDuration(*intensityTransition.delay) == defaultTransition.delay);
         XCTAssert(intensityTransition.duration && MGLTimeIntervalFromDuration(*intensityTransition.duration) == defaultTransition.duration);
-        
-        NSNumber *intensityValue = @0.4;
-        MGLStyleValue<NSNumber *> *intensityStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:intensityValue];
-        mglLight.intensity = intensityStyleValue;
-        mglLight.intensityTransition = transition;
-        
-        NSAssert([mglLight.intensity isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.intensity isn’t a MGLConstantStyleValue.");
-        intensityNumber = ((MGLConstantStyleValue *)mglLight.intensity).rawValue;
-        XCTAssert(intensityNumber.floatValue == intensityValue.floatValue);
-        XCTAssertEqual(mglLight.intensityTransition.delay, transition.delay);
-        XCTAssertEqual(mglLight.intensityTransition.duration, transition.duration);
-
-        mbgl::style::PropertyValue<float> intensityProperty = { 0.4 };
-        light.setIntensity(intensityProperty);
+
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        light.setIntensity(propertyValue);
         light.setIntensityTransition(transitionOptions);
 
+        mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
         lightFromMGLlight = [mglLight mbglLight];
-        
-        XCTAssertEqual(light.getIntensity().asConstant(), lightFromMGLlight.getIntensity().asConstant());
+
+        XCTAssertEqual(light.getIntensity(), lightFromMGLlight.getIntensity());
         intensityTransition = lightFromMGLlight.getIntensityTransition();
         XCTAssert(intensityTransition.delay && MGLTimeIntervalFromDuration(*intensityTransition.delay) == transition.delay);
         XCTAssert(intensityTransition.duration && MGLTimeIntervalFromDuration(*intensityTransition.duration) == transition.duration);
-  
+
     }
 
 }
 
 - (void)testValueAdditions {
     MGLSphericalPosition position = MGLSphericalPositionMake(1.15, 210, 30);
-    
+
     XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.radial, position.radial);
     XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.azimuthal, position.azimuthal);
     XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.polar, position.polar);
diff --git a/platform/darwin/test/MGLLightTest.mm.ejs b/platform/darwin/test/MGLLightTest.mm.ejs
new file mode 100644
index 0000000000..5b1f27d8d1
--- /dev/null
+++ b/platform/darwin/test/MGLLightTest.mm.ejs
@@ -0,0 +1,92 @@
+<%
+  const type = locals.type;
+  const properties = locals.properties;
+-%>
+// This file is generated.
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make darwin-style-code`.
+#import <XCTest/XCTest.h>
+#import <Mapbox/Mapbox.h>
+
+#import "MGLLight_Private.h"
+
+#import "../../darwin/src/NSDate+MGLAdditions.h"
+
+#import <mbgl/style/light.hpp>
+#import <mbgl/style/types.hpp>
+#include <mbgl/style/transition_options.hpp>
+
+@interface MGLLightTest : XCTestCase
+
+@end
+
+@implementation MGLLightTest
+
+- (void)testProperties {
+
+    MGLTransition defaultTransition = MGLTransitionMake(0, 0);
+    MGLTransition transition = MGLTransitionMake(6, 3);
+    mbgl::style::TransitionOptions transitionOptions { { MGLDurationFromTimeInterval(6) }, { MGLDurationFromTimeInterval(3) } };
+
+<% for (const property of properties) { -%>
+    // <%- property.name %>
+    {
+        mbgl::style::Light light;
+        MGLLight *mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
+        auto lightFromMGLlight = [mglLight mbglLight];
+
+        XCTAssertEqual(light.getDefault<%- camelize(property.name) -%>(), lightFromMGLlight.get<%- camelize(property.name) -%>());
+<% if (property.transition) { -%>
+        auto <%- camelizeWithLeadingLowercase(property.name) -%>Transition = lightFromMGLlight.get<%- camelize(property.name) -%>Transition();
+        XCTAssert(<%- camelizeWithLeadingLowercase(property.name) -%>Transition.delay && MGLTimeIntervalFromDuration(*<%- camelizeWithLeadingLowercase(property.name) -%>Transition.delay) == defaultTransition.delay);
+        XCTAssert(<%- camelizeWithLeadingLowercase(property.name) -%>Transition.duration && MGLTimeIntervalFromDuration(*<%- camelizeWithLeadingLowercase(property.name) -%>Transition.duration) == defaultTransition.duration);
+
+<% } -%>
+<% if (property.type == "enum" && property.default) { -%>
+        XCTAssert([mglLight.<%- camelizeWithLeadingLowercase(property.name) -%> isKindOfClass:[MGLConstantStyleValue class]], @"mglLight.<%- camelizeWithLeadingLowercase(property.name) -%> isn’t a MGLConstantStyleValue.");
+        NSValue *<%- camelizeWithLeadingLowercase(property.name) -%>Value = ((MGLConstantStyleValue *)mglLight.<%- camelizeWithLeadingLowercase(property.name) -%>).rawValue;
+        XCTAssertEqual(<%- camelizeWithLeadingLowercase(property.name) -%>Value.MGLLight<%- camelize(property.name) -%>Value, MGLLight<%- camelize(property.name) -%><%- camelize(property.default) -%>);
+
+<% } -%>
+<% if (property.type == "array") { -%>
+        std::array<float, 3> positionArray = { { 6, 180, 90 } };
+        mbgl::style::Position position = { positionArray };
+        mbgl::style::PropertyValue<mbgl::style::Position> propertyValue = { position };
+<% } else { -%>
+        mbgl::style::PropertyValue<<%- mbglType(property) %>> propertyValue = { <%- mbglTestValue(property, type) %> };
+<% } -%>
+        light.set<%- camelize(property.name) -%>(propertyValue);
+<% if (property.transition) { -%>
+        light.set<%- camelize(property.name) -%>Transition(transitionOptions);
+
+<% } -%>
+        mglLight = [[MGLLight alloc] initWithMBGLLight:&light];
+        lightFromMGLlight = [mglLight mbglLight];
+
+        XCTAssertEqual(light.get<%- camelize(property.name) -%>(), lightFromMGLlight.get<%- camelize(property.name) -%>());
+<% if (property.transition) { -%>
+        <%- camelizeWithLeadingLowercase(property.name) -%>Transition = lightFromMGLlight.get<%- camelize(property.name) -%>Transition();
+        XCTAssert(<%- camelizeWithLeadingLowercase(property.name) -%>Transition.delay && MGLTimeIntervalFromDuration(*<%- camelizeWithLeadingLowercase(property.name) -%>Transition.delay) == transition.delay);
+        XCTAssert(<%- camelizeWithLeadingLowercase(property.name) -%>Transition.duration && MGLTimeIntervalFromDuration(*<%- camelizeWithLeadingLowercase(property.name) -%>Transition.duration) == transition.duration);
+
+<% } -%>
+    }
+
+<% } -%>
+}
+
+- (void)testValueAdditions {
+    MGLSphericalPosition position = MGLSphericalPositionMake(1.15, 210, 30);
+
+    XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.radial, position.radial);
+    XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.azimuthal, position.azimuthal);
+    XCTAssertEqual([NSValue valueWithMGLSphericalPosition:position].MGLSphericalPositionValue.polar, position.polar);
+<% for (const property of properties) { -%>
+<% if (property.type == "enum") { -%>
+<% for (const value in property.values) { -%>
+    XCTAssertEqual([NSValue valueWithMGLLight<%- camelize(property.name) %>:MGLLight<%- camelize(property.name) %><%- camelize(value) %>].MGLLight<%- camelize(property.name) %>Value, MGLLight<%- camelize(property.name) %><%- camelize(value) %>);
+<% } -%>
+<% } -%>
+<% } -%>
+}
+
+@end
diff --git a/platform/darwin/test/MGLLineStyleLayerTests.mm b/platform/darwin/test/MGLLineStyleLayerTests.mm
index be7d9a6754..7e7926e22e 100644
--- a/platform/darwin/test/MGLLineStyleLayerTests.mm
+++ b/platform/darwin/test/MGLLineStyleLayerTests.mm
@@ -95,7 +95,7 @@
 
         MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLLineJoin:MGLLineJoinMiter]];
         layer.lineJoin = constantStyleValue;
-        mbgl::style::PropertyValue<mbgl::style::LineJoinType> propertyValue = { mbgl::style::LineJoinType::Miter };
+        mbgl::style::DataDrivenPropertyValue<mbgl::style::LineJoinType> propertyValue = { mbgl::style::LineJoinType::Miter };
         XCTAssertEqual(rawLayer->getLineJoin(), propertyValue,
                        @"Setting lineJoin to a constant value should update line-join.");
         XCTAssertEqualObjects(layer.lineJoin, constantStyleValue,
@@ -119,11 +119,6 @@
                       @"Unsetting lineJoin should return line-join to the default value.");
         XCTAssertEqualObjects(layer.lineJoin, defaultStyleValue,
                               @"lineJoin should return the default value after being unset.");
-
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.lineJoin = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.lineJoin = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
     // line-miter-limit
diff --git a/platform/darwin/test/MGLNSStringAdditionsTests.m b/platform/darwin/test/MGLNSStringAdditionsTests.m
index f07f2c1423..03503b7f8a 100644
--- a/platform/darwin/test/MGLNSStringAdditionsTests.m
+++ b/platform/darwin/test/MGLNSStringAdditionsTests.m
@@ -19,7 +19,7 @@
 
     XCTAssertEqualObjects([@"Improve the map" mgl_titleCasedStringWithLocale:locale], @"Improve the Map");
     XCTAssertEqualObjects([@"Improve The Map" mgl_titleCasedStringWithLocale:locale], @"Improve The Map");
-
+    
     XCTAssertEqualObjects([@"Improve a map" mgl_titleCasedStringWithLocale:locale], @"Improve a Map");
     XCTAssertEqualObjects([@"Improve A Map" mgl_titleCasedStringWithLocale:locale], @"Improve A Map");
 
diff --git a/platform/darwin/test/MGLSDKTestHelpers.swift b/platform/darwin/test/MGLSDKTestHelpers.swift
index 82b5caa273..f21041782e 100644
--- a/platform/darwin/test/MGLSDKTestHelpers.swift
+++ b/platform/darwin/test/MGLSDKTestHelpers.swift
@@ -25,7 +25,8 @@ extension MGLSDKTestHelpers {
         let methodDescriptionList: UnsafeMutablePointer<objc_method_description>! = protocol_copyMethodDescriptionList(p, false, true, &methodCount)
         for i in 0..<Int(methodCount) {
             let description: objc_method_description = methodDescriptionList[i]
-            methods.insert(description.name.description)
+            XCTAssertNotNil(description.name?.description)
+            methods.insert(description.name!.description)
         }
         free(methodDescriptionList)
         return methods
diff --git a/platform/darwin/test/MGLShapeSourceTests.mm b/platform/darwin/test/MGLShapeSourceTests.mm
index 561af7f3d0..60500959b6 100644
--- a/platform/darwin/test/MGLShapeSourceTests.mm
+++ b/platform/darwin/test/MGLShapeSourceTests.mm
@@ -2,6 +2,7 @@
 
 #import <Mapbox/Mapbox.h>
 #import "MGLFeature_Private.h"
+#import "MGLAbstractShapeSource_Private.h"
 #import "MGLShapeSource_Private.h"
 #import "MGLSource_Private.h"
 
diff --git a/platform/darwin/test/MGLStyleTests.mm b/platform/darwin/test/MGLStyleTests.mm
index 608cfdfd2d..8f610e338c 100644
--- a/platform/darwin/test/MGLStyleTests.mm
+++ b/platform/darwin/test/MGLStyleTests.mm
@@ -99,6 +99,8 @@
                           @(mbgl::util::default_styles::satelliteStreets.url));
     XCTAssertEqualObjects([MGLStyle satelliteStreetsStyleURLWithVersion:99].absoluteString,
                           @"mapbox://styles/mapbox/satellite-streets-v99");
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     XCTAssertEqualObjects([MGLStyle trafficDayStyleURLWithVersion:mbgl::util::default_styles::trafficDay.currentVersion].absoluteString,
                           @(mbgl::util::default_styles::trafficDay.url));
     XCTAssertEqualObjects([MGLStyle trafficDayStyleURLWithVersion:99].absoluteString,
@@ -107,6 +109,7 @@
                           @(mbgl::util::default_styles::trafficNight.url));
     XCTAssertEqualObjects([MGLStyle trafficNightStyleURLWithVersion:99].absoluteString,
                           @"mapbox://styles/mapbox/traffic-night-v99");
+#pragma clang diagnostic pop
 
     static_assert(8 == mbgl::util::default_styles::numOrderedStyles,
                   "MGLStyleTests isn’t testing all the styles in mbgl::util::default_styles.");
@@ -140,7 +143,7 @@
     NSString *styleHeader = self.stringWithContentsOfStyleHeader;
 
     NSError *versionedMethodError;
-    NSString *versionedMethodExpressionString = @(R"RE(^\+\s*\(NSURL\s*\*\s*\)\s*\w+StyleURLWithVersion\s*:\s*\(\s*NSInteger\s*\)\s*version\s*;)RE");
+    NSString *versionedMethodExpressionString = @(R"RE(^\+\s*\(NSURL\s*\*\s*\)\s*\w+StyleURLWithVersion\s*:\s*\(\s*NSInteger\s*\)\s*version\s*\b)RE");
     NSRegularExpression *versionedMethodExpression = [NSRegularExpression regularExpressionWithPattern:versionedMethodExpressionString options:NSRegularExpressionAnchorsMatchLines error:&versionedMethodError];
     XCTAssertNil(versionedMethodError, @"Error compiling regular expression to search for versioned methods.");
     NSUInteger numVersionedMethodDeclarations = [versionedMethodExpression numberOfMatchesInString:styleHeader options:0 range:NSMakeRange(0, styleHeader.length)];
diff --git a/platform/darwin/test/MGLStyleValueTests.swift b/platform/darwin/test/MGLStyleValueTests.swift
index 784b2fbaf1..c559037588 100644
--- a/platform/darwin/test/MGLStyleValueTests.swift
+++ b/platform/darwin/test/MGLStyleValueTests.swift
@@ -6,16 +6,34 @@ typealias MGLColor = UIColor
 #elseif os(macOS)
 typealias MGLColor = NSColor
 #endif
+
+#if swift(>=3.2)
+#else
+func XCTAssertEqual<T: FloatingPoint>(_ lhs: @autoclosure () throws -> T, _ rhs: @autoclosure () throws -> T, accuracy: T) {
+    XCTAssertEqualWithAccuracy(lhs, rhs, accuracy: accuracy)
+}
+#endif
     
 extension MGLStyleValueTests {
+    
+    struct Color {
+        var red: CGFloat = 0
+        var green: CGFloat = 0
+        var blue: CGFloat = 0
+        var alpha: CGFloat = 0
+    }
+    
     func assertColorsEqualWithAccuracy(_ actual: MGLColor, _ expected: MGLColor, accuracy: Float = 1/255) {
-        var actualComponents : [CGFloat] = [0, 0, 0, 0]
-        var expectedComponents : [CGFloat] = [0, 0, 0, 0]
-        actual.getRed(&(actualComponents[0]), green: &(actualComponents[1]), blue: &(actualComponents[2]), alpha: &(actualComponents[3]))
-        expected.getRed(&(expectedComponents[0]), green: &(expectedComponents[1]), blue: &(expectedComponents[2]), alpha: &(expectedComponents[3]))
-        for (ac, ec) in zip(actualComponents, expectedComponents) {
-            XCTAssertEqualWithAccuracy(Float(ac), Float(ec), accuracy: accuracy)
-        }
+        var actualColor = Color()
+        var expectedColor = Color()
+        
+        actual.getRed(&actualColor.red, green: &actualColor.green, blue: &actualColor.blue, alpha: &actualColor.alpha)
+        expected.getRed(&expectedColor.red, green: &expectedColor.green, blue: &expectedColor.blue, alpha: &expectedColor.alpha)
+
+        XCTAssertEqual(Float(actualColor.red), Float(expectedColor.red), accuracy: accuracy)
+        XCTAssertEqual(Float(actualColor.green), Float(expectedColor.green), accuracy: accuracy)
+        XCTAssertEqual(Float(actualColor.blue), Float(expectedColor.blue), accuracy: accuracy)
+        XCTAssertEqual(Float(actualColor.alpha), Float(expectedColor.alpha), accuracy: accuracy)
     }
     
     func assertColorValuesEqual(_ actual: MGLStyleValue<MGLColor>, _ expected: MGLStyleValue<MGLColor>) {
@@ -249,22 +267,50 @@ extension MGLStyleValueTests {
             options: [.defaultValue: defaultRadius]
         )
         circleStyleLayer.circleRadius = expectedCompositeCategoricalValue
-        XCTAssertEqual(circleStyleLayer.circleRadius, expectedCompositeCategoricalValue)
+        
+        var compositeValue = circleStyleLayer.circleRadius as! MGLCompositeStyleFunction
+        var expectedCompositeValue = expectedCompositeCategoricalValue as! MGLCompositeStyleFunction
+        XCTAssertEqual(compositeValue.attributeName, expectedCompositeValue.attributeName)
+        XCTAssertEqual(compositeValue.stops as NSDictionary, radiusCompositeCategoricalStops as NSDictionary)
+        XCTAssertEqual(compositeValue.interpolationMode, expectedCompositeValue.interpolationMode)
+        XCTAssertEqual(compositeValue.defaultValue, expectedCompositeValue.defaultValue)
 
         // data-driven, composite function with inner exponential color stop values nested in outer camera stops
         let radiusCompositeExponentialOrIntervalStops: [Float: [Float: MGLStyleValue<NSNumber>]] = [
-            0: [0: smallRadius],
-            10: [200: smallRadius],
-            20: [200: largeRadius]
+            0: [0: MGLStyleValue<NSNumber>(rawValue: 5)],
+            10: [200: MGLStyleValue<NSNumber>(rawValue: 5)],
+            20: [200: MGLStyleValue<NSNumber>(rawValue: 20)]
+        ]
+
+        let expectedStops = [
+            0: [0: MGLStyleValue<NSNumber>(rawValue: 5)],
+            10: [200: MGLStyleValue<NSNumber>(rawValue: 5)],
+            20: [200: MGLStyleValue<NSNumber>(rawValue: 20)]
         ]
+        circleStyleLayer.circleRadius = MGLStyleValue<NSNumber>(
+            interpolationMode: .exponential,
+            compositeStops: [
+                0: [0: MGLStyleValue<NSNumber>(rawValue: 5)],
+                10: [200: MGLStyleValue<NSNumber>(rawValue: 5)],
+                20: [200: MGLStyleValue<NSNumber>(rawValue: 20)]
+            ],
+            attributeName: "temp",
+            options: [.defaultValue: mediumRadius]
+        )
+        
         let expectedCompositeExponentialValue = MGLStyleValue<NSNumber>(
             interpolationMode: .exponential,
             compositeStops: radiusCompositeExponentialOrIntervalStops,
             attributeName: "temp",
             options: [.defaultValue: mediumRadius]
         )
-        circleStyleLayer.circleRadius = expectedCompositeExponentialValue
-        XCTAssertEqual(circleStyleLayer.circleRadius, expectedCompositeExponentialValue)
+
+        compositeValue = circleStyleLayer.circleRadius as! MGLCompositeStyleFunction
+        expectedCompositeValue = expectedCompositeExponentialValue as! MGLCompositeStyleFunction
+        XCTAssertEqual(compositeValue.attributeName, expectedCompositeValue.attributeName)
+        XCTAssertEqual(compositeValue.stops as NSDictionary, expectedStops as NSDictionary)
+        XCTAssertEqual(compositeValue.interpolationMode, expectedCompositeValue.interpolationMode)
+        XCTAssertEqual(compositeValue.defaultValue, expectedCompositeValue.defaultValue)
 
         // get a value back
         if let returnedCircleRadius = circleStyleLayer.circleRadius as? MGLCompositeStyleFunction<NSNumber> {
@@ -287,11 +333,30 @@ extension MGLStyleValueTests {
         // data-driven, composite function with inner interval color stop values nested in outer camera stops
         let expectedCompositeIntervalValue = MGLStyleValue<NSNumber>(
             interpolationMode: .interval,
-            compositeStops: radiusCompositeExponentialOrIntervalStops,
+            compositeStops: [
+                
+                10: [200: MGLStyleValue<NSNumber>(rawValue: 5)],
+                20: [200: MGLStyleValue<NSNumber>(rawValue: 20)]
+            ],
+            attributeName: "temp",
+            options: nil
+        )
+        circleStyleLayer.circleRadius = MGLStyleValue<NSNumber>(
+            interpolationMode: .interval,
+            compositeStops: [
+                0: [0: MGLStyleValue<NSNumber>(rawValue: 5)],
+                10: [200: MGLStyleValue<NSNumber>(rawValue: 5)],
+                20: [200: MGLStyleValue<NSNumber>(rawValue: 20)]
+            ],
             attributeName: "temp",
             options: nil
         )
-        circleStyleLayer.circleRadius = expectedCompositeIntervalValue
-        XCTAssertEqual(circleStyleLayer.circleRadius, expectedCompositeIntervalValue)
+        
+        compositeValue = circleStyleLayer.circleRadius as! MGLCompositeStyleFunction
+        expectedCompositeValue = expectedCompositeIntervalValue as! MGLCompositeStyleFunction
+        XCTAssertEqual(compositeValue.attributeName, expectedCompositeValue.attributeName)
+        XCTAssertEqual(compositeValue.stops as NSDictionary, expectedStops as NSDictionary)
+        XCTAssertEqual(compositeValue.interpolationMode, expectedCompositeValue.interpolationMode)
+        XCTAssertEqual(compositeValue.defaultValue, expectedCompositeValue.defaultValue)
     }
 }
diff --git a/platform/darwin/test/MGLSymbolStyleLayerTests.mm b/platform/darwin/test/MGLSymbolStyleLayerTests.mm
index 367ebf363c..1ac86dd402 100644
--- a/platform/darwin/test/MGLSymbolStyleLayerTests.mm
+++ b/platform/darwin/test/MGLSymbolStyleLayerTests.mm
@@ -87,6 +87,40 @@
         XCTAssertThrowsSpecificNamed(layer.iconAllowsOverlap = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
+    // icon-anchor
+    {
+        XCTAssertTrue(rawLayer->getIconAnchor().isUndefined(),
+                      @"icon-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconAnchor;
+
+        MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomRight]];
+        layer.iconAnchor = constantStyleValue;
+        mbgl::style::DataDrivenPropertyValue<mbgl::style::SymbolAnchorType> propertyValue = { mbgl::style::SymbolAnchorType::BottomRight };
+        XCTAssertEqual(rawLayer->getIconAnchor(), propertyValue,
+                       @"Setting iconAnchor to a constant value should update icon-anchor.");
+        XCTAssertEqualObjects(layer.iconAnchor, constantStyleValue,
+                              @"iconAnchor should round-trip constant values.");
+
+        MGLStyleValue<NSValue *> * functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
+        layer.iconAnchor = functionStyleValue;
+
+        mbgl::style::IntervalStops<mbgl::style::SymbolAnchorType> intervalStops = { {{18, mbgl::style::SymbolAnchorType::BottomRight}} };
+        propertyValue = mbgl::style::CameraFunction<mbgl::style::SymbolAnchorType> { intervalStops };
+        
+        XCTAssertEqual(rawLayer->getIconAnchor(), propertyValue,
+                       @"Setting iconAnchor to a camera function should update icon-anchor.");
+        XCTAssertEqualObjects(layer.iconAnchor, functionStyleValue,
+                              @"iconAnchor should round-trip camera functions.");
+
+                              
+
+        layer.iconAnchor = nil;
+        XCTAssertTrue(rawLayer->getIconAnchor().isUndefined(),
+                      @"Unsetting iconAnchor should return icon-anchor to the default value.");
+        XCTAssertEqualObjects(layer.iconAnchor, defaultStyleValue,
+                              @"iconAnchor should return the default value after being unset.");
+    }
+
     // icon-ignore-placement
     {
         XCTAssertTrue(rawLayer->getIconIgnorePlacement().isUndefined(),
@@ -301,6 +335,45 @@
         XCTAssertThrowsSpecificNamed(layer.iconPadding = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
+    // icon-pitch-alignment
+    {
+        XCTAssertTrue(rawLayer->getIconPitchAlignment().isUndefined(),
+                      @"icon-pitch-alignment should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconPitchAlignment;
+
+        MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentAuto]];
+        layer.iconPitchAlignment = constantStyleValue;
+        mbgl::style::PropertyValue<mbgl::style::AlignmentType> propertyValue = { mbgl::style::AlignmentType::Auto };
+        XCTAssertEqual(rawLayer->getIconPitchAlignment(), propertyValue,
+                       @"Setting iconPitchAlignment to a constant value should update icon-pitch-alignment.");
+        XCTAssertEqualObjects(layer.iconPitchAlignment, constantStyleValue,
+                              @"iconPitchAlignment should round-trip constant values.");
+
+        MGLStyleValue<NSValue *> * functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
+        layer.iconPitchAlignment = functionStyleValue;
+
+        mbgl::style::IntervalStops<mbgl::style::AlignmentType> intervalStops = { {{18, mbgl::style::AlignmentType::Auto}} };
+        propertyValue = mbgl::style::CameraFunction<mbgl::style::AlignmentType> { intervalStops };
+        
+        XCTAssertEqual(rawLayer->getIconPitchAlignment(), propertyValue,
+                       @"Setting iconPitchAlignment to a camera function should update icon-pitch-alignment.");
+        XCTAssertEqualObjects(layer.iconPitchAlignment, functionStyleValue,
+                              @"iconPitchAlignment should round-trip camera functions.");
+
+                              
+
+        layer.iconPitchAlignment = nil;
+        XCTAssertTrue(rawLayer->getIconPitchAlignment().isUndefined(),
+                      @"Unsetting iconPitchAlignment should return icon-pitch-alignment to the default value.");
+        XCTAssertEqualObjects(layer.iconPitchAlignment, defaultStyleValue,
+                              @"iconPitchAlignment should return the default value after being unset.");
+
+        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
+        XCTAssertThrowsSpecificNamed(layer.iconPitchAlignment = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
+        XCTAssertThrowsSpecificNamed(layer.iconPitchAlignment = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+    }
+
     // icon-rotate
     {
         XCTAssertTrue(rawLayer->getIconRotate().isUndefined(),
@@ -663,7 +736,7 @@
 
         MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
         layer.maximumTextWidth = constantStyleValue;
-        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        mbgl::style::DataDrivenPropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getTextMaxWidth(), propertyValue,
                        @"Setting maximumTextWidth to a constant value should update text-max-width.");
         XCTAssertEqualObjects(layer.maximumTextWidth, constantStyleValue,
@@ -680,6 +753,29 @@
         XCTAssertEqualObjects(layer.maximumTextWidth, functionStyleValue,
                               @"maximumTextWidth should round-trip camera functions.");
 
+        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeExponential sourceStops:@{@18: constantStyleValue} attributeName:@"keyName" options:nil];
+        layer.maximumTextWidth = functionStyleValue;
+
+        mbgl::style::ExponentialStops<float> exponentialStops = { {{18, 0xff}}, 1.0 };
+        propertyValue = mbgl::style::SourceFunction<float> { "keyName", exponentialStops };
+
+        XCTAssertEqual(rawLayer->getTextMaxWidth(), propertyValue,
+                       @"Setting maximumTextWidth to a source function should update text-max-width.");
+        XCTAssertEqualObjects(layer.maximumTextWidth, functionStyleValue,
+                              @"maximumTextWidth should round-trip source functions.");
+
+        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeExponential compositeStops:@{@10: @{@18: constantStyleValue}} attributeName:@"keyName" options:nil];
+        layer.maximumTextWidth = functionStyleValue;
+
+        std::map<float, float> innerStops { {18, 0xff} };
+        mbgl::style::CompositeExponentialStops<float> compositeStops { { {10.0, innerStops} }, 1.0 };
+
+        propertyValue = mbgl::style::CompositeFunction<float> { "keyName", compositeStops };
+
+        XCTAssertEqual(rawLayer->getTextMaxWidth(), propertyValue,
+                       @"Setting maximumTextWidth to a composite function should update text-max-width.");
+        XCTAssertEqualObjects(layer.maximumTextWidth, functionStyleValue,
+                              @"maximumTextWidth should round-trip composite functions.");                                                                                                          
                               
 
         layer.maximumTextWidth = nil;
@@ -687,11 +783,6 @@
                       @"Unsetting maximumTextWidth should return text-max-width to the default value.");
         XCTAssertEqualObjects(layer.maximumTextWidth, defaultStyleValue,
                               @"maximumTextWidth should return the default value after being unset.");
-
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.maximumTextWidth = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.maximumTextWidth = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
     // symbol-avoid-edges
@@ -892,7 +983,7 @@
 
         MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextAnchor:MGLTextAnchorBottomRight]];
         layer.textAnchor = constantStyleValue;
-        mbgl::style::PropertyValue<mbgl::style::TextAnchorType> propertyValue = { mbgl::style::TextAnchorType::BottomRight };
+        mbgl::style::DataDrivenPropertyValue<mbgl::style::SymbolAnchorType> propertyValue = { mbgl::style::SymbolAnchorType::BottomRight };
         XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue,
                        @"Setting textAnchor to a constant value should update text-anchor.");
         XCTAssertEqualObjects(layer.textAnchor, constantStyleValue,
@@ -901,8 +992,8 @@
         MGLStyleValue<NSValue *> * functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
         layer.textAnchor = functionStyleValue;
 
-        mbgl::style::IntervalStops<mbgl::style::TextAnchorType> intervalStops = { {{18, mbgl::style::TextAnchorType::BottomRight}} };
-        propertyValue = mbgl::style::CameraFunction<mbgl::style::TextAnchorType> { intervalStops };
+        mbgl::style::IntervalStops<mbgl::style::SymbolAnchorType> intervalStops = { {{18, mbgl::style::SymbolAnchorType::BottomRight}} };
+        propertyValue = mbgl::style::CameraFunction<mbgl::style::SymbolAnchorType> { intervalStops };
         
         XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue,
                        @"Setting textAnchor to a camera function should update text-anchor.");
@@ -916,11 +1007,6 @@
                       @"Unsetting textAnchor should return text-anchor to the default value.");
         XCTAssertEqualObjects(layer.textAnchor, defaultStyleValue,
                               @"textAnchor should return the default value after being unset.");
-
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textAnchor = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textAnchor = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
     // text-font
@@ -1066,7 +1152,7 @@
 
         MGLStyleValue<NSValue *> *constantStyleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextJustification:MGLTextJustificationRight]];
         layer.textJustification = constantStyleValue;
-        mbgl::style::PropertyValue<mbgl::style::TextJustifyType> propertyValue = { mbgl::style::TextJustifyType::Right };
+        mbgl::style::DataDrivenPropertyValue<mbgl::style::TextJustifyType> propertyValue = { mbgl::style::TextJustifyType::Right };
         XCTAssertEqual(rawLayer->getTextJustify(), propertyValue,
                        @"Setting textJustification to a constant value should update text-justify.");
         XCTAssertEqualObjects(layer.textJustification, constantStyleValue,
@@ -1090,11 +1176,6 @@
                       @"Unsetting textJustification should return text-justify to the default value.");
         XCTAssertEqualObjects(layer.textJustification, defaultStyleValue,
                               @"textJustification should return the default value after being unset.");
-
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textJustification = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSValue *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textJustification = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
     // text-letter-spacing
@@ -1105,7 +1186,7 @@
 
         MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
         layer.textLetterSpacing = constantStyleValue;
-        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        mbgl::style::DataDrivenPropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getTextLetterSpacing(), propertyValue,
                        @"Setting textLetterSpacing to a constant value should update text-letter-spacing.");
         XCTAssertEqualObjects(layer.textLetterSpacing, constantStyleValue,
@@ -1122,6 +1203,29 @@
         XCTAssertEqualObjects(layer.textLetterSpacing, functionStyleValue,
                               @"textLetterSpacing should round-trip camera functions.");
 
+        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeExponential sourceStops:@{@18: constantStyleValue} attributeName:@"keyName" options:nil];
+        layer.textLetterSpacing = functionStyleValue;
+
+        mbgl::style::ExponentialStops<float> exponentialStops = { {{18, 0xff}}, 1.0 };
+        propertyValue = mbgl::style::SourceFunction<float> { "keyName", exponentialStops };
+
+        XCTAssertEqual(rawLayer->getTextLetterSpacing(), propertyValue,
+                       @"Setting textLetterSpacing to a source function should update text-letter-spacing.");
+        XCTAssertEqualObjects(layer.textLetterSpacing, functionStyleValue,
+                              @"textLetterSpacing should round-trip source functions.");
+
+        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeExponential compositeStops:@{@10: @{@18: constantStyleValue}} attributeName:@"keyName" options:nil];
+        layer.textLetterSpacing = functionStyleValue;
+
+        std::map<float, float> innerStops { {18, 0xff} };
+        mbgl::style::CompositeExponentialStops<float> compositeStops { { {10.0, innerStops} }, 1.0 };
+
+        propertyValue = mbgl::style::CompositeFunction<float> { "keyName", compositeStops };
+
+        XCTAssertEqual(rawLayer->getTextLetterSpacing(), propertyValue,
+                       @"Setting textLetterSpacing to a composite function should update text-letter-spacing.");
+        XCTAssertEqualObjects(layer.textLetterSpacing, functionStyleValue,
+                              @"textLetterSpacing should round-trip composite functions.");                                                                                                          
                               
 
         layer.textLetterSpacing = nil;
@@ -1129,11 +1233,6 @@
                       @"Unsetting textLetterSpacing should return text-letter-spacing to the default value.");
         XCTAssertEqualObjects(layer.textLetterSpacing, defaultStyleValue,
                               @"textLetterSpacing should return the default value after being unset.");
-
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textLetterSpacing = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.textLetterSpacing = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
     }
 
     // text-line-height
@@ -2316,11 +2415,13 @@
 
 - (void)testPropertyNames {
     [self testPropertyName:@"icon-allows-overlap" isBoolean:YES];
+    [self testPropertyName:@"icon-anchor" isBoolean:NO];
     [self testPropertyName:@"icon-ignores-placement" isBoolean:YES];
     [self testPropertyName:@"icon-image-name" isBoolean:NO];
     [self testPropertyName:@"icon-offset" isBoolean:NO];
     [self testPropertyName:@"is-icon-optional" isBoolean:YES];
     [self testPropertyName:@"icon-padding" isBoolean:NO];
+    [self testPropertyName:@"icon-pitch-alignment" isBoolean:NO];
     [self testPropertyName:@"icon-rotation" isBoolean:NO];
     [self testPropertyName:@"icon-rotation-alignment" isBoolean:NO];
     [self testPropertyName:@"icon-scale" isBoolean:NO];
@@ -2366,6 +2467,18 @@
 }
 
 - (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorCenter].MGLIconAnchorValue, MGLIconAnchorCenter);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorLeft].MGLIconAnchorValue, MGLIconAnchorLeft);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorRight].MGLIconAnchorValue, MGLIconAnchorRight);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTop].MGLIconAnchorValue, MGLIconAnchorTop);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottom].MGLIconAnchorValue, MGLIconAnchorBottom);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTopLeft].MGLIconAnchorValue, MGLIconAnchorTopLeft);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTopRight].MGLIconAnchorValue, MGLIconAnchorTopRight);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomLeft].MGLIconAnchorValue, MGLIconAnchorBottomLeft);
+    XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomRight].MGLIconAnchorValue, MGLIconAnchorBottomRight);
+    XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentMap].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentViewport].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentViewport);
+    XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentAuto].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentAuto);
     XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentMap].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentMap);
     XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentViewport].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentViewport);
     XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentAuto].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentAuto);