[ios, macos] Rewrote style layer tests

Replaced the style layer integration tests with unit tests. Test conversion of style values to property values and vice versa, not just round-tripping. Test the initial state and null-resetting of each null-resettable property. Test NSValue additions for style attribute enumerations. Test properties common to all style layer classes. Test MGLStyle’s source and layer collections.

Eviscerated implementations of unavailable style layer properties corresponding to style specification properties that were renamed. Implemented corresponding getters to prevent ivars from being autosynthesized for these unavailable properties.

Added a missing bridging header to the iOS test project.

29 files changed, 3846 insertions, 1090 deletions

diff --git a/platform/darwin/scripts/generate-style-code.js b/platform/darwin/scripts/generate-style-code.js
index ab3d8e1916..0266e25890 100644
--- a/platform/darwin/scripts/generate-style-code.js
+++ b/platform/darwin/scripts/generate-style-code.js
@@ -69,15 +69,15 @@ global.camelizeWithLeadingLowercase = function (str) {
 
 global.objCName = function (property) {
     return camelizeWithLeadingLowercase(property.name);
-}
+};
 
 global.objCGetter = function (property) {
     return camelizeWithLeadingLowercase(property.getter || property.name);
-}
+};
 
 global.objCType = function (layerType, propertyName) {
     return `${prefix}${camelize(propertyName)}`;
-}
+};
 
 global.arrayType = function (property) {
     return property.type === 'array' ? originalPropertyName(property).split('-').pop() : false;
@@ -86,7 +86,87 @@ global.arrayType = function (property) {
 global.testImplementation = function (property, layerType, isFunction) {
     let helperMsg = testHelperMessage(property, layerType, isFunction);
     return `layer.${objCName(property)} = [MGLRuntimeStylingHelper ${helperMsg}];`;
-}
+};
+
+global.objCTestValue = function (property, layerType, indent) {
+    let propertyName = originalPropertyName(property);
+    switch (property.type) {
+        case 'boolean':
+            return property.default ? '@NO' : '@YES';
+        case 'number':
+            return '@0xff';
+        case 'string':
+            return `@"${_.startCase(propertyName)}"`;
+        case 'enum':
+            let type = objCType(layerType, property.name);
+            let value = `${type}${camelize(_.last(_.keys(property.values)))}`;
+            return `[NSValue valueWith${type}:${value}]`;
+        case 'color':
+            return '[MGLColor redColor]';
+        case 'array':
+            switch (arrayType(property)) {
+                case 'dasharray':
+                    return '@[@1, @2]';
+                case 'font':
+                    return `@[@"${_.startCase(propertyName)}", @"${_.startCase(_.reverse(propertyName.split('')).join(''))}"]`;
+                case 'padding': {
+                    let iosValue = '[NSValue valueWithUIEdgeInsets:UIEdgeInsetsMake(1, 1, 1, 1)]'.indent(indent * 4);
+                    let macosValue = '[NSValue valueWithEdgeInsets:NSEdgeInsetsMake(1, 1, 1, 1)]'.indent(indent * 4);
+                    return `\n#if TARGET_OS_IPHONE\n${iosValue}\n#else\n${macosValue}\n#endif\n${''.indent((indent - 1) * 4)}`;
+                }
+                case 'offset':
+                case 'translate':
+                    let iosValue = '[NSValue valueWithCGVector:CGVectorMake(1, 1)]'.indent(indent * 4);
+                    let macosValue = '[NSValue valueWithMGLVector:CGVectorMake(1, -1)]'.indent(indent * 4);
+                    return `\n#if TARGET_OS_IPHONE\n${iosValue}\n#else\n${macosValue}\n#endif\n${''.indent((indent - 1) * 4)}`;
+                default:
+                    throw new Error(`unknown array type for ${property.name}`);
+            }
+        default:
+            throw new Error(`unknown type for ${property.name}`);
+    }
+};
+
+global.mbglTestValue = function (property, layerType) {
+    let propertyName = originalPropertyName(property);
+    switch (property.type) {
+        case 'boolean':
+            return property.default ? 'false' : 'true';
+        case 'number':
+            return '0xff';
+        case 'string':
+            return `"${_.startCase(propertyName)}"`;
+        case 'enum': {
+            let type = camelize(originalPropertyName(property));
+            if (/-translate-anchor$/.test(originalPropertyName(property))) {
+                type = 'TranslateAnchor';
+            }
+            if (/-(rotation|pitch)-alignment$/.test(originalPropertyName(property))) {
+                type = 'Alignment';
+            }
+            let value = camelize(_.last(_.keys(property.values)));
+            return `mbgl::style::${type}Type::${value}`;
+        }
+        case 'color':
+            return '{ .r = 1, .g = 0, .b = 0, .a = 1 }';
+        case 'array':
+            switch (arrayType(property)) {
+                case 'dasharray':
+                    return '{1, 2}';
+                case 'font':
+                    return `{ "${_.startCase(propertyName)}", "${_.startCase(_.reverse(propertyName.split('')).join(''))}" }`;
+                case 'padding':
+                    return '{ 1, 1, 1, 1 }';
+                case 'offset':
+                case 'translate':
+                    return '{ 1, 1 }';
+                default:
+                    throw new Error(`unknown array type for ${property.name}`);
+            }
+        default:
+            throw new Error(`unknown type for ${property.name}`);
+    }
+};
 
 global.testGetterImplementation = function (property, layerType, isFunction) {
     let helperMsg = testHelperMessage(property, layerType, isFunction);
@@ -99,7 +179,7 @@ global.testGetterImplementation = function (property, layerType, isFunction) {
     XCTAssertEqualObjects(gLayer.${objCName(property)}, ${value});`;
     }
     return `XCTAssertEqualObjects(gLayer.${objCName(property)}, ${value});`;
-}
+};
 
 global.testHelperMessage = function (property, layerType, isFunction) {
     let fnSuffix = isFunction ? 'Function' : '';
@@ -153,7 +233,7 @@ global.propertyDoc = function (propertyName, property, layerType, kind) {
     // Requires symbols to be surrounded by backticks.
     doc = doc.replace(/`(.+?)`/g, function (m, symbol, offset, str) {
         if ('values' in property && Object.keys(property.values).indexOf(symbol) !== -1) {
-            let objCType = objCType(layerType, property.name);
+            let objCType = global.objCType(layerType, property.name);
             return '`' + `${objCType}${camelize(symbol)}` + '`';
         }
         if (str.substr(offset - 4, 3) !== 'CSS') {
@@ -288,7 +368,7 @@ global.propertyDefault = function (property, layerType) {
 
 global.originalPropertyName = function (property) {
     return property.original || property.name;
-}
+};
 
 global.propertyType = function (property) {
     switch (property.type) {
@@ -353,32 +433,60 @@ global.valueTransformerArguments = function (property) {
     }
 };
 
+global.mbglType = function(property) {
+    switch (property.type) {
+        case 'boolean':
+            return 'bool';
+        case 'number':
+            return 'float';
+        case 'string':
+            return 'std::string';
+        case 'enum': {
+            let type = camelize(originalPropertyName(property));
+            if (/-translate-anchor$/.test(originalPropertyName(property))) {
+                type = 'TranslateAnchor';
+            }
+            if (/-(rotation|pitch)-alignment$/.test(originalPropertyName(property))) {
+                type = 'Alignment';
+            }
+            return `mbgl::style::${type}Type`;
+        }
+        case 'color':
+            return 'mbgl::Color';
+        case 'array':
+            switch (arrayType(property)) {
+                case 'dasharray':
+                    return 'std::vector<float>';
+                case 'font':
+                    return 'std::vector<std::string>';
+                case 'padding':
+                    return 'std::array<float, 4>';
+                case 'offset':
+                case 'translate':
+                    return 'std::array<float, 2>';
+                default:
+                    throw new Error(`unknown array type for ${property.name}`);
+            }
+        default:
+            throw new Error(`unknown type for ${property.name}`);
+    }
+};
+
 global.initLayer = function (layerType) {
     if (layerType == "background") {
        return `_layer = new mbgl::style::${camelize(layerType)}Layer(identifier.UTF8String);`
     } else {
         return `_layer = new mbgl::style::${camelize(layerType)}Layer(identifier.UTF8String, source.identifier.UTF8String);`
     }
-}
+};
 
 global.setSourceLayer = function() {
-   return `_layer->setSourceLayer(sourceLayer.UTF8String);`
-}
-
-global.mbglType = function(property) {
-    let mbglType = camelize(originalPropertyName(property)) + 'Type';
-    if (/-translate-anchor$/.test(originalPropertyName(property))) {
-        mbglType = 'TranslateAnchorType';
-    }
-    if (/-(rotation|pitch)-alignment$/.test(originalPropertyName(property))) {
-        mbglType = 'AlignmentType';
-    }
-    return mbglType;
-}
+    return `_layer->setSourceLayer(sourceLayer.UTF8String);`
+};
 
 const layerH = ejs.compile(fs.readFileSync('platform/darwin/src/MGLStyleLayer.h.ejs', 'utf8'), { strict: true });
 const layerM = ejs.compile(fs.readFileSync('platform/darwin/src/MGLStyleLayer.mm.ejs', 'utf8'), { strict: true});
-const testLayers = ejs.compile(fs.readFileSync('platform/darwin/test/MGLStyleLayerTests.m.ejs', 'utf8'), { strict: true});
+const testLayers = ejs.compile(fs.readFileSync('platform/darwin/test/MGLStyleLayerTests.mm.ejs', 'utf8'), { strict: true});
 const guideMD = ejs.compile(fs.readFileSync('platform/darwin/docs/guides/For Style Authors.md.ejs', 'utf8'), { strict: true });
 
 const layers = _(spec.layer.type.values).map((value, layerType) => {
@@ -439,21 +547,21 @@ ${macosComment}${decl}
 var renamedPropertiesByLayerType = {};
 
 for (var layer of layers) {
-    let properties = _.concat(layer.layoutProperties, layer.paintProperties);
-    let enumProperties = _.filter(properties, prop => prop.type === 'enum');
+    layer.properties = _.concat(layer.layoutProperties, layer.paintProperties);
+    let enumProperties = _.filter(layer.properties, prop => prop.type === 'enum');
     if (enumProperties.length) {
         layer.enumProperties = enumProperties;
     }
     
     let renamedProperties = {};
-    _.assign(renamedProperties, _.filter(properties, prop => 'original' in prop || 'getter' in prop));
+    _.assign(renamedProperties, _.filter(layer.properties, prop => 'original' in prop || 'getter' in prop));
     if (!_.isEmpty(renamedProperties)) {
         renamedPropertiesByLayerType[layer.type] = renamedProperties;
     }
 
     fs.writeFileSync(`platform/darwin/src/${prefix}${camelize(layer.type)}${suffix}.h`, duplicatePlatformDecls(layerH(layer)));
     fs.writeFileSync(`platform/darwin/src/${prefix}${camelize(layer.type)}${suffix}.mm`, layerM(layer));
-    fs.writeFileSync(`platform/darwin/test/${prefix}${camelize(layer.type)}${suffix}Tests.m`, testLayers(layer));
+    fs.writeFileSync(`platform/darwin/test/${prefix}${camelize(layer.type)}${suffix}Tests.mm`, testLayers(layer));
 }
 
 fs.writeFileSync(`platform/ios/docs/guides/For Style Authors.md`, guideMD({
diff --git a/platform/darwin/src/MGLCircleStyleLayer.mm b/platform/darwin/src/MGLCircleStyleLayer.mm
index 7ef1e0892a..0aff74ffa6 100644
--- a/platform/darwin/src/MGLCircleStyleLayer.mm
+++ b/platform/darwin/src/MGLCircleStyleLayer.mm
@@ -201,9 +201,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::CirclePitchScaleType, NSValue *, mbgl::style::CirclePitchScaleType, MGLCircleScaleAlignment>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setCirclePitchScale:(MGLStyleValue<NSValue *> *)circlePitchScale {
-    NSAssert(NO, @"Use -setCircleScaleAlignment: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)circlePitchScale {
+    return self.circleScaleAlignment;
 }
 
 - (void)setCircleTranslation:(MGLStyleValue<NSValue *> *)circleTranslation {
@@ -220,9 +222,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setCircleTranslate:(MGLStyleValue<NSValue *> *)circleTranslate {
-    NSAssert(NO, @"Use -setCircleTranslation: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)circleTranslate {
+    return self.circleTranslation;
 }
 
 - (void)setCircleTranslationAnchor:(MGLStyleValue<NSValue *> *)circleTranslationAnchor {
@@ -239,9 +243,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLCircleTranslationAnchor>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setCircleTranslateAnchor:(MGLStyleValue<NSValue *> *)circleTranslateAnchor {
-    NSAssert(NO, @"Use -setCircleTranslationAnchor: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)circleTranslateAnchor {
+    return self.circleTranslationAnchor;
 }
 
 
diff --git a/platform/darwin/src/MGLFillStyleLayer.mm b/platform/darwin/src/MGLFillStyleLayer.mm
index 560a1cab18..ec736d8825 100644
--- a/platform/darwin/src/MGLFillStyleLayer.mm
+++ b/platform/darwin/src/MGLFillStyleLayer.mm
@@ -140,9 +140,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setFillAntialias:(MGLStyleValue<NSNumber *> *)fillAntialias {
-    NSAssert(NO, @"Use -setFillAntialiased: instead.");
+}
+
+- (MGLStyleValue<NSNumber *> *)fillAntialias {
+    return self.isFillAntialiased;
 }
 
 - (void)setFillColor:(MGLStyleValue<MGLColor *> *)fillColor {
@@ -215,9 +217,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setFillTranslate:(MGLStyleValue<NSValue *> *)fillTranslate {
-    NSAssert(NO, @"Use -setFillTranslation: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)fillTranslate {
+    return self.fillTranslation;
 }
 
 - (void)setFillTranslationAnchor:(MGLStyleValue<NSValue *> *)fillTranslationAnchor {
@@ -234,9 +238,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLFillTranslationAnchor>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setFillTranslateAnchor:(MGLStyleValue<NSValue *> *)fillTranslateAnchor {
-    NSAssert(NO, @"Use -setFillTranslationAnchor: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)fillTranslateAnchor {
+    return self.fillTranslationAnchor;
 }
 
 
diff --git a/platform/darwin/src/MGLLineStyleLayer.mm b/platform/darwin/src/MGLLineStyleLayer.mm
index f3b9f22df9..f6884fad15 100644
--- a/platform/darwin/src/MGLLineStyleLayer.mm
+++ b/platform/darwin/src/MGLLineStyleLayer.mm
@@ -238,9 +238,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::vector<float>, NSArray<NSNumber *> *, float>().toStyleValue(propertyValue);
 }
 
-
 - (void)setLineDasharray:(MGLStyleValue<NSArray<NSNumber *> *> *)lineDasharray {
-    NSAssert(NO, @"Use -setLineDashPattern: instead.");
+}
+
+- (MGLStyleValue<NSArray<NSNumber *> *> *)lineDasharray {
+    return self.lineDashPattern;
 }
 
 - (void)setLineGapWidth:(MGLStyleValue<NSNumber *> *)lineGapWidth {
@@ -313,9 +315,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setLineTranslate:(MGLStyleValue<NSValue *> *)lineTranslate {
-    NSAssert(NO, @"Use -setLineTranslation: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)lineTranslate {
+    return self.lineTranslation;
 }
 
 - (void)setLineTranslationAnchor:(MGLStyleValue<NSValue *> *)lineTranslationAnchor {
@@ -332,9 +336,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLLineTranslationAnchor>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setLineTranslateAnchor:(MGLStyleValue<NSValue *> *)lineTranslateAnchor {
-    NSAssert(NO, @"Use -setLineTranslationAnchor: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)lineTranslateAnchor {
+    return self.lineTranslationAnchor;
 }
 
 - (void)setLineWidth:(MGLStyleValue<NSNumber *> *)lineWidth {
diff --git a/platform/darwin/src/MGLRasterStyleLayer.mm b/platform/darwin/src/MGLRasterStyleLayer.mm
index ebe9e5f8f0..22e182df61 100644
--- a/platform/darwin/src/MGLRasterStyleLayer.mm
+++ b/platform/darwin/src/MGLRasterStyleLayer.mm
@@ -103,9 +103,11 @@
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setRasterBrightnessMax:(MGLStyleValue<NSNumber *> *)rasterBrightnessMax {
-    NSAssert(NO, @"Use -setMaximumRasterBrightness: instead.");
+}
+
+- (MGLStyleValue<NSNumber *> *)rasterBrightnessMax {
+    return self.maximumRasterBrightness;
 }
 
 - (void)setMinimumRasterBrightness:(MGLStyleValue<NSNumber *> *)minimumRasterBrightness {
@@ -122,9 +124,11 @@
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setRasterBrightnessMin:(MGLStyleValue<NSNumber *> *)rasterBrightnessMin {
-    NSAssert(NO, @"Use -setMinimumRasterBrightness: instead.");
+}
+
+- (MGLStyleValue<NSNumber *> *)rasterBrightnessMin {
+    return self.minimumRasterBrightness;
 }
 
 - (void)setRasterContrast:(MGLStyleValue<NSNumber *> *)rasterContrast {
@@ -169,9 +173,11 @@
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setRasterHueRotate:(MGLStyleValue<NSNumber *> *)rasterHueRotate {
-    NSAssert(NO, @"Use -setRasterHueRotation: instead.");
+}
+
+- (MGLStyleValue<NSNumber *> *)rasterHueRotate {
+    return self.rasterHueRotation;
 }
 
 - (void)setRasterOpacity:(MGLStyleValue<NSNumber *> *)rasterOpacity {
diff --git a/platform/darwin/src/MGLStyleLayer.mm.ejs b/platform/darwin/src/MGLStyleLayer.mm.ejs
index c3b9e92243..ec8f8599b3 100644
--- a/platform/darwin/src/MGLStyleLayer.mm.ejs
+++ b/platform/darwin/src/MGLStyleLayer.mm.ejs
@@ -175,7 +175,7 @@ namespace mbgl {
     MGLAssertStyleLayerIsValid();
 
 <% if (property.type == "enum") { -%>
-    auto mbglValue = MGLStyleValueTransformer<mbgl::style::<%- mbglType(property) %>, NSValue *, mbgl::style::<%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumPropertyValue(<%- objCName(property) %>);
+    auto mbglValue = MGLStyleValueTransformer<<%- mbglType(property) %>, NSValue *, <%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumPropertyValue(<%- objCName(property) %>);
     self.rawLayer->set<%- camelize(originalPropertyName(property)) %>(mbglValue);
 <% } else { -%>
     auto mbglValue = MGLStyleValueTransformer<<%- valueTransformerArguments(property).join(', ') %>>().toPropertyValue(<%- objCName(property) %>);
@@ -188,15 +188,14 @@ namespace mbgl {
 
     auto propertyValue = self.rawLayer->get<%- camelize(originalPropertyName(property)) %>() ?: self.rawLayer->getDefault<%- camelize(originalPropertyName(property)) %>();
 <% if (property.type == "enum") { -%>
-    return MGLStyleValueTransformer<mbgl::style::<%- mbglType(property) %>, NSValue *, mbgl::style::<%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumStyleValue(propertyValue);
+    return MGLStyleValueTransformer<<%- mbglType(property) %>, NSValue *, <%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumStyleValue(propertyValue);
 <% } else { -%>
     return MGLStyleValueTransformer<<%- valueTransformerArguments(property).join(', ') %>>().toStyleValue(propertyValue);
 <% } -%>
 }
 
-<% if (property.original) { %>
+<% if (property.original) { -%>
 - (void)set<%- camelize(originalPropertyName(property)) %>:(MGLStyleValue<<%- propertyType(property, true) %>> *)<%- camelizeWithLeadingLowercase(originalPropertyName(property)) %> {
-    self.<%- camelizeWithLeadingLowercase(property.name) %> = <%- camelizeWithLeadingLowercase(originalPropertyName(property)) %>;
 }
 
 - (MGLStyleValue<<%- propertyType(property, true) %>> *)<%- camelizeWithLeadingLowercase(originalPropertyName(property)) %> {
@@ -214,7 +213,7 @@ namespace mbgl {
     MGLAssertStyleLayerIsValid();
 
 <% if (property.type == "enum") { -%>
-    auto mbglValue = MGLStyleValueTransformer<mbgl::style::<%- mbglType(property) %>, NSValue *, mbgl::style::<%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumPropertyValue(<%- objCName(property) %>);
+    auto mbglValue = MGLStyleValueTransformer<<%- mbglType(property) %>, NSValue *, <%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumPropertyValue(<%- objCName(property) %>);
     self.rawLayer->set<%- camelize(originalPropertyName(property)) %>(mbglValue);
 <% } else { -%>
     auto mbglValue = MGLStyleValueTransformer<<%- valueTransformerArguments(property).join(', ') %>>().toPropertyValue(<%- objCName(property) %>);
@@ -227,15 +226,18 @@ namespace mbgl {
 
     auto propertyValue = self.rawLayer->get<%- camelize(originalPropertyName(property)) %>() ?: self.rawLayer->getDefault<%- camelize(originalPropertyName(property)) %>();
 <% if (property.type == "enum") { -%>
-    return MGLStyleValueTransformer<mbgl::style::<%- mbglType(property) %>, NSValue *, mbgl::style::<%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumStyleValue(propertyValue);
+    return MGLStyleValueTransformer<<%- mbglType(property) %>, NSValue *, <%- mbglType(property) %>, MGL<%- camelize(property.name) %>>().toEnumStyleValue(propertyValue);
 <% } else { -%>
     return MGLStyleValueTransformer<<%- valueTransformerArguments(property).join(', ') %>>().toStyleValue(propertyValue);
 <% } -%>
 }
 
-<% if (property.original) { %>
+<% if (property.original) { -%>
 - (void)set<%- camelize(originalPropertyName(property)) %>:(MGLStyleValue<<%- propertyType(property, true) %>> *)<%- camelizeWithLeadingLowercase(originalPropertyName(property)) %> {
-    NSAssert(NO, @"Use -set<%- camelize(property.name) %>: instead.");
+}
+
+- (MGLStyleValue<<%- propertyType(property, true) %>> *)<%- camelizeWithLeadingLowercase(originalPropertyName(property)) %> {
+    return self.<%- objCGetter(property) %>;
 }
 
 <% } -%>
diff --git a/platform/darwin/src/MGLSymbolStyleLayer.mm b/platform/darwin/src/MGLSymbolStyleLayer.mm
index c84f218cac..c7ba9d7dc5 100644
--- a/platform/darwin/src/MGLSymbolStyleLayer.mm
+++ b/platform/darwin/src/MGLSymbolStyleLayer.mm
@@ -199,9 +199,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconAllowOverlap:(MGLStyleValue<NSNumber *> *)iconAllowOverlap {
-    self.iconAllowsOverlap = iconAllowOverlap;
 }
 
 - (MGLStyleValue<NSNumber *> *)iconAllowOverlap {
@@ -222,9 +220,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconIgnorePlacement:(MGLStyleValue<NSNumber *> *)iconIgnorePlacement {
-    self.iconIgnoresPlacement = iconIgnorePlacement;
 }
 
 - (MGLStyleValue<NSNumber *> *)iconIgnorePlacement {
@@ -245,9 +241,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::string, NSString *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconImage:(MGLStyleValue<NSString *> *)iconImage {
-    self.iconImageName = iconImage;
 }
 
 - (MGLStyleValue<NSString *> *)iconImage {
@@ -310,9 +304,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconRotate:(MGLStyleValue<NSNumber *> *)iconRotate {
-    self.iconRotation = iconRotate;
 }
 
 - (MGLStyleValue<NSNumber *> *)iconRotate {
@@ -347,9 +339,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconSize:(MGLStyleValue<NSNumber *> *)iconSize {
-    self.iconScale = iconSize;
 }
 
 - (MGLStyleValue<NSNumber *> *)iconSize {
@@ -398,9 +388,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconKeepUpright:(MGLStyleValue<NSNumber *> *)iconKeepUpright {
-    self.keepsIconUpright = iconKeepUpright;
 }
 
 - (MGLStyleValue<NSNumber *> *)iconKeepUpright {
@@ -421,9 +409,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextKeepUpright:(MGLStyleValue<NSNumber *> *)textKeepUpright {
-    self.keepsTextUpright = textKeepUpright;
 }
 
 - (MGLStyleValue<NSNumber *> *)textKeepUpright {
@@ -444,9 +430,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextMaxAngle:(MGLStyleValue<NSNumber *> *)textMaxAngle {
-    self.maximumTextAngle = textMaxAngle;
 }
 
 - (MGLStyleValue<NSNumber *> *)textMaxAngle {
@@ -467,9 +451,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextMaxWidth:(MGLStyleValue<NSNumber *> *)textMaxWidth {
-    self.maximumTextWidth = textMaxWidth;
 }
 
 - (MGLStyleValue<NSNumber *> *)textMaxWidth {
@@ -490,9 +472,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setSymbolAvoidEdges:(MGLStyleValue<NSNumber *> *)symbolAvoidEdges {
-    self.symbolAvoidsEdges = symbolAvoidEdges;
 }
 
 - (MGLStyleValue<NSNumber *> *)symbolAvoidEdges {
@@ -541,9 +521,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::string, NSString *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextField:(MGLStyleValue<NSString *> *)textField {
-    self.text = textField;
 }
 
 - (MGLStyleValue<NSString *> *)textField {
@@ -564,9 +542,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextAllowOverlap:(MGLStyleValue<NSNumber *> *)textAllowOverlap {
-    self.textAllowsOverlap = textAllowOverlap;
 }
 
 - (MGLStyleValue<NSNumber *> *)textAllowOverlap {
@@ -601,9 +577,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::vector<std::string>, NSArray<NSString *> *, std::string>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextFont:(MGLStyleValue<NSArray<NSString *> *> *)textFont {
-    self.textFontNames = textFont;
 }
 
 - (MGLStyleValue<NSArray<NSString *> *> *)textFont {
@@ -624,9 +598,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextSize:(MGLStyleValue<NSNumber *> *)textSize {
-    self.textFontSize = textSize;
 }
 
 - (MGLStyleValue<NSNumber *> *)textSize {
@@ -647,9 +619,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<bool, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextIgnorePlacement:(MGLStyleValue<NSNumber *> *)textIgnorePlacement {
-    self.textIgnoresPlacement = textIgnorePlacement;
 }
 
 - (MGLStyleValue<NSNumber *> *)textIgnorePlacement {
@@ -670,9 +640,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TextJustifyType, NSValue *, mbgl::style::TextJustifyType, MGLTextJustification>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setTextJustify:(MGLStyleValue<NSValue *> *)textJustify {
-    self.textJustification = textJustify;
 }
 
 - (MGLStyleValue<NSValue *> *)textJustify {
@@ -777,9 +745,7 @@ namespace mbgl {
     return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextRotate:(MGLStyleValue<NSNumber *> *)textRotate {
-    self.textRotation = textRotate;
 }
 
 - (MGLStyleValue<NSNumber *> *)textRotate {
@@ -900,9 +866,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setIconTranslate:(MGLStyleValue<NSValue *> *)iconTranslate {
-    NSAssert(NO, @"Use -setIconTranslation: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)iconTranslate {
+    return self.iconTranslation;
 }
 
 - (void)setIconTranslationAnchor:(MGLStyleValue<NSValue *> *)iconTranslationAnchor {
@@ -919,9 +887,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLIconTranslationAnchor>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setIconTranslateAnchor:(MGLStyleValue<NSValue *> *)iconTranslateAnchor {
-    NSAssert(NO, @"Use -setIconTranslationAnchor: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)iconTranslateAnchor {
+    return self.iconTranslationAnchor;
 }
 
 - (void)setTextColor:(MGLStyleValue<MGLColor *> *)textColor {
@@ -1008,9 +978,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue);
 }
 
-
 - (void)setTextTranslate:(MGLStyleValue<NSValue *> *)textTranslate {
-    NSAssert(NO, @"Use -setTextTranslation: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)textTranslate {
+    return self.textTranslation;
 }
 
 - (void)setTextTranslationAnchor:(MGLStyleValue<NSValue *> *)textTranslationAnchor {
@@ -1027,9 +999,11 @@ namespace mbgl {
     return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLTextTranslationAnchor>().toEnumStyleValue(propertyValue);
 }
 
-
 - (void)setTextTranslateAnchor:(MGLStyleValue<NSValue *> *)textTranslateAnchor {
-    NSAssert(NO, @"Use -setTextTranslationAnchor: instead.");
+}
+
+- (MGLStyleValue<NSValue *> *)textTranslateAnchor {
+    return self.textTranslationAnchor;
 }
 
 
diff --git a/platform/darwin/test/MGLBackgroundStyleLayerTests.m b/platform/darwin/test/MGLBackgroundStyleLayerTests.m
deleted file mode 100644
index 934021d6b8..0000000000
--- a/platform/darwin/test/MGLBackgroundStyleLayerTests.m
+++ /dev/null
@@ -1,44 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLBackgroundLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLBackgroundLayerTests
-
-+ (NSString *)layerType {
-    return @"background";
-}
-
-- (void)testBackgroundLayer {
-    MGLBackgroundStyleLayer *layer = [[MGLBackgroundStyleLayer alloc] initWithIdentifier:@"layerID"];
-    [self.mapView.style addLayer:layer];
-
-    layer.backgroundColor = [MGLRuntimeStylingHelper testColor];
-    layer.backgroundOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.backgroundPattern = [MGLRuntimeStylingHelper testString];
-
-    MGLBackgroundStyleLayer *gLayer = (MGLBackgroundStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLBackgroundStyleLayer class]]);
-    XCTAssertEqualObjects(gLayer.backgroundColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.backgroundOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.backgroundPattern, [MGLRuntimeStylingHelper testString]);
-
-    layer.backgroundColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.backgroundOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.backgroundPattern = [MGLRuntimeStylingHelper testStringFunction];
-
-    XCTAssertEqualObjects(gLayer.backgroundColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.backgroundOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.backgroundPattern, [MGLRuntimeStylingHelper testStringFunction]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"background-color" isBoolean:NO];
-    [self testPropertyName:@"background-opacity" isBoolean:NO];
-    [self testPropertyName:@"background-pattern" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLBackgroundStyleLayerTests.mm b/platform/darwin/test/MGLBackgroundStyleLayerTests.mm
new file mode 100644
index 0000000000..ec962ae502
--- /dev/null
+++ b/platform/darwin/test/MGLBackgroundStyleLayerTests.mm
@@ -0,0 +1,134 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/background_layer.hpp>
+
+@interface MGLBackgroundLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLBackgroundLayerTests
+
++ (NSString *)layerType {
+    return @"background";
+}
+
+- (void)testProperties {
+    MGLBackgroundStyleLayer *layer = [[MGLBackgroundStyleLayer alloc] initWithIdentifier:@"layerID"];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::BackgroundLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::BackgroundLayer>();
+    
+    // background-color
+    {
+        XCTAssertTrue(rawLayer->getBackgroundColor().isUndefined(),
+                      @"background-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.backgroundColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.backgroundColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getBackgroundColor(), propertyValue,
+                       @"Setting backgroundColor to a constant value should update background-color.");
+        XCTAssertEqualObjects(layer.backgroundColor, styleValue,
+                              @"backgroundColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.backgroundColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getBackgroundColor(), propertyValue,
+                       @"Setting backgroundColor to a function should update background-color.");
+        XCTAssertEqualObjects(layer.backgroundColor, styleValue,
+                              @"backgroundColor should round-trip functions.");
+        
+        layer.backgroundColor = nil;
+        XCTAssertTrue(rawLayer->getBackgroundColor().isUndefined(),
+                      @"Unsetting backgroundColor should return background-color to the default value.");
+        XCTAssertEqualObjects(layer.backgroundColor, defaultStyleValue,
+                              @"backgroundColor should return the default value after being unset.");
+    }
+    
+    // background-opacity
+    {
+        XCTAssertTrue(rawLayer->getBackgroundOpacity().isUndefined(),
+                      @"background-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.backgroundOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.backgroundOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getBackgroundOpacity(), propertyValue,
+                       @"Setting backgroundOpacity to a constant value should update background-opacity.");
+        XCTAssertEqualObjects(layer.backgroundOpacity, styleValue,
+                              @"backgroundOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.backgroundOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getBackgroundOpacity(), propertyValue,
+                       @"Setting backgroundOpacity to a function should update background-opacity.");
+        XCTAssertEqualObjects(layer.backgroundOpacity, styleValue,
+                              @"backgroundOpacity should round-trip functions.");
+        
+        layer.backgroundOpacity = nil;
+        XCTAssertTrue(rawLayer->getBackgroundOpacity().isUndefined(),
+                      @"Unsetting backgroundOpacity should return background-opacity to the default value.");
+        XCTAssertEqualObjects(layer.backgroundOpacity, defaultStyleValue,
+                              @"backgroundOpacity should return the default value after being unset.");
+    }
+    
+    // background-pattern
+    {
+        XCTAssertTrue(rawLayer->getBackgroundPattern().isUndefined(),
+                      @"background-pattern should be unset initially.");
+        MGLStyleValue<NSString *> *defaultStyleValue = layer.backgroundPattern;
+        
+        MGLStyleValue<NSString *> *styleValue = [MGLStyleValue<NSString *> valueWithRawValue:@"Background Pattern"];
+        layer.backgroundPattern = styleValue;
+        mbgl::style::PropertyValue<std::string> propertyValue = { "Background Pattern" };
+        XCTAssertEqual(rawLayer->getBackgroundPattern(), propertyValue,
+                       @"Setting backgroundPattern to a constant value should update background-pattern.");
+        XCTAssertEqualObjects(layer.backgroundPattern, styleValue,
+                              @"backgroundPattern should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSString *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.backgroundPattern = styleValue;
+        propertyValue = { mbgl::style::Function<std::string> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getBackgroundPattern(), propertyValue,
+                       @"Setting backgroundPattern to a function should update background-pattern.");
+        XCTAssertEqualObjects(layer.backgroundPattern, styleValue,
+                              @"backgroundPattern should round-trip functions.");
+        
+        layer.backgroundPattern = nil;
+        XCTAssertTrue(rawLayer->getBackgroundPattern().isUndefined(),
+                      @"Unsetting backgroundPattern should return background-pattern to the default value.");
+        XCTAssertEqualObjects(layer.backgroundPattern, defaultStyleValue,
+                              @"backgroundPattern should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"background-color" isBoolean:NO];
+    [self testPropertyName:@"background-opacity" isBoolean:NO];
+    [self testPropertyName:@"background-pattern" isBoolean:NO];
+}
+
+@end
diff --git a/platform/darwin/test/MGLCircleStyleLayerTests.m b/platform/darwin/test/MGLCircleStyleLayerTests.m
deleted file mode 100644
index 78898a49cb..0000000000
--- a/platform/darwin/test/MGLCircleStyleLayerTests.m
+++ /dev/null
@@ -1,70 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLCircleLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLCircleLayerTests
-
-+ (NSString *)layerType {
-    return @"circle";
-}
-
-- (void)testCircleLayer {
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGLCircleStyleLayer *layer = [[MGLCircleStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-    [self.mapView.style addLayer:layer];
-
-    layer.circleBlur = [MGLRuntimeStylingHelper testNumber];
-    layer.circleColor = [MGLRuntimeStylingHelper testColor];
-    layer.circleOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.circleRadius = [MGLRuntimeStylingHelper testNumber];
-    layer.circleScaleAlignment = [MGLRuntimeStylingHelper testEnum:MGLCircleScaleAlignmentViewport type:@encode(MGLCircleScaleAlignment)];
-    layer.circleTranslation = [MGLRuntimeStylingHelper testOffset];
-    layer.circleTranslationAnchor = [MGLRuntimeStylingHelper testEnum:MGLCircleTranslationAnchorViewport type:@encode(MGLCircleTranslationAnchor)];
-
-    MGLCircleStyleLayer *gLayer = (MGLCircleStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLCircleStyleLayer class]]);
-    XCTAssertEqualObjects(gLayer.circleBlur, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.circleColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.circleOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.circleRadius, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssert([gLayer.circleScaleAlignment isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.circleScaleAlignment, [MGLRuntimeStylingHelper testEnum:MGLCircleScaleAlignmentViewport type:@encode(MGLCircleScaleAlignment)]);
-    XCTAssertEqualObjects(gLayer.circleTranslation, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssert([gLayer.circleTranslationAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.circleTranslationAnchor, [MGLRuntimeStylingHelper testEnum:MGLCircleTranslationAnchorViewport type:@encode(MGLCircleTranslationAnchor)]);
-
-    layer.circleBlur = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.circleColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.circleOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.circleRadius = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.circleScaleAlignment = [MGLRuntimeStylingHelper testEnumFunction:MGLCircleScaleAlignmentViewport type:@encode(MGLCircleScaleAlignment)];
-    layer.circleTranslation = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.circleTranslationAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLCircleTranslationAnchorViewport type:@encode(MGLCircleTranslationAnchor)];
-
-    XCTAssertEqualObjects(gLayer.circleBlur, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.circleColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.circleOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.circleRadius, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.circleScaleAlignment, [MGLRuntimeStylingHelper testEnumFunction:MGLCircleScaleAlignmentViewport type:@encode(MGLCircleScaleAlignment)]);
-    XCTAssertEqualObjects(gLayer.circleTranslation, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.circleTranslationAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLCircleTranslationAnchorViewport type:@encode(MGLCircleTranslationAnchor)]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"circle-blur" isBoolean:NO];
-    [self testPropertyName:@"circle-color" isBoolean:NO];
-    [self testPropertyName:@"circle-opacity" isBoolean:NO];
-    [self testPropertyName:@"circle-radius" isBoolean:NO];
-    [self testPropertyName:@"circle-scale-alignment" isBoolean:NO];
-    [self testPropertyName:@"circle-translation" isBoolean:NO];
-    [self testPropertyName:@"circle-translation-anchor" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLCircleStyleLayerTests.mm b/platform/darwin/test/MGLCircleStyleLayerTests.mm
new file mode 100644
index 0000000000..1f4b82e32b
--- /dev/null
+++ b/platform/darwin/test/MGLCircleStyleLayerTests.mm
@@ -0,0 +1,308 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/circle_layer.hpp>
+
+@interface MGLCircleLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLCircleLayerTests
+
++ (NSString *)layerType {
+    return @"circle";
+}
+
+- (void)testPredicates {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    MGLCircleStyleLayer *layer = [[MGLCircleStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    layer.sourceLayerIdentifier = @"layerID";
+    XCTAssertEqualObjects(layer.sourceLayerIdentifier, @"layerID");
+    layer.sourceLayerIdentifier = nil;
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    
+    XCTAssertNil(layer.predicate);
+    layer.predicate = [NSPredicate predicateWithValue:NO];
+    XCTAssertEqualObjects(layer.predicate, [NSPredicate predicateWithValue:NO]);
+    layer.predicate = nil;
+    XCTAssertNil(layer.predicate);
+}
+
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGLCircleStyleLayer *layer = [[MGLCircleStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::CircleLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::CircleLayer>();
+    
+    // circle-blur
+    {
+        XCTAssertTrue(rawLayer->getCircleBlur().isUndefined(),
+                      @"circle-blur should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.circleBlur;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.circleBlur = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getCircleBlur(), propertyValue,
+                       @"Setting circleBlur to a constant value should update circle-blur.");
+        XCTAssertEqualObjects(layer.circleBlur, styleValue,
+                              @"circleBlur should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleBlur = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleBlur(), propertyValue,
+                       @"Setting circleBlur to a function should update circle-blur.");
+        XCTAssertEqualObjects(layer.circleBlur, styleValue,
+                              @"circleBlur should round-trip functions.");
+        
+        layer.circleBlur = nil;
+        XCTAssertTrue(rawLayer->getCircleBlur().isUndefined(),
+                      @"Unsetting circleBlur should return circle-blur to the default value.");
+        XCTAssertEqualObjects(layer.circleBlur, defaultStyleValue,
+                              @"circleBlur should return the default value after being unset.");
+    }
+    
+    // circle-color
+    {
+        XCTAssertTrue(rawLayer->getCircleColor().isUndefined(),
+                      @"circle-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.circleColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.circleColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getCircleColor(), propertyValue,
+                       @"Setting circleColor to a constant value should update circle-color.");
+        XCTAssertEqualObjects(layer.circleColor, styleValue,
+                              @"circleColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleColor(), propertyValue,
+                       @"Setting circleColor to a function should update circle-color.");
+        XCTAssertEqualObjects(layer.circleColor, styleValue,
+                              @"circleColor should round-trip functions.");
+        
+        layer.circleColor = nil;
+        XCTAssertTrue(rawLayer->getCircleColor().isUndefined(),
+                      @"Unsetting circleColor should return circle-color to the default value.");
+        XCTAssertEqualObjects(layer.circleColor, defaultStyleValue,
+                              @"circleColor should return the default value after being unset.");
+    }
+    
+    // circle-opacity
+    {
+        XCTAssertTrue(rawLayer->getCircleOpacity().isUndefined(),
+                      @"circle-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.circleOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.circleOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getCircleOpacity(), propertyValue,
+                       @"Setting circleOpacity to a constant value should update circle-opacity.");
+        XCTAssertEqualObjects(layer.circleOpacity, styleValue,
+                              @"circleOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleOpacity(), propertyValue,
+                       @"Setting circleOpacity to a function should update circle-opacity.");
+        XCTAssertEqualObjects(layer.circleOpacity, styleValue,
+                              @"circleOpacity should round-trip functions.");
+        
+        layer.circleOpacity = nil;
+        XCTAssertTrue(rawLayer->getCircleOpacity().isUndefined(),
+                      @"Unsetting circleOpacity should return circle-opacity to the default value.");
+        XCTAssertEqualObjects(layer.circleOpacity, defaultStyleValue,
+                              @"circleOpacity should return the default value after being unset.");
+    }
+    
+    // circle-radius
+    {
+        XCTAssertTrue(rawLayer->getCircleRadius().isUndefined(),
+                      @"circle-radius should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.circleRadius;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.circleRadius = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getCircleRadius(), propertyValue,
+                       @"Setting circleRadius to a constant value should update circle-radius.");
+        XCTAssertEqualObjects(layer.circleRadius, styleValue,
+                              @"circleRadius should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleRadius = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleRadius(), propertyValue,
+                       @"Setting circleRadius to a function should update circle-radius.");
+        XCTAssertEqualObjects(layer.circleRadius, styleValue,
+                              @"circleRadius should round-trip functions.");
+        
+        layer.circleRadius = nil;
+        XCTAssertTrue(rawLayer->getCircleRadius().isUndefined(),
+                      @"Unsetting circleRadius should return circle-radius to the default value.");
+        XCTAssertEqualObjects(layer.circleRadius, defaultStyleValue,
+                              @"circleRadius should return the default value after being unset.");
+    }
+    
+    // circle-pitch-scale
+    {
+        XCTAssertTrue(rawLayer->getCirclePitchScale().isUndefined(),
+                      @"circle-pitch-scale should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.circleScaleAlignment;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLCircleScaleAlignment:MGLCircleScaleAlignmentViewport]];
+        layer.circleScaleAlignment = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::CirclePitchScaleType> propertyValue = { mbgl::style::CirclePitchScaleType::Viewport };
+        XCTAssertEqual(rawLayer->getCirclePitchScale(), propertyValue,
+                       @"Setting circleScaleAlignment to a constant value should update circle-pitch-scale.");
+        XCTAssertEqualObjects(layer.circleScaleAlignment, styleValue,
+                              @"circleScaleAlignment should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleScaleAlignment = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::CirclePitchScaleType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCirclePitchScale(), propertyValue,
+                       @"Setting circleScaleAlignment to a function should update circle-pitch-scale.");
+        XCTAssertEqualObjects(layer.circleScaleAlignment, styleValue,
+                              @"circleScaleAlignment should round-trip functions.");
+        
+        layer.circleScaleAlignment = nil;
+        XCTAssertTrue(rawLayer->getCirclePitchScale().isUndefined(),
+                      @"Unsetting circleScaleAlignment should return circle-pitch-scale to the default value.");
+        XCTAssertEqualObjects(layer.circleScaleAlignment, defaultStyleValue,
+                              @"circleScaleAlignment should return the default value after being unset.");
+    }
+    
+    // circle-translate
+    {
+        XCTAssertTrue(rawLayer->getCircleTranslate().isUndefined(),
+                      @"circle-translate should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.circleTranslation;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.circleTranslation = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getCircleTranslate(), propertyValue,
+                       @"Setting circleTranslation to a constant value should update circle-translate.");
+        XCTAssertEqualObjects(layer.circleTranslation, styleValue,
+                              @"circleTranslation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleTranslation = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleTranslate(), propertyValue,
+                       @"Setting circleTranslation to a function should update circle-translate.");
+        XCTAssertEqualObjects(layer.circleTranslation, styleValue,
+                              @"circleTranslation should round-trip functions.");
+        
+        layer.circleTranslation = nil;
+        XCTAssertTrue(rawLayer->getCircleTranslate().isUndefined(),
+                      @"Unsetting circleTranslation should return circle-translate to the default value.");
+        XCTAssertEqualObjects(layer.circleTranslation, defaultStyleValue,
+                              @"circleTranslation should return the default value after being unset.");
+    }
+    
+    // circle-translate-anchor
+    {
+        XCTAssertTrue(rawLayer->getCircleTranslateAnchor().isUndefined(),
+                      @"circle-translate-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.circleTranslationAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLCircleTranslationAnchor:MGLCircleTranslationAnchorViewport]];
+        layer.circleTranslationAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TranslateAnchorType> propertyValue = { mbgl::style::TranslateAnchorType::Viewport };
+        XCTAssertEqual(rawLayer->getCircleTranslateAnchor(), propertyValue,
+                       @"Setting circleTranslationAnchor to a constant value should update circle-translate-anchor.");
+        XCTAssertEqualObjects(layer.circleTranslationAnchor, styleValue,
+                              @"circleTranslationAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.circleTranslationAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TranslateAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getCircleTranslateAnchor(), propertyValue,
+                       @"Setting circleTranslationAnchor to a function should update circle-translate-anchor.");
+        XCTAssertEqualObjects(layer.circleTranslationAnchor, styleValue,
+                              @"circleTranslationAnchor should round-trip functions.");
+        
+        layer.circleTranslationAnchor = nil;
+        XCTAssertTrue(rawLayer->getCircleTranslateAnchor().isUndefined(),
+                      @"Unsetting circleTranslationAnchor should return circle-translate-anchor to the default value.");
+        XCTAssertEqualObjects(layer.circleTranslationAnchor, defaultStyleValue,
+                              @"circleTranslationAnchor should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"circle-blur" isBoolean:NO];
+    [self testPropertyName:@"circle-color" isBoolean:NO];
+    [self testPropertyName:@"circle-opacity" isBoolean:NO];
+    [self testPropertyName:@"circle-radius" isBoolean:NO];
+    [self testPropertyName:@"circle-scale-alignment" isBoolean:NO];
+    [self testPropertyName:@"circle-translation" isBoolean:NO];
+    [self testPropertyName:@"circle-translation-anchor" isBoolean:NO];
+}
+
+- (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLCircleScaleAlignment:MGLCircleScaleAlignmentMap].MGLCircleScaleAlignmentValue, MGLCircleScaleAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLCircleScaleAlignment:MGLCircleScaleAlignmentViewport].MGLCircleScaleAlignmentValue, MGLCircleScaleAlignmentViewport);
+    XCTAssertEqual([NSValue valueWithMGLCircleTranslationAnchor:MGLCircleTranslationAnchorMap].MGLCircleTranslationAnchorValue, MGLCircleTranslationAnchorMap);
+    XCTAssertEqual([NSValue valueWithMGLCircleTranslationAnchor:MGLCircleTranslationAnchorViewport].MGLCircleTranslationAnchorValue, MGLCircleTranslationAnchorViewport);
+}
+
+@end
diff --git a/platform/darwin/test/MGLFillStyleLayerTests.m b/platform/darwin/test/MGLFillStyleLayerTests.m
deleted file mode 100644
index 549a8cf4a8..0000000000
--- a/platform/darwin/test/MGLFillStyleLayerTests.m
+++ /dev/null
@@ -1,69 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLFillLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLFillLayerTests
-
-+ (NSString *)layerType {
-    return @"fill";
-}
-
-- (void)testFillLayer {
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGLFillStyleLayer *layer = [[MGLFillStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-    [self.mapView.style addLayer:layer];
-
-    layer.fillAntialiased = [MGLRuntimeStylingHelper testBool];
-    layer.fillColor = [MGLRuntimeStylingHelper testColor];
-    layer.fillOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.fillOutlineColor = [MGLRuntimeStylingHelper testColor];
-    layer.fillPattern = [MGLRuntimeStylingHelper testString];
-    layer.fillTranslation = [MGLRuntimeStylingHelper testOffset];
-    layer.fillTranslationAnchor = [MGLRuntimeStylingHelper testEnum:MGLFillTranslationAnchorViewport type:@encode(MGLFillTranslationAnchor)];
-
-    MGLFillStyleLayer *gLayer = (MGLFillStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLFillStyleLayer class]]);
-    XCTAssertEqualObjects(gLayer.fillAntialiased, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.fillColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.fillOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.fillOutlineColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.fillPattern, [MGLRuntimeStylingHelper testString]);
-    XCTAssertEqualObjects(gLayer.fillTranslation, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssert([gLayer.fillTranslationAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.fillTranslationAnchor, [MGLRuntimeStylingHelper testEnum:MGLFillTranslationAnchorViewport type:@encode(MGLFillTranslationAnchor)]);
-
-    layer.fillAntialiased = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.fillColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.fillOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.fillOutlineColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.fillPattern = [MGLRuntimeStylingHelper testStringFunction];
-    layer.fillTranslation = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.fillTranslationAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLFillTranslationAnchorViewport type:@encode(MGLFillTranslationAnchor)];
-
-    XCTAssertEqualObjects(gLayer.fillAntialiased, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.fillColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.fillOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.fillOutlineColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.fillPattern, [MGLRuntimeStylingHelper testStringFunction]);
-    XCTAssertEqualObjects(gLayer.fillTranslation, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.fillTranslationAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLFillTranslationAnchorViewport type:@encode(MGLFillTranslationAnchor)]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"is-fill-antialiased" isBoolean:YES];
-    [self testPropertyName:@"fill-color" isBoolean:NO];
-    [self testPropertyName:@"fill-opacity" isBoolean:NO];
-    [self testPropertyName:@"fill-outline-color" isBoolean:NO];
-    [self testPropertyName:@"fill-pattern" isBoolean:NO];
-    [self testPropertyName:@"fill-translation" isBoolean:NO];
-    [self testPropertyName:@"fill-translation-anchor" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLFillStyleLayerTests.mm b/platform/darwin/test/MGLFillStyleLayerTests.mm
new file mode 100644
index 0000000000..869ad4f9b5
--- /dev/null
+++ b/platform/darwin/test/MGLFillStyleLayerTests.mm
@@ -0,0 +1,306 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/fill_layer.hpp>
+
+@interface MGLFillLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLFillLayerTests
+
++ (NSString *)layerType {
+    return @"fill";
+}
+
+- (void)testPredicates {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    MGLFillStyleLayer *layer = [[MGLFillStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    layer.sourceLayerIdentifier = @"layerID";
+    XCTAssertEqualObjects(layer.sourceLayerIdentifier, @"layerID");
+    layer.sourceLayerIdentifier = nil;
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    
+    XCTAssertNil(layer.predicate);
+    layer.predicate = [NSPredicate predicateWithValue:NO];
+    XCTAssertEqualObjects(layer.predicate, [NSPredicate predicateWithValue:NO]);
+    layer.predicate = nil;
+    XCTAssertNil(layer.predicate);
+}
+
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGLFillStyleLayer *layer = [[MGLFillStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::FillLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::FillLayer>();
+    
+    // fill-antialias
+    {
+        XCTAssertTrue(rawLayer->getFillAntialias().isUndefined(),
+                      @"fill-antialias should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.fillAntialiased;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@NO];
+        layer.fillAntialiased = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { false };
+        XCTAssertEqual(rawLayer->getFillAntialias(), propertyValue,
+                       @"Setting fillAntialiased to a constant value should update fill-antialias.");
+        XCTAssertEqualObjects(layer.fillAntialiased, styleValue,
+                              @"fillAntialiased should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillAntialiased = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillAntialias(), propertyValue,
+                       @"Setting fillAntialiased to a function should update fill-antialias.");
+        XCTAssertEqualObjects(layer.fillAntialiased, styleValue,
+                              @"fillAntialiased should round-trip functions.");
+        
+        layer.fillAntialiased = nil;
+        XCTAssertTrue(rawLayer->getFillAntialias().isUndefined(),
+                      @"Unsetting fillAntialiased should return fill-antialias to the default value.");
+        XCTAssertEqualObjects(layer.fillAntialiased, defaultStyleValue,
+                              @"fillAntialiased should return the default value after being unset.");
+    }
+    
+    // fill-color
+    {
+        XCTAssertTrue(rawLayer->getFillColor().isUndefined(),
+                      @"fill-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.fillColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.fillColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getFillColor(), propertyValue,
+                       @"Setting fillColor to a constant value should update fill-color.");
+        XCTAssertEqualObjects(layer.fillColor, styleValue,
+                              @"fillColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillColor(), propertyValue,
+                       @"Setting fillColor to a function should update fill-color.");
+        XCTAssertEqualObjects(layer.fillColor, styleValue,
+                              @"fillColor should round-trip functions.");
+        
+        layer.fillColor = nil;
+        XCTAssertTrue(rawLayer->getFillColor().isUndefined(),
+                      @"Unsetting fillColor should return fill-color to the default value.");
+        XCTAssertEqualObjects(layer.fillColor, defaultStyleValue,
+                              @"fillColor should return the default value after being unset.");
+    }
+    
+    // fill-opacity
+    {
+        XCTAssertTrue(rawLayer->getFillOpacity().isUndefined(),
+                      @"fill-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.fillOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.fillOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getFillOpacity(), propertyValue,
+                       @"Setting fillOpacity to a constant value should update fill-opacity.");
+        XCTAssertEqualObjects(layer.fillOpacity, styleValue,
+                              @"fillOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillOpacity(), propertyValue,
+                       @"Setting fillOpacity to a function should update fill-opacity.");
+        XCTAssertEqualObjects(layer.fillOpacity, styleValue,
+                              @"fillOpacity should round-trip functions.");
+        
+        layer.fillOpacity = nil;
+        XCTAssertTrue(rawLayer->getFillOpacity().isUndefined(),
+                      @"Unsetting fillOpacity should return fill-opacity to the default value.");
+        XCTAssertEqualObjects(layer.fillOpacity, defaultStyleValue,
+                              @"fillOpacity should return the default value after being unset.");
+    }
+    
+    // fill-outline-color
+    {
+        XCTAssertTrue(rawLayer->getFillOutlineColor().isUndefined(),
+                      @"fill-outline-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.fillOutlineColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.fillOutlineColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getFillOutlineColor(), propertyValue,
+                       @"Setting fillOutlineColor to a constant value should update fill-outline-color.");
+        XCTAssertEqualObjects(layer.fillOutlineColor, styleValue,
+                              @"fillOutlineColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillOutlineColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillOutlineColor(), propertyValue,
+                       @"Setting fillOutlineColor to a function should update fill-outline-color.");
+        XCTAssertEqualObjects(layer.fillOutlineColor, styleValue,
+                              @"fillOutlineColor should round-trip functions.");
+        
+        layer.fillOutlineColor = nil;
+        XCTAssertTrue(rawLayer->getFillOutlineColor().isUndefined(),
+                      @"Unsetting fillOutlineColor should return fill-outline-color to the default value.");
+        XCTAssertEqualObjects(layer.fillOutlineColor, defaultStyleValue,
+                              @"fillOutlineColor should return the default value after being unset.");
+    }
+    
+    // fill-pattern
+    {
+        XCTAssertTrue(rawLayer->getFillPattern().isUndefined(),
+                      @"fill-pattern should be unset initially.");
+        MGLStyleValue<NSString *> *defaultStyleValue = layer.fillPattern;
+        
+        MGLStyleValue<NSString *> *styleValue = [MGLStyleValue<NSString *> valueWithRawValue:@"Fill Pattern"];
+        layer.fillPattern = styleValue;
+        mbgl::style::PropertyValue<std::string> propertyValue = { "Fill Pattern" };
+        XCTAssertEqual(rawLayer->getFillPattern(), propertyValue,
+                       @"Setting fillPattern to a constant value should update fill-pattern.");
+        XCTAssertEqualObjects(layer.fillPattern, styleValue,
+                              @"fillPattern should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSString *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillPattern = styleValue;
+        propertyValue = { mbgl::style::Function<std::string> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillPattern(), propertyValue,
+                       @"Setting fillPattern to a function should update fill-pattern.");
+        XCTAssertEqualObjects(layer.fillPattern, styleValue,
+                              @"fillPattern should round-trip functions.");
+        
+        layer.fillPattern = nil;
+        XCTAssertTrue(rawLayer->getFillPattern().isUndefined(),
+                      @"Unsetting fillPattern should return fill-pattern to the default value.");
+        XCTAssertEqualObjects(layer.fillPattern, defaultStyleValue,
+                              @"fillPattern should return the default value after being unset.");
+    }
+    
+    // fill-translate
+    {
+        XCTAssertTrue(rawLayer->getFillTranslate().isUndefined(),
+                      @"fill-translate should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.fillTranslation;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.fillTranslation = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getFillTranslate(), propertyValue,
+                       @"Setting fillTranslation to a constant value should update fill-translate.");
+        XCTAssertEqualObjects(layer.fillTranslation, styleValue,
+                              @"fillTranslation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillTranslation = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillTranslate(), propertyValue,
+                       @"Setting fillTranslation to a function should update fill-translate.");
+        XCTAssertEqualObjects(layer.fillTranslation, styleValue,
+                              @"fillTranslation should round-trip functions.");
+        
+        layer.fillTranslation = nil;
+        XCTAssertTrue(rawLayer->getFillTranslate().isUndefined(),
+                      @"Unsetting fillTranslation should return fill-translate to the default value.");
+        XCTAssertEqualObjects(layer.fillTranslation, defaultStyleValue,
+                              @"fillTranslation should return the default value after being unset.");
+    }
+    
+    // fill-translate-anchor
+    {
+        XCTAssertTrue(rawLayer->getFillTranslateAnchor().isUndefined(),
+                      @"fill-translate-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.fillTranslationAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLFillTranslationAnchor:MGLFillTranslationAnchorViewport]];
+        layer.fillTranslationAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TranslateAnchorType> propertyValue = { mbgl::style::TranslateAnchorType::Viewport };
+        XCTAssertEqual(rawLayer->getFillTranslateAnchor(), propertyValue,
+                       @"Setting fillTranslationAnchor to a constant value should update fill-translate-anchor.");
+        XCTAssertEqualObjects(layer.fillTranslationAnchor, styleValue,
+                              @"fillTranslationAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.fillTranslationAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TranslateAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getFillTranslateAnchor(), propertyValue,
+                       @"Setting fillTranslationAnchor to a function should update fill-translate-anchor.");
+        XCTAssertEqualObjects(layer.fillTranslationAnchor, styleValue,
+                              @"fillTranslationAnchor should round-trip functions.");
+        
+        layer.fillTranslationAnchor = nil;
+        XCTAssertTrue(rawLayer->getFillTranslateAnchor().isUndefined(),
+                      @"Unsetting fillTranslationAnchor should return fill-translate-anchor to the default value.");
+        XCTAssertEqualObjects(layer.fillTranslationAnchor, defaultStyleValue,
+                              @"fillTranslationAnchor should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"is-fill-antialiased" isBoolean:YES];
+    [self testPropertyName:@"fill-color" isBoolean:NO];
+    [self testPropertyName:@"fill-opacity" isBoolean:NO];
+    [self testPropertyName:@"fill-outline-color" isBoolean:NO];
+    [self testPropertyName:@"fill-pattern" isBoolean:NO];
+    [self testPropertyName:@"fill-translation" isBoolean:NO];
+    [self testPropertyName:@"fill-translation-anchor" isBoolean:NO];
+}
+
+- (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLFillTranslationAnchor:MGLFillTranslationAnchorMap].MGLFillTranslationAnchorValue, MGLFillTranslationAnchorMap);
+    XCTAssertEqual([NSValue valueWithMGLFillTranslationAnchor:MGLFillTranslationAnchorViewport].MGLFillTranslationAnchorValue, MGLFillTranslationAnchorViewport);
+}
+
+@end
diff --git a/platform/darwin/test/MGLLineStyleLayerTests.m b/platform/darwin/test/MGLLineStyleLayerTests.m
deleted file mode 100644
index a9e9c7e6a3..0000000000
--- a/platform/darwin/test/MGLLineStyleLayerTests.m
+++ /dev/null
@@ -1,106 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLLineLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLLineLayerTests
-
-+ (NSString *)layerType {
-    return @"line";
-}
-
-- (void)testLineLayer {
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGLLineStyleLayer *layer = [[MGLLineStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-    [self.mapView.style addLayer:layer];
-
-    layer.lineCap = [MGLRuntimeStylingHelper testEnum:MGLLineCapSquare type:@encode(MGLLineCap)];
-    layer.lineJoin = [MGLRuntimeStylingHelper testEnum:MGLLineJoinMiter type:@encode(MGLLineJoin)];
-    layer.lineMiterLimit = [MGLRuntimeStylingHelper testNumber];
-    layer.lineRoundLimit = [MGLRuntimeStylingHelper testNumber];
-    layer.lineBlur = [MGLRuntimeStylingHelper testNumber];
-    layer.lineColor = [MGLRuntimeStylingHelper testColor];
-    layer.lineDashPattern = [MGLRuntimeStylingHelper testDashArray];
-    layer.lineGapWidth = [MGLRuntimeStylingHelper testNumber];
-    layer.lineOffset = [MGLRuntimeStylingHelper testNumber];
-    layer.lineOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.linePattern = [MGLRuntimeStylingHelper testString];
-    layer.lineTranslation = [MGLRuntimeStylingHelper testOffset];
-    layer.lineTranslationAnchor = [MGLRuntimeStylingHelper testEnum:MGLLineTranslationAnchorViewport type:@encode(MGLLineTranslationAnchor)];
-    layer.lineWidth = [MGLRuntimeStylingHelper testNumber];
-
-    MGLLineStyleLayer *gLayer = (MGLLineStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLLineStyleLayer class]]);
-    XCTAssert([gLayer.lineCap isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.lineCap, [MGLRuntimeStylingHelper testEnum:MGLLineCapSquare type:@encode(MGLLineCap)]);
-    XCTAssert([gLayer.lineJoin isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.lineJoin, [MGLRuntimeStylingHelper testEnum:MGLLineJoinMiter type:@encode(MGLLineJoin)]);
-    XCTAssertEqualObjects(gLayer.lineMiterLimit, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.lineRoundLimit, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.lineBlur, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.lineColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.lineDashPattern, [MGLRuntimeStylingHelper testDashArray]);
-    XCTAssertEqualObjects(gLayer.lineGapWidth, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.lineOffset, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.lineOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.linePattern, [MGLRuntimeStylingHelper testString]);
-    XCTAssertEqualObjects(gLayer.lineTranslation, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssert([gLayer.lineTranslationAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.lineTranslationAnchor, [MGLRuntimeStylingHelper testEnum:MGLLineTranslationAnchorViewport type:@encode(MGLLineTranslationAnchor)]);
-    XCTAssertEqualObjects(gLayer.lineWidth, [MGLRuntimeStylingHelper testNumber]);
-
-    layer.lineCap = [MGLRuntimeStylingHelper testEnumFunction:MGLLineCapSquare type:@encode(MGLLineCap)];
-    layer.lineJoin = [MGLRuntimeStylingHelper testEnumFunction:MGLLineJoinMiter type:@encode(MGLLineJoin)];
-    layer.lineMiterLimit = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.lineRoundLimit = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.lineBlur = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.lineColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.lineDashPattern = [MGLRuntimeStylingHelper testDashArrayFunction];
-    layer.lineGapWidth = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.lineOffset = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.lineOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.linePattern = [MGLRuntimeStylingHelper testStringFunction];
-    layer.lineTranslation = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.lineTranslationAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLLineTranslationAnchorViewport type:@encode(MGLLineTranslationAnchor)];
-    layer.lineWidth = [MGLRuntimeStylingHelper testNumberFunction];
-
-    XCTAssertEqualObjects(gLayer.lineCap, [MGLRuntimeStylingHelper testEnumFunction:MGLLineCapSquare type:@encode(MGLLineCap)]);
-    XCTAssertEqualObjects(gLayer.lineJoin, [MGLRuntimeStylingHelper testEnumFunction:MGLLineJoinMiter type:@encode(MGLLineJoin)]);
-    XCTAssertEqualObjects(gLayer.lineMiterLimit, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.lineRoundLimit, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.lineBlur, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.lineColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.lineDashPattern, [MGLRuntimeStylingHelper testDashArrayFunction]);
-    XCTAssertEqualObjects(gLayer.lineGapWidth, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.lineOffset, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.lineOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.linePattern, [MGLRuntimeStylingHelper testStringFunction]);
-    XCTAssertEqualObjects(gLayer.lineTranslation, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.lineTranslationAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLLineTranslationAnchorViewport type:@encode(MGLLineTranslationAnchor)]);
-    XCTAssertEqualObjects(gLayer.lineWidth, [MGLRuntimeStylingHelper testNumberFunction]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"line-cap" isBoolean:NO];
-    [self testPropertyName:@"line-join" isBoolean:NO];
-    [self testPropertyName:@"line-miter-limit" isBoolean:NO];
-    [self testPropertyName:@"line-round-limit" isBoolean:NO];
-    [self testPropertyName:@"line-blur" isBoolean:NO];
-    [self testPropertyName:@"line-color" isBoolean:NO];
-    [self testPropertyName:@"line-dash-pattern" isBoolean:NO];
-    [self testPropertyName:@"line-gap-width" isBoolean:NO];
-    [self testPropertyName:@"line-offset" isBoolean:NO];
-    [self testPropertyName:@"line-opacity" isBoolean:NO];
-    [self testPropertyName:@"line-pattern" isBoolean:NO];
-    [self testPropertyName:@"line-translation" isBoolean:NO];
-    [self testPropertyName:@"line-translation-anchor" isBoolean:NO];
-    [self testPropertyName:@"line-width" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLLineStyleLayerTests.mm b/platform/darwin/test/MGLLineStyleLayerTests.mm
new file mode 100644
index 0000000000..1abe1cf6c3
--- /dev/null
+++ b/platform/darwin/test/MGLLineStyleLayerTests.mm
@@ -0,0 +1,557 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/line_layer.hpp>
+
+@interface MGLLineLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLLineLayerTests
+
++ (NSString *)layerType {
+    return @"line";
+}
+
+- (void)testPredicates {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    MGLLineStyleLayer *layer = [[MGLLineStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    layer.sourceLayerIdentifier = @"layerID";
+    XCTAssertEqualObjects(layer.sourceLayerIdentifier, @"layerID");
+    layer.sourceLayerIdentifier = nil;
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    
+    XCTAssertNil(layer.predicate);
+    layer.predicate = [NSPredicate predicateWithValue:NO];
+    XCTAssertEqualObjects(layer.predicate, [NSPredicate predicateWithValue:NO]);
+    layer.predicate = nil;
+    XCTAssertNil(layer.predicate);
+}
+
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGLLineStyleLayer *layer = [[MGLLineStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::LineLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::LineLayer>();
+    
+    // line-cap
+    {
+        XCTAssertTrue(rawLayer->getLineCap().isUndefined(),
+                      @"line-cap should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.lineCap;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLLineCap:MGLLineCapSquare]];
+        layer.lineCap = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::LineCapType> propertyValue = { mbgl::style::LineCapType::Square };
+        XCTAssertEqual(rawLayer->getLineCap(), propertyValue,
+                       @"Setting lineCap to a constant value should update line-cap.");
+        XCTAssertEqualObjects(layer.lineCap, styleValue,
+                              @"lineCap should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineCap = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::LineCapType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineCap(), propertyValue,
+                       @"Setting lineCap to a function should update line-cap.");
+        XCTAssertEqualObjects(layer.lineCap, styleValue,
+                              @"lineCap should round-trip functions.");
+        
+        layer.lineCap = nil;
+        XCTAssertTrue(rawLayer->getLineCap().isUndefined(),
+                      @"Unsetting lineCap should return line-cap to the default value.");
+        XCTAssertEqualObjects(layer.lineCap, defaultStyleValue,
+                              @"lineCap should return the default value after being unset.");
+    }
+    
+    // line-join
+    {
+        XCTAssertTrue(rawLayer->getLineJoin().isUndefined(),
+                      @"line-join should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.lineJoin;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLLineJoin:MGLLineJoinMiter]];
+        layer.lineJoin = styleValue;
+        mbgl::style::PropertyValue<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, styleValue,
+                              @"lineJoin should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineJoin = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::LineJoinType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineJoin(), propertyValue,
+                       @"Setting lineJoin to a function should update line-join.");
+        XCTAssertEqualObjects(layer.lineJoin, styleValue,
+                              @"lineJoin should round-trip functions.");
+        
+        layer.lineJoin = nil;
+        XCTAssertTrue(rawLayer->getLineJoin().isUndefined(),
+                      @"Unsetting lineJoin should return line-join to the default value.");
+        XCTAssertEqualObjects(layer.lineJoin, defaultStyleValue,
+                              @"lineJoin should return the default value after being unset.");
+    }
+    
+    // line-miter-limit
+    {
+        XCTAssertTrue(rawLayer->getLineMiterLimit().isUndefined(),
+                      @"line-miter-limit should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineMiterLimit;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineMiterLimit = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineMiterLimit(), propertyValue,
+                       @"Setting lineMiterLimit to a constant value should update line-miter-limit.");
+        XCTAssertEqualObjects(layer.lineMiterLimit, styleValue,
+                              @"lineMiterLimit should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineMiterLimit = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineMiterLimit(), propertyValue,
+                       @"Setting lineMiterLimit to a function should update line-miter-limit.");
+        XCTAssertEqualObjects(layer.lineMiterLimit, styleValue,
+                              @"lineMiterLimit should round-trip functions.");
+        
+        layer.lineMiterLimit = nil;
+        XCTAssertTrue(rawLayer->getLineMiterLimit().isUndefined(),
+                      @"Unsetting lineMiterLimit should return line-miter-limit to the default value.");
+        XCTAssertEqualObjects(layer.lineMiterLimit, defaultStyleValue,
+                              @"lineMiterLimit should return the default value after being unset.");
+    }
+    
+    // line-round-limit
+    {
+        XCTAssertTrue(rawLayer->getLineRoundLimit().isUndefined(),
+                      @"line-round-limit should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineRoundLimit;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineRoundLimit = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineRoundLimit(), propertyValue,
+                       @"Setting lineRoundLimit to a constant value should update line-round-limit.");
+        XCTAssertEqualObjects(layer.lineRoundLimit, styleValue,
+                              @"lineRoundLimit should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineRoundLimit = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineRoundLimit(), propertyValue,
+                       @"Setting lineRoundLimit to a function should update line-round-limit.");
+        XCTAssertEqualObjects(layer.lineRoundLimit, styleValue,
+                              @"lineRoundLimit should round-trip functions.");
+        
+        layer.lineRoundLimit = nil;
+        XCTAssertTrue(rawLayer->getLineRoundLimit().isUndefined(),
+                      @"Unsetting lineRoundLimit should return line-round-limit to the default value.");
+        XCTAssertEqualObjects(layer.lineRoundLimit, defaultStyleValue,
+                              @"lineRoundLimit should return the default value after being unset.");
+    }
+    
+    // line-blur
+    {
+        XCTAssertTrue(rawLayer->getLineBlur().isUndefined(),
+                      @"line-blur should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineBlur;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineBlur = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineBlur(), propertyValue,
+                       @"Setting lineBlur to a constant value should update line-blur.");
+        XCTAssertEqualObjects(layer.lineBlur, styleValue,
+                              @"lineBlur should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineBlur = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineBlur(), propertyValue,
+                       @"Setting lineBlur to a function should update line-blur.");
+        XCTAssertEqualObjects(layer.lineBlur, styleValue,
+                              @"lineBlur should round-trip functions.");
+        
+        layer.lineBlur = nil;
+        XCTAssertTrue(rawLayer->getLineBlur().isUndefined(),
+                      @"Unsetting lineBlur should return line-blur to the default value.");
+        XCTAssertEqualObjects(layer.lineBlur, defaultStyleValue,
+                              @"lineBlur should return the default value after being unset.");
+    }
+    
+    // line-color
+    {
+        XCTAssertTrue(rawLayer->getLineColor().isUndefined(),
+                      @"line-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.lineColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.lineColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getLineColor(), propertyValue,
+                       @"Setting lineColor to a constant value should update line-color.");
+        XCTAssertEqualObjects(layer.lineColor, styleValue,
+                              @"lineColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineColor(), propertyValue,
+                       @"Setting lineColor to a function should update line-color.");
+        XCTAssertEqualObjects(layer.lineColor, styleValue,
+                              @"lineColor should round-trip functions.");
+        
+        layer.lineColor = nil;
+        XCTAssertTrue(rawLayer->getLineColor().isUndefined(),
+                      @"Unsetting lineColor should return line-color to the default value.");
+        XCTAssertEqualObjects(layer.lineColor, defaultStyleValue,
+                              @"lineColor should return the default value after being unset.");
+    }
+    
+    // line-dasharray
+    {
+        XCTAssertTrue(rawLayer->getLineDasharray().isUndefined(),
+                      @"line-dasharray should be unset initially.");
+        MGLStyleValue<NSArray<NSNumber *> *> *defaultStyleValue = layer.lineDashPattern;
+        
+        MGLStyleValue<NSArray<NSNumber *> *> *styleValue = [MGLStyleValue<NSArray<NSNumber *> *> valueWithRawValue:@[@1, @2]];
+        layer.lineDashPattern = styleValue;
+        mbgl::style::PropertyValue<std::vector<float>> propertyValue = { {1, 2} };
+        XCTAssertEqual(rawLayer->getLineDasharray(), propertyValue,
+                       @"Setting lineDashPattern to a constant value should update line-dasharray.");
+        XCTAssertEqualObjects(layer.lineDashPattern, styleValue,
+                              @"lineDashPattern should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSArray<NSNumber *> *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineDashPattern = styleValue;
+        propertyValue = { mbgl::style::Function<std::vector<float>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineDasharray(), propertyValue,
+                       @"Setting lineDashPattern to a function should update line-dasharray.");
+        XCTAssertEqualObjects(layer.lineDashPattern, styleValue,
+                              @"lineDashPattern should round-trip functions.");
+        
+        layer.lineDashPattern = nil;
+        XCTAssertTrue(rawLayer->getLineDasharray().isUndefined(),
+                      @"Unsetting lineDashPattern should return line-dasharray to the default value.");
+        XCTAssertEqualObjects(layer.lineDashPattern, defaultStyleValue,
+                              @"lineDashPattern should return the default value after being unset.");
+    }
+    
+    // line-gap-width
+    {
+        XCTAssertTrue(rawLayer->getLineGapWidth().isUndefined(),
+                      @"line-gap-width should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineGapWidth;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineGapWidth = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineGapWidth(), propertyValue,
+                       @"Setting lineGapWidth to a constant value should update line-gap-width.");
+        XCTAssertEqualObjects(layer.lineGapWidth, styleValue,
+                              @"lineGapWidth should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineGapWidth = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineGapWidth(), propertyValue,
+                       @"Setting lineGapWidth to a function should update line-gap-width.");
+        XCTAssertEqualObjects(layer.lineGapWidth, styleValue,
+                              @"lineGapWidth should round-trip functions.");
+        
+        layer.lineGapWidth = nil;
+        XCTAssertTrue(rawLayer->getLineGapWidth().isUndefined(),
+                      @"Unsetting lineGapWidth should return line-gap-width to the default value.");
+        XCTAssertEqualObjects(layer.lineGapWidth, defaultStyleValue,
+                              @"lineGapWidth should return the default value after being unset.");
+    }
+    
+    // line-offset
+    {
+        XCTAssertTrue(rawLayer->getLineOffset().isUndefined(),
+                      @"line-offset should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineOffset;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineOffset = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineOffset(), propertyValue,
+                       @"Setting lineOffset to a constant value should update line-offset.");
+        XCTAssertEqualObjects(layer.lineOffset, styleValue,
+                              @"lineOffset should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineOffset = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineOffset(), propertyValue,
+                       @"Setting lineOffset to a function should update line-offset.");
+        XCTAssertEqualObjects(layer.lineOffset, styleValue,
+                              @"lineOffset should round-trip functions.");
+        
+        layer.lineOffset = nil;
+        XCTAssertTrue(rawLayer->getLineOffset().isUndefined(),
+                      @"Unsetting lineOffset should return line-offset to the default value.");
+        XCTAssertEqualObjects(layer.lineOffset, defaultStyleValue,
+                              @"lineOffset should return the default value after being unset.");
+    }
+    
+    // line-opacity
+    {
+        XCTAssertTrue(rawLayer->getLineOpacity().isUndefined(),
+                      @"line-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineOpacity(), propertyValue,
+                       @"Setting lineOpacity to a constant value should update line-opacity.");
+        XCTAssertEqualObjects(layer.lineOpacity, styleValue,
+                              @"lineOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineOpacity(), propertyValue,
+                       @"Setting lineOpacity to a function should update line-opacity.");
+        XCTAssertEqualObjects(layer.lineOpacity, styleValue,
+                              @"lineOpacity should round-trip functions.");
+        
+        layer.lineOpacity = nil;
+        XCTAssertTrue(rawLayer->getLineOpacity().isUndefined(),
+                      @"Unsetting lineOpacity should return line-opacity to the default value.");
+        XCTAssertEqualObjects(layer.lineOpacity, defaultStyleValue,
+                              @"lineOpacity should return the default value after being unset.");
+    }
+    
+    // line-pattern
+    {
+        XCTAssertTrue(rawLayer->getLinePattern().isUndefined(),
+                      @"line-pattern should be unset initially.");
+        MGLStyleValue<NSString *> *defaultStyleValue = layer.linePattern;
+        
+        MGLStyleValue<NSString *> *styleValue = [MGLStyleValue<NSString *> valueWithRawValue:@"Line Pattern"];
+        layer.linePattern = styleValue;
+        mbgl::style::PropertyValue<std::string> propertyValue = { "Line Pattern" };
+        XCTAssertEqual(rawLayer->getLinePattern(), propertyValue,
+                       @"Setting linePattern to a constant value should update line-pattern.");
+        XCTAssertEqualObjects(layer.linePattern, styleValue,
+                              @"linePattern should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSString *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.linePattern = styleValue;
+        propertyValue = { mbgl::style::Function<std::string> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLinePattern(), propertyValue,
+                       @"Setting linePattern to a function should update line-pattern.");
+        XCTAssertEqualObjects(layer.linePattern, styleValue,
+                              @"linePattern should round-trip functions.");
+        
+        layer.linePattern = nil;
+        XCTAssertTrue(rawLayer->getLinePattern().isUndefined(),
+                      @"Unsetting linePattern should return line-pattern to the default value.");
+        XCTAssertEqualObjects(layer.linePattern, defaultStyleValue,
+                              @"linePattern should return the default value after being unset.");
+    }
+    
+    // line-translate
+    {
+        XCTAssertTrue(rawLayer->getLineTranslate().isUndefined(),
+                      @"line-translate should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.lineTranslation;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.lineTranslation = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getLineTranslate(), propertyValue,
+                       @"Setting lineTranslation to a constant value should update line-translate.");
+        XCTAssertEqualObjects(layer.lineTranslation, styleValue,
+                              @"lineTranslation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineTranslation = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineTranslate(), propertyValue,
+                       @"Setting lineTranslation to a function should update line-translate.");
+        XCTAssertEqualObjects(layer.lineTranslation, styleValue,
+                              @"lineTranslation should round-trip functions.");
+        
+        layer.lineTranslation = nil;
+        XCTAssertTrue(rawLayer->getLineTranslate().isUndefined(),
+                      @"Unsetting lineTranslation should return line-translate to the default value.");
+        XCTAssertEqualObjects(layer.lineTranslation, defaultStyleValue,
+                              @"lineTranslation should return the default value after being unset.");
+    }
+    
+    // line-translate-anchor
+    {
+        XCTAssertTrue(rawLayer->getLineTranslateAnchor().isUndefined(),
+                      @"line-translate-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.lineTranslationAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLLineTranslationAnchor:MGLLineTranslationAnchorViewport]];
+        layer.lineTranslationAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TranslateAnchorType> propertyValue = { mbgl::style::TranslateAnchorType::Viewport };
+        XCTAssertEqual(rawLayer->getLineTranslateAnchor(), propertyValue,
+                       @"Setting lineTranslationAnchor to a constant value should update line-translate-anchor.");
+        XCTAssertEqualObjects(layer.lineTranslationAnchor, styleValue,
+                              @"lineTranslationAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineTranslationAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TranslateAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineTranslateAnchor(), propertyValue,
+                       @"Setting lineTranslationAnchor to a function should update line-translate-anchor.");
+        XCTAssertEqualObjects(layer.lineTranslationAnchor, styleValue,
+                              @"lineTranslationAnchor should round-trip functions.");
+        
+        layer.lineTranslationAnchor = nil;
+        XCTAssertTrue(rawLayer->getLineTranslateAnchor().isUndefined(),
+                      @"Unsetting lineTranslationAnchor should return line-translate-anchor to the default value.");
+        XCTAssertEqualObjects(layer.lineTranslationAnchor, defaultStyleValue,
+                              @"lineTranslationAnchor should return the default value after being unset.");
+    }
+    
+    // line-width
+    {
+        XCTAssertTrue(rawLayer->getLineWidth().isUndefined(),
+                      @"line-width should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.lineWidth;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.lineWidth = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getLineWidth(), propertyValue,
+                       @"Setting lineWidth to a constant value should update line-width.");
+        XCTAssertEqualObjects(layer.lineWidth, styleValue,
+                              @"lineWidth should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.lineWidth = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getLineWidth(), propertyValue,
+                       @"Setting lineWidth to a function should update line-width.");
+        XCTAssertEqualObjects(layer.lineWidth, styleValue,
+                              @"lineWidth should round-trip functions.");
+        
+        layer.lineWidth = nil;
+        XCTAssertTrue(rawLayer->getLineWidth().isUndefined(),
+                      @"Unsetting lineWidth should return line-width to the default value.");
+        XCTAssertEqualObjects(layer.lineWidth, defaultStyleValue,
+                              @"lineWidth should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"line-cap" isBoolean:NO];
+    [self testPropertyName:@"line-join" isBoolean:NO];
+    [self testPropertyName:@"line-miter-limit" isBoolean:NO];
+    [self testPropertyName:@"line-round-limit" isBoolean:NO];
+    [self testPropertyName:@"line-blur" isBoolean:NO];
+    [self testPropertyName:@"line-color" isBoolean:NO];
+    [self testPropertyName:@"line-dash-pattern" isBoolean:NO];
+    [self testPropertyName:@"line-gap-width" isBoolean:NO];
+    [self testPropertyName:@"line-offset" isBoolean:NO];
+    [self testPropertyName:@"line-opacity" isBoolean:NO];
+    [self testPropertyName:@"line-pattern" isBoolean:NO];
+    [self testPropertyName:@"line-translation" isBoolean:NO];
+    [self testPropertyName:@"line-translation-anchor" isBoolean:NO];
+    [self testPropertyName:@"line-width" isBoolean:NO];
+}
+
+- (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLLineCap:MGLLineCapButt].MGLLineCapValue, MGLLineCapButt);
+    XCTAssertEqual([NSValue valueWithMGLLineCap:MGLLineCapRound].MGLLineCapValue, MGLLineCapRound);
+    XCTAssertEqual([NSValue valueWithMGLLineCap:MGLLineCapSquare].MGLLineCapValue, MGLLineCapSquare);
+    XCTAssertEqual([NSValue valueWithMGLLineJoin:MGLLineJoinBevel].MGLLineJoinValue, MGLLineJoinBevel);
+    XCTAssertEqual([NSValue valueWithMGLLineJoin:MGLLineJoinRound].MGLLineJoinValue, MGLLineJoinRound);
+    XCTAssertEqual([NSValue valueWithMGLLineJoin:MGLLineJoinMiter].MGLLineJoinValue, MGLLineJoinMiter);
+    XCTAssertEqual([NSValue valueWithMGLLineTranslationAnchor:MGLLineTranslationAnchorMap].MGLLineTranslationAnchorValue, MGLLineTranslationAnchorMap);
+    XCTAssertEqual([NSValue valueWithMGLLineTranslationAnchor:MGLLineTranslationAnchorViewport].MGLLineTranslationAnchorValue, MGLLineTranslationAnchorViewport);
+}
+
+@end
diff --git a/platform/darwin/test/MGLRasterStyleLayerTests.m b/platform/darwin/test/MGLRasterStyleLayerTests.m
deleted file mode 100644
index f8de191da0..0000000000
--- a/platform/darwin/test/MGLRasterStyleLayerTests.m
+++ /dev/null
@@ -1,68 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLRasterLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLRasterLayerTests
-
-+ (NSString *)layerType {
-    return @"raster";
-}
-
-- (void)testRasterLayer {
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGLRasterStyleLayer *layer = [[MGLRasterStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-    [self.mapView.style addLayer:layer];
-
-    layer.maximumRasterBrightness = [MGLRuntimeStylingHelper testNumber];
-    layer.minimumRasterBrightness = [MGLRuntimeStylingHelper testNumber];
-    layer.rasterContrast = [MGLRuntimeStylingHelper testNumber];
-    layer.rasterFadeDuration = [MGLRuntimeStylingHelper testNumber];
-    layer.rasterHueRotation = [MGLRuntimeStylingHelper testNumber];
-    layer.rasterOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.rasterSaturation = [MGLRuntimeStylingHelper testNumber];
-
-    MGLRasterStyleLayer *gLayer = (MGLRasterStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLRasterStyleLayer class]]);
-    XCTAssertEqualObjects(gLayer.maximumRasterBrightness, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.minimumRasterBrightness, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.rasterContrast, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.rasterFadeDuration, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.rasterHueRotation, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.rasterOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.rasterSaturation, [MGLRuntimeStylingHelper testNumber]);
-
-    layer.maximumRasterBrightness = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.minimumRasterBrightness = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.rasterContrast = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.rasterFadeDuration = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.rasterHueRotation = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.rasterOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.rasterSaturation = [MGLRuntimeStylingHelper testNumberFunction];
-
-    XCTAssertEqualObjects(gLayer.maximumRasterBrightness, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.minimumRasterBrightness, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.rasterContrast, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.rasterFadeDuration, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.rasterHueRotation, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.rasterOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.rasterSaturation, [MGLRuntimeStylingHelper testNumberFunction]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"maximum-raster-brightness" isBoolean:NO];
-    [self testPropertyName:@"minimum-raster-brightness" isBoolean:NO];
-    [self testPropertyName:@"raster-contrast" isBoolean:NO];
-    [self testPropertyName:@"raster-fade-duration" isBoolean:NO];
-    [self testPropertyName:@"raster-hue-rotation" isBoolean:NO];
-    [self testPropertyName:@"raster-opacity" isBoolean:NO];
-    [self testPropertyName:@"raster-saturation" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLRasterStyleLayerTests.mm b/platform/darwin/test/MGLRasterStyleLayerTests.mm
new file mode 100644
index 0000000000..28a201961c
--- /dev/null
+++ b/platform/darwin/test/MGLRasterStyleLayerTests.mm
@@ -0,0 +1,277 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/raster_layer.hpp>
+
+@interface MGLRasterLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLRasterLayerTests
+
++ (NSString *)layerType {
+    return @"raster";
+}
+
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGLRasterStyleLayer *layer = [[MGLRasterStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::RasterLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::RasterLayer>();
+    
+    // raster-brightness-max
+    {
+        XCTAssertTrue(rawLayer->getRasterBrightnessMax().isUndefined(),
+                      @"raster-brightness-max should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.maximumRasterBrightness;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.maximumRasterBrightness = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterBrightnessMax(), propertyValue,
+                       @"Setting maximumRasterBrightness to a constant value should update raster-brightness-max.");
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, styleValue,
+                              @"maximumRasterBrightness should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.maximumRasterBrightness = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterBrightnessMax(), propertyValue,
+                       @"Setting maximumRasterBrightness to a function should update raster-brightness-max.");
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, styleValue,
+                              @"maximumRasterBrightness should round-trip functions.");
+        
+        layer.maximumRasterBrightness = nil;
+        XCTAssertTrue(rawLayer->getRasterBrightnessMax().isUndefined(),
+                      @"Unsetting maximumRasterBrightness should return raster-brightness-max to the default value.");
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, defaultStyleValue,
+                              @"maximumRasterBrightness should return the default value after being unset.");
+    }
+    
+    // raster-brightness-min
+    {
+        XCTAssertTrue(rawLayer->getRasterBrightnessMin().isUndefined(),
+                      @"raster-brightness-min should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.minimumRasterBrightness;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.minimumRasterBrightness = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterBrightnessMin(), propertyValue,
+                       @"Setting minimumRasterBrightness to a constant value should update raster-brightness-min.");
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, styleValue,
+                              @"minimumRasterBrightness should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.minimumRasterBrightness = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterBrightnessMin(), propertyValue,
+                       @"Setting minimumRasterBrightness to a function should update raster-brightness-min.");
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, styleValue,
+                              @"minimumRasterBrightness should round-trip functions.");
+        
+        layer.minimumRasterBrightness = nil;
+        XCTAssertTrue(rawLayer->getRasterBrightnessMin().isUndefined(),
+                      @"Unsetting minimumRasterBrightness should return raster-brightness-min to the default value.");
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, defaultStyleValue,
+                              @"minimumRasterBrightness should return the default value after being unset.");
+    }
+    
+    // raster-contrast
+    {
+        XCTAssertTrue(rawLayer->getRasterContrast().isUndefined(),
+                      @"raster-contrast should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterContrast;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.rasterContrast = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterContrast(), propertyValue,
+                       @"Setting rasterContrast to a constant value should update raster-contrast.");
+        XCTAssertEqualObjects(layer.rasterContrast, styleValue,
+                              @"rasterContrast should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.rasterContrast = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterContrast(), propertyValue,
+                       @"Setting rasterContrast to a function should update raster-contrast.");
+        XCTAssertEqualObjects(layer.rasterContrast, styleValue,
+                              @"rasterContrast should round-trip functions.");
+        
+        layer.rasterContrast = nil;
+        XCTAssertTrue(rawLayer->getRasterContrast().isUndefined(),
+                      @"Unsetting rasterContrast should return raster-contrast to the default value.");
+        XCTAssertEqualObjects(layer.rasterContrast, defaultStyleValue,
+                              @"rasterContrast should return the default value after being unset.");
+    }
+    
+    // raster-fade-duration
+    {
+        XCTAssertTrue(rawLayer->getRasterFadeDuration().isUndefined(),
+                      @"raster-fade-duration should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterFadeDuration;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.rasterFadeDuration = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterFadeDuration(), propertyValue,
+                       @"Setting rasterFadeDuration to a constant value should update raster-fade-duration.");
+        XCTAssertEqualObjects(layer.rasterFadeDuration, styleValue,
+                              @"rasterFadeDuration should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.rasterFadeDuration = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterFadeDuration(), propertyValue,
+                       @"Setting rasterFadeDuration to a function should update raster-fade-duration.");
+        XCTAssertEqualObjects(layer.rasterFadeDuration, styleValue,
+                              @"rasterFadeDuration should round-trip functions.");
+        
+        layer.rasterFadeDuration = nil;
+        XCTAssertTrue(rawLayer->getRasterFadeDuration().isUndefined(),
+                      @"Unsetting rasterFadeDuration should return raster-fade-duration to the default value.");
+        XCTAssertEqualObjects(layer.rasterFadeDuration, defaultStyleValue,
+                              @"rasterFadeDuration should return the default value after being unset.");
+    }
+    
+    // raster-hue-rotate
+    {
+        XCTAssertTrue(rawLayer->getRasterHueRotate().isUndefined(),
+                      @"raster-hue-rotate should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterHueRotation;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.rasterHueRotation = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterHueRotate(), propertyValue,
+                       @"Setting rasterHueRotation to a constant value should update raster-hue-rotate.");
+        XCTAssertEqualObjects(layer.rasterHueRotation, styleValue,
+                              @"rasterHueRotation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.rasterHueRotation = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterHueRotate(), propertyValue,
+                       @"Setting rasterHueRotation to a function should update raster-hue-rotate.");
+        XCTAssertEqualObjects(layer.rasterHueRotation, styleValue,
+                              @"rasterHueRotation should round-trip functions.");
+        
+        layer.rasterHueRotation = nil;
+        XCTAssertTrue(rawLayer->getRasterHueRotate().isUndefined(),
+                      @"Unsetting rasterHueRotation should return raster-hue-rotate to the default value.");
+        XCTAssertEqualObjects(layer.rasterHueRotation, defaultStyleValue,
+                              @"rasterHueRotation should return the default value after being unset.");
+    }
+    
+    // raster-opacity
+    {
+        XCTAssertTrue(rawLayer->getRasterOpacity().isUndefined(),
+                      @"raster-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.rasterOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterOpacity(), propertyValue,
+                       @"Setting rasterOpacity to a constant value should update raster-opacity.");
+        XCTAssertEqualObjects(layer.rasterOpacity, styleValue,
+                              @"rasterOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.rasterOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterOpacity(), propertyValue,
+                       @"Setting rasterOpacity to a function should update raster-opacity.");
+        XCTAssertEqualObjects(layer.rasterOpacity, styleValue,
+                              @"rasterOpacity should round-trip functions.");
+        
+        layer.rasterOpacity = nil;
+        XCTAssertTrue(rawLayer->getRasterOpacity().isUndefined(),
+                      @"Unsetting rasterOpacity should return raster-opacity to the default value.");
+        XCTAssertEqualObjects(layer.rasterOpacity, defaultStyleValue,
+                              @"rasterOpacity should return the default value after being unset.");
+    }
+    
+    // raster-saturation
+    {
+        XCTAssertTrue(rawLayer->getRasterSaturation().isUndefined(),
+                      @"raster-saturation should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterSaturation;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.rasterSaturation = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getRasterSaturation(), propertyValue,
+                       @"Setting rasterSaturation to a constant value should update raster-saturation.");
+        XCTAssertEqualObjects(layer.rasterSaturation, styleValue,
+                              @"rasterSaturation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.rasterSaturation = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getRasterSaturation(), propertyValue,
+                       @"Setting rasterSaturation to a function should update raster-saturation.");
+        XCTAssertEqualObjects(layer.rasterSaturation, styleValue,
+                              @"rasterSaturation should round-trip functions.");
+        
+        layer.rasterSaturation = nil;
+        XCTAssertTrue(rawLayer->getRasterSaturation().isUndefined(),
+                      @"Unsetting rasterSaturation should return raster-saturation to the default value.");
+        XCTAssertEqualObjects(layer.rasterSaturation, defaultStyleValue,
+                              @"rasterSaturation should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"maximum-raster-brightness" isBoolean:NO];
+    [self testPropertyName:@"minimum-raster-brightness" isBoolean:NO];
+    [self testPropertyName:@"raster-contrast" isBoolean:NO];
+    [self testPropertyName:@"raster-fade-duration" isBoolean:NO];
+    [self testPropertyName:@"raster-hue-rotation" isBoolean:NO];
+    [self testPropertyName:@"raster-opacity" isBoolean:NO];
+    [self testPropertyName:@"raster-saturation" isBoolean:NO];
+}
+
+@end
diff --git a/platform/darwin/test/MGLRuntimeStylingHelper.h b/platform/darwin/test/MGLRuntimeStylingHelper.h
deleted file mode 100644
index 8857dba9c5..0000000000
--- a/platform/darwin/test/MGLRuntimeStylingHelper.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#import <Foundation/Foundation.h>
-
-#import "MGLTypes.h"
-#import "MGLStyleValue.h"
-
-@interface MGLRuntimeStylingHelper : NSObject
-
-+ (MGLStyleConstantValue<NSValue *> *)testPadding;
-+ (MGLStyleFunction<NSValue *> *)testPaddingFunction;
-
-+ (MGLStyleConstantValue<NSValue *> *)testOffset;
-+ (MGLStyleFunction<NSValue *> *)testOffsetFunction;
-
-+ (MGLStyleConstantValue<NSArray<NSString *> *> *)testFont;
-+ (MGLStyleFunction<NSArray<NSString *> *> *)testFontFunction;
-
-+ (MGLStyleConstantValue<NSArray<NSNumber *> *> *)testDashArray;
-+ (MGLStyleFunction<NSArray<NSNumber *> *> *)testDashArrayFunction;
-
-+ (MGLStyleConstantValue<NSNumber *> *)testNumber;
-+ (MGLStyleFunction<NSNumber *> *)testNumberFunction;
-
-+ (MGLStyleConstantValue<NSNumber *> *)testBool;
-+ (MGLStyleFunction<NSNumber *> *)testBoolFunction;
-
-+ (MGLStyleConstantValue<NSString *> *)testString;
-+ (MGLStyleFunction<NSString *> *)testStringFunction;
-
-+ (MGLStyleConstantValue<MGLColor *> *)testColor;
-+ (MGLStyleFunction<MGLColor *> *)testColorFunction;
-
-+ (MGLStyleConstantValue<NSValue *> *)testEnum:(NSUInteger)value type:(const char *)type;
-+ (MGLStyleFunction<NSValue *> *)testEnumFunction:(NSUInteger)value type:(const char *)type;
-
-@end
diff --git a/platform/darwin/test/MGLRuntimeStylingHelper.m b/platform/darwin/test/MGLRuntimeStylingHelper.m
deleted file mode 100644
index 955c664f2c..0000000000
--- a/platform/darwin/test/MGLRuntimeStylingHelper.m
+++ /dev/null
@@ -1,122 +0,0 @@
-#import "MGLRuntimeStylingHelper.h"
-
-#if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
-    #import <UIKit/UIKit.h>
-    #define MGLEdgeInsets UIEdgeInsets
-#else
-    #import <Cocoa/Cocoa.h>
-    #define MGLEdgeInsets NSEdgeInsets
-#endif
-
-@implementation MGLRuntimeStylingHelper
-
-+ (MGLStyleConstantValue<NSValue *> *)testPadding
-{
-    MGLEdgeInsets insets = {
-        .top = 1,
-        .left = 1,
-        .bottom = 1,
-        .right = 1,
-    };
-    return [MGLStyleConstantValue<NSValue *> valueWithRawValue:[NSValue value:&insets withObjCType:@encode(MGLEdgeInsets)]];
-}
-
-+ (MGLStyleFunction<NSValue *> *)testPaddingFunction
-{
-    return [MGLStyleFunction<NSValue *> functionWithStops:@{@(18): self.testPadding}];
-}
-
-+ (MGLStyleConstantValue<NSValue *> *)testOffset
-{
-    CGVector vector = CGVectorMake(1, 1);
-    return [MGLStyleConstantValue<NSValue *> valueWithRawValue:[NSValue value:&vector withObjCType:@encode(CGVector)]];
-}
-
-+ (MGLStyleFunction<NSValue *> *)testOffsetFunction
-{
-    return [MGLStyleFunction<NSValue *> valueWithStops:@{ @(18): self.testOffset }];
-}
-
-+ (MGLStyleConstantValue<NSArray<NSString *> *> *)testFont
-{
-    return [MGLStyleConstantValue<NSArray<NSString *> *> valueWithRawValue:@[@"Open Sans Regular", @"Arial Unicode MS Regular"]];
-}
-
-+ (MGLStyleFunction<NSArray<NSString *> *> *)testFontFunction
-{
-    return [MGLStyleFunction<NSArray<NSString *> *> valueWithStops:@{ @18: self.testFont }];
-}
-
-+ (MGLStyleConstantValue<NSArray<NSNumber *> *> *)testDashArray
-{
-    return [MGLStyleConstantValue<NSArray<NSNumber *> *> valueWithRawValue:@[@1, @2]];
-}
-
-+ (MGLStyleFunction<NSArray<NSNumber *> *> *)testDashArrayFunction
-{
-    return [MGLStyleFunction<NSArray<NSNumber *> *> valueWithStops:@{
-        @18: self.testDashArray,
-    }];
-}
-
-+ (MGLStyleConstantValue<NSNumber *> *)testNumber
-{
-    return [MGLStyleConstantValue<NSNumber *> valueWithRawValue:@1];
-}
-
-+ (MGLStyleFunction<NSNumber *> *)testNumberFunction
-{
-    return [MGLStyleFunction<NSNumber *> valueWithStops:@{
-        @18: self.testNumber,
-    }];
-}
-
-+ (MGLStyleConstantValue<NSNumber *> *)testBool
-{
-    return [MGLStyleConstantValue<NSNumber *> valueWithRawValue:@YES];
-}
-
-+ (MGLStyleFunction<NSNumber *> *)testBoolFunction
-{
-    return [MGLStyleFunction<NSNumber *> valueWithStops:@{
-        @18: self.testBool,
-    }];
-}
-
-+ (MGLStyleConstantValue<NSString *> *)testString
-{
-    return [MGLStyleConstantValue<NSString *> valueWithRawValue:@"test"];
-}
-
-+ (MGLStyleFunction<NSString *> *)testStringFunction
-{
-    return [MGLStyleFunction<NSString *> valueWithStops:@{
-        @18: self.testString,
-    }];
-}
-
-+ (MGLStyleConstantValue<MGLColor *> *)testColor
-{
-    return [MGLStyleConstantValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
-}
-
-+ (MGLStyleFunction<MGLColor *> *)testColorFunction
-{
-    return [MGLStyleFunction<MGLColor *> valueWithStops:@{
-        @18: self.testColor,
-    }];
-}
-
-+ (MGLStyleConstantValue<NSValue *> *)testEnum:(NSUInteger)value type:(const char *)type
-{
-    return [MGLStyleConstantValue<NSValue *> valueWithRawValue:[NSValue value:&value withObjCType:type]];
-}
-
-+ (MGLStyleFunction<NSValue *> *)testEnumFunction:(NSUInteger)value type:(const char *)type
-{
-    return [MGLStyleFunction<NSValue *> valueWithStops:@{
-        @18: [self testEnum:value type:type],
-    }];
-}
-
-@end
diff --git a/platform/darwin/test/MGLStyleLayerTests.h b/platform/darwin/test/MGLStyleLayerTests.h
index 65322ff331..f0b889f022 100644
--- a/platform/darwin/test/MGLStyleLayerTests.h
+++ b/platform/darwin/test/MGLStyleLayerTests.h
@@ -1,10 +1,8 @@
 #import <Mapbox/Mapbox.h>
-#import "MGLRuntimeStylingHelper.h"
 #import <XCTest/XCTest.h>
 
 @interface MGLStyleLayerTests : XCTestCase <MGLMapViewDelegate>
 
-@property (nonatomic) IBOutlet MGLMapView *mapView;
 @property (nonatomic, copy, readonly, class) NSString *layerType;
 
 - (void)testPropertyName:(NSString *)name isBoolean:(BOOL)isBoolean;
@@ -17,3 +15,11 @@
 @property (nonatomic, readonly, copy) NSString *lemma;
 
 @end
+
+@interface NSValue (MGLStyleLayerTestAdditions)
+
++ (instancetype)valueWithMGLVector:(CGVector)vector;
+
+@property (readonly) CGVector MGLVectorValue;
+
+@end
diff --git a/platform/darwin/test/MGLStyleLayerTests.m b/platform/darwin/test/MGLStyleLayerTests.m
index 0bf5072391..1dba9f4305 100644
--- a/platform/darwin/test/MGLStyleLayerTests.m
+++ b/platform/darwin/test/MGLStyleLayerTests.m
@@ -4,37 +4,32 @@
 
 #define TEST_STRICT_NAMING_CONVENTIONS 0
 
-@implementation MGLStyleLayerTests {
-    XCTestExpectation *_styleLoadingExpectation;
-}
+@implementation MGLStyleLayerTests
 
 @dynamic layerType;
 
-- (void)setUp {
-    [super setUp];
-    [MGLAccountManager setAccessToken:@"pk.feedcafedeadbeefbadebede"];
-    NSURL *styleURL = [[NSBundle bundleForClass:[self class]] URLForResource:@"one-liner" withExtension:@"json"];
-    self.mapView = [[MGLMapView alloc] initWithFrame:CGRectMake(0, 0, 256, 256) styleURL:styleURL];
-    self.mapView.delegate = self;
-    if (!self.mapView.style) {
-        _styleLoadingExpectation = [self expectationWithDescription:@"Map view should finish loading style."];
-        [self waitForExpectationsWithTimeout:1 handler:nil];
-    }
-}
-
-- (void)mapView:(MGLMapView *)mapView didFinishLoadingStyle:(MGLStyle *)style {
-    XCTAssertNotNil(mapView.style);
-    XCTAssertEqual(mapView.style, style);
-    XCTAssertNil(style.name);
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
     
-    [_styleLoadingExpectation fulfill];
-}
-
-- (void)tearDown {
-    _styleLoadingExpectation = nil;
-    _mapView = nil;
+    MGLFillStyleLayer *layer = [[MGLFillStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertEqualObjects(layer.identifier, @"layerID");
+    XCTAssertEqualObjects(layer.sourceIdentifier, source.identifier);
+    
+    XCTAssertTrue(layer.visible);
+    layer.visible = NO;
+    XCTAssertFalse(layer.visible);
+    layer.visible = YES;
+    XCTAssertTrue(layer.visible);
+    
+    XCTAssertEqual(layer.minimumZoomLevel, -INFINITY);
+    layer.minimumZoomLevel = 22;
+    XCTAssertEqual(layer.minimumZoomLevel, 22);
     
-    [super tearDown];
+    XCTAssertEqual(layer.maximumZoomLevel, INFINITY);
+    layer.maximumZoomLevel = 0;
+    XCTAssertEqual(layer.maximumZoomLevel, 0);
 }
 
 - (void)testPropertyName:(NSString *)name isBoolean:(BOOL)isBoolean {
@@ -99,3 +94,25 @@
 }
 
 @end
+
+@implementation NSValue (MGLStyleLayerTestAdditions)
+
++ (instancetype)valueWithMGLVector:(CGVector)vector {
+#if TARGET_OS_IPHONE
+    return [self valueWithCGVector:vector];
+#else
+    return [self value:&vector withObjCType:@encode(CGVector)];
+#endif
+}
+
+- (CGVector)MGLVectorValue {
+#if TARGET_OS_IPHONE
+    return self.CGVectorValue;
+#else
+    CGVector vector;
+    [self getValue:&vector];
+    return vector;
+#endif
+}
+
+@end
diff --git a/platform/darwin/test/MGLStyleLayerTests.m.ejs b/platform/darwin/test/MGLStyleLayerTests.m.ejs
deleted file mode 100644
index 6b7bfe2f1c..0000000000
--- a/platform/darwin/test/MGLStyleLayerTests.m.ejs
+++ /dev/null
@@ -1,72 +0,0 @@
-<%
-  const type = locals.type;
-  const layoutProperties = locals.layoutProperties;
-  const paintProperties = locals.paintProperties;
--%>
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGL<%- camelize(type) %>LayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGL<%- camelize(type) %>LayerTests
-
-+ (NSString *)layerType {
-    return @"<%- type %>";
-}
-
-- (void)test<%- camelize(type) %>Layer {
-<% if (type === 'background') { -%>
-    MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithIdentifier:@"layerID"];
-<% } else { -%>
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-<% } -%>
-    [self.mapView.style addLayer:layer];
-
-<% for (const property of layoutProperties) { -%>
-    <%- testImplementation(property, type) %>
-<% } -%>
-<% for (const property of paintProperties) { -%>
-    <%- testImplementation(property, type) %>
-<% } -%>
-
-    MGL<%- camelize(type) %>StyleLayer *gLayer = (MGL<%- camelize(type) %>StyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGL<%- camelize(type) %>StyleLayer class]]);
-<% for (const property of layoutProperties) { -%>
-    <%- testGetterImplementation(property, type) %>
-<% } -%>
-<% for (const property of paintProperties) { -%>
-    <%- testGetterImplementation(property, type) %>
-<% } -%>
-
-<% for (const property of layoutProperties) { -%>
-    <%- testImplementation(property, type, true) %>
-<% } -%>
-<% for (const property of paintProperties) { -%>
-    <%- testImplementation(property, type, true) %>
-<% } -%>
-
-<% for (const property of layoutProperties) { -%>
-    <%- testGetterImplementation(property, type, true) %>
-<% } -%>
-<% for (const property of paintProperties) { -%>
-    <%- testGetterImplementation(property, type, true) %>
-<% } -%>
-}
-
-- (void)testPropertyNames {
-<% for (const property of layoutProperties) { -%>
-    [self testPropertyName:@"<%- property.getter || property.name %>" isBoolean:<%- property.type === 'boolean' ? 'YES' : 'NO' %>];
-<% } -%>
-<% for (const property of paintProperties) { -%>
-    [self testPropertyName:@"<%- property.getter || property.name %>" isBoolean:<%- property.type === 'boolean' ? 'YES' : 'NO' %>];
-<% } -%>
-}
-
-@end
diff --git a/platform/darwin/test/MGLStyleLayerTests.mm.ejs b/platform/darwin/test/MGLStyleLayerTests.mm.ejs
new file mode 100644
index 0000000000..00842a5b4e
--- /dev/null
+++ b/platform/darwin/test/MGLStyleLayerTests.mm.ejs
@@ -0,0 +1,114 @@
+<%
+  const type = locals.type;
+  const properties = locals.properties;
+  const enumProperties = locals.enumProperties;
+-%>
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/<%- type %>_layer.hpp>
+
+@interface MGL<%- camelize(type) %>LayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGL<%- camelize(type) %>LayerTests
+
++ (NSString *)layerType {
+    return @"<%- type %>";
+}
+
+<% if (type !== 'background' && type !== 'raster') { -%>
+- (void)testPredicates {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    layer.sourceLayerIdentifier = @"layerID";
+    XCTAssertEqualObjects(layer.sourceLayerIdentifier, @"layerID");
+    layer.sourceLayerIdentifier = nil;
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    
+    XCTAssertNil(layer.predicate);
+    layer.predicate = [NSPredicate predicateWithValue:NO];
+    XCTAssertEqualObjects(layer.predicate, [NSPredicate predicateWithValue:NO]);
+    layer.predicate = nil;
+    XCTAssertNil(layer.predicate);
+}
+
+<% } -%>
+- (void)testProperties {
+<% if (type === 'background') { -%>
+    MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithIdentifier:@"layerID"];
+<% } else { -%>
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+<% } -%>
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::<%- camelize(type) %>Layer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::<%- camelize(type) %>Layer>();
+<% for (const property of properties) { -%>
+    
+    // <%- originalPropertyName(property) %>
+    {
+        XCTAssertTrue(rawLayer->get<%- camelize(originalPropertyName(property)) %>().isUndefined(),
+                      @"<%- originalPropertyName(property) %> should be unset initially.");
+        MGLStyleValue<<%- propertyType(property) %>> *defaultStyleValue = layer.<%- objCName(property) %>;
+        
+        MGLStyleValue<<%- propertyType(property) %>> *styleValue = [MGLStyleValue<<%- propertyType(property) %>> valueWithRawValue:<%- objCTestValue(property, type, 3) %>];
+        layer.<%- objCName(property) %> = styleValue;
+        mbgl::style::PropertyValue<<%- mbglType(property) %>> propertyValue = { <%- mbglTestValue(property, type) %> };
+        XCTAssertEqual(rawLayer->get<%- camelize(originalPropertyName(property)) %>(), propertyValue,
+                       @"Setting <%- objCName(property) %> to a constant value should update <%- originalPropertyName(property) %>.");
+        XCTAssertEqualObjects(layer.<%- objCName(property) %>, styleValue,
+                              @"<%- objCName(property) %> should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<<%- propertyType(property) %>> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.<%- objCName(property) %> = styleValue;
+        propertyValue = { mbgl::style::Function<<%- mbglType(property) %>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->get<%- camelize(originalPropertyName(property)) %>(), propertyValue,
+                       @"Setting <%- objCName(property) %> to a function should update <%- originalPropertyName(property) %>.");
+        XCTAssertEqualObjects(layer.<%- objCName(property) %>, styleValue,
+                              @"<%- objCName(property) %> should round-trip functions.");
+<% if (!property.required) { -%>
+        
+        layer.<%- objCName(property) %> = nil;
+        XCTAssertTrue(rawLayer->get<%- camelize(originalPropertyName(property)) %>().isUndefined(),
+                      @"Unsetting <%- objCName(property) %> should return <%- originalPropertyName(property) %> to the default value.");
+        XCTAssertEqualObjects(layer.<%- objCName(property) %>, defaultStyleValue,
+                              @"<%- objCName(property) %> should return the default value after being unset.");
+<% } -%>
+    }
+<% } -%>
+}
+
+- (void)testPropertyNames {
+<% for (const property of properties) { -%>
+    [self testPropertyName:@"<%- property.getter || property.name %>" isBoolean:<%- property.type === 'boolean' ? 'YES' : 'NO' %>];
+<% } -%>
+}
+
+<% if (enumProperties) { -%>
+- (void)testValueAdditions {
+<% for (let property of enumProperties) { -%>
+<% for (let value in property.values) { -%>
+<% if (property.values.hasOwnProperty(value)) { -%>
+    XCTAssertEqual([NSValue valueWithMGL<%- camelize(property.name) %>:MGL<%- camelize(property.name) %><%- camelize(value) %>].MGL<%- camelize(property.name) %>Value, MGL<%- camelize(property.name) %><%- camelize(value) %>);
+<% } -%>
+<% } -%>
+<% } -%>
+}
+
+<% } -%>
+@end
diff --git a/platform/darwin/test/MGLStyleLayerTests.xib b/platform/darwin/test/MGLStyleLayerTests.xib
deleted file mode 100644
index d21f5753fc..0000000000
--- a/platform/darwin/test/MGLStyleLayerTests.xib
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="11762" systemVersion="15G1212" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
-    <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11762"/>
-        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
-    </dependencies>
-    <objects>
-        <customObject id="-2" userLabel="File's Owner" customClass="MGLMapViewTests"/>
-        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
-        <customObject id="-3" userLabel="Application" customClass="NSObject"/>
-        <window title="MGLMapViewTests" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" animationBehavior="default" id="QvC-M9-y7g">
-            <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/>
-            <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
-            <rect key="contentRect" x="196" y="240" width="256" height="256"/>
-            <rect key="screenRect" x="0.0" y="0.0" width="1280" height="777"/>
-            <view key="contentView" wantsLayer="YES" id="EiT-Mj-1SZ">
-                <rect key="frame" x="0.0" y="0.0" width="256" height="256"/>
-                <autoresizingMask key="autoresizingMask"/>
-            </view>
-        </window>
-    </objects>
-</document>
diff --git a/platform/darwin/test/MGLStyleTests.mm b/platform/darwin/test/MGLStyleTests.mm
index 82de27973b..176217619d 100644
--- a/platform/darwin/test/MGLStyleTests.mm
+++ b/platform/darwin/test/MGLStyleTests.mm
@@ -39,7 +39,6 @@
 - (void)mapView:(MGLMapView *)mapView didFinishLoadingStyle:(MGLStyle *)style {
     XCTAssertNotNil(mapView.style);
     XCTAssertEqual(mapView.style, style);
-    XCTAssertNil(style.name);
     
     [_styleLoadingExpectation fulfill];
 }
@@ -135,6 +134,24 @@
     }];
 }
 
+- (void)testName {
+    XCTAssertNil(self.style.name);
+}
+
+- (void)testSources {
+    NSSet<MGLSource *> *initialSources = self.style.sources;
+    if ([initialSources.anyObject.identifier isEqualToString:@"com.mapbox.annotations"]) {
+        XCTAssertEqual(self.style.sources.count, 1);
+    } else {
+        XCTAssertEqual(self.style.sources.count, 0);
+    }
+    MGLShapeSource *shapeSource = [[MGLShapeSource alloc] initWithIdentifier:@"shapeSource" shape:nil options:nil];
+    [self.style addSource:shapeSource];
+    XCTAssertEqual(self.style.sources.count, initialSources.count + 1);
+    [self.style removeSource:shapeSource];
+    XCTAssertEqual(self.style.sources.count, initialSources.count);
+}
+
 - (void)testAddingSourcesTwice {
     MGLShapeSource *shapeSource = [[MGLShapeSource alloc] initWithIdentifier:@"shapeSource" shape:nil options:nil];
     [self.style addSource:shapeSource];
@@ -157,6 +174,22 @@
     XCTAssertThrowsSpecificNamed([self.style addSource: source2], NSException, @"MGLRedundantSourceIdentifierException");
 }
 
+- (void)testLayers {
+    NSArray<MGLStyleLayer *> *initialLayers = self.style.layers;
+    if ([initialLayers.firstObject.identifier isEqualToString:@"com.mapbox.annotations.points"]) {
+        XCTAssertEqual(self.style.layers.count, 1);
+    } else {
+        XCTAssertEqual(self.style.layers.count, 0);
+    }
+    MGLShapeSource *shapeSource = [[MGLShapeSource alloc] initWithIdentifier:@"shapeSource" shape:nil options:nil];
+    [self.style addSource:shapeSource];
+    MGLFillStyleLayer *fillLayer = [[MGLFillStyleLayer alloc] initWithIdentifier:@"fillLayer" source:shapeSource];
+    [self.style addLayer:fillLayer];
+    XCTAssertEqual(self.style.layers.count, initialLayers.count + 1);
+    [self.style removeLayer:fillLayer];
+    XCTAssertEqual(self.style.layers.count, initialLayers.count);
+}
+
 - (void)testAddingLayersTwice {
     MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"shapeSource" shape:nil options:nil];
 
@@ -212,6 +245,10 @@
     return styleHeader;
 }
 
+- (void)testClasses {
+    XCTAssertEqual(self.style.styleClasses.count, 0);
+}
+
 - (void)testImages {
     NSString *imageName = @"TrackingLocationMask";
 #if TARGET_OS_IPHONE
diff --git a/platform/darwin/test/MGLSymbolStyleLayerTests.m b/platform/darwin/test/MGLSymbolStyleLayerTests.m
deleted file mode 100644
index ba9bc78d26..0000000000
--- a/platform/darwin/test/MGLSymbolStyleLayerTests.m
+++ /dev/null
@@ -1,283 +0,0 @@
-// This file is generated. 
-// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
-
-#import "MGLStyleLayerTests.h"
-
-@interface MGLSymbolLayerTests : MGLStyleLayerTests
-@end
-
-@implementation MGLSymbolLayerTests
-
-+ (NSString *)layerType {
-    return @"symbol";
-}
-
-- (void)testSymbolLayer {
-    NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"];
-    NSURL *url = [NSURL fileURLWithPath:filePath];
-    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" URL:url options:nil];
-    [self.mapView.style addSource:source];
-    MGLSymbolStyleLayer *layer = [[MGLSymbolStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
-    [self.mapView.style addLayer:layer];
-
-    layer.iconAllowsOverlap = [MGLRuntimeStylingHelper testBool];
-    layer.iconIgnoresPlacement = [MGLRuntimeStylingHelper testBool];
-    layer.iconImageName = [MGLRuntimeStylingHelper testString];
-    layer.iconOffset = [MGLRuntimeStylingHelper testOffset];
-    layer.iconOptional = [MGLRuntimeStylingHelper testBool];
-    layer.iconPadding = [MGLRuntimeStylingHelper testNumber];
-    layer.iconRotation = [MGLRuntimeStylingHelper testNumber];
-    layer.iconRotationAlignment = [MGLRuntimeStylingHelper testEnum:MGLIconRotationAlignmentAuto type:@encode(MGLIconRotationAlignment)];
-    layer.iconScale = [MGLRuntimeStylingHelper testNumber];
-    layer.iconTextFit = [MGLRuntimeStylingHelper testEnum:MGLIconTextFitBoth type:@encode(MGLIconTextFit)];
-    layer.iconTextFitPadding = [MGLRuntimeStylingHelper testPadding];
-    layer.keepsIconUpright = [MGLRuntimeStylingHelper testBool];
-    layer.keepsTextUpright = [MGLRuntimeStylingHelper testBool];
-    layer.maximumTextAngle = [MGLRuntimeStylingHelper testNumber];
-    layer.maximumTextWidth = [MGLRuntimeStylingHelper testNumber];
-    layer.symbolAvoidsEdges = [MGLRuntimeStylingHelper testBool];
-    layer.symbolPlacement = [MGLRuntimeStylingHelper testEnum:MGLSymbolPlacementLine type:@encode(MGLSymbolPlacement)];
-    layer.symbolSpacing = [MGLRuntimeStylingHelper testNumber];
-    layer.text = [MGLRuntimeStylingHelper testString];
-    layer.textAllowsOverlap = [MGLRuntimeStylingHelper testBool];
-    layer.textAnchor = [MGLRuntimeStylingHelper testEnum:MGLTextAnchorBottomRight type:@encode(MGLTextAnchor)];
-    layer.textFontNames = [MGLRuntimeStylingHelper testFont];
-    layer.textFontSize = [MGLRuntimeStylingHelper testNumber];
-    layer.textIgnoresPlacement = [MGLRuntimeStylingHelper testBool];
-    layer.textJustification = [MGLRuntimeStylingHelper testEnum:MGLTextJustificationRight type:@encode(MGLTextJustification)];
-    layer.textLetterSpacing = [MGLRuntimeStylingHelper testNumber];
-    layer.textLineHeight = [MGLRuntimeStylingHelper testNumber];
-    layer.textOffset = [MGLRuntimeStylingHelper testOffset];
-    layer.textOptional = [MGLRuntimeStylingHelper testBool];
-    layer.textPadding = [MGLRuntimeStylingHelper testNumber];
-    layer.textPitchAlignment = [MGLRuntimeStylingHelper testEnum:MGLTextPitchAlignmentAuto type:@encode(MGLTextPitchAlignment)];
-    layer.textRotation = [MGLRuntimeStylingHelper testNumber];
-    layer.textRotationAlignment = [MGLRuntimeStylingHelper testEnum:MGLTextRotationAlignmentAuto type:@encode(MGLTextRotationAlignment)];
-    layer.textTransform = [MGLRuntimeStylingHelper testEnum:MGLTextTransformLowercase type:@encode(MGLTextTransform)];
-    layer.iconColor = [MGLRuntimeStylingHelper testColor];
-    layer.iconHaloBlur = [MGLRuntimeStylingHelper testNumber];
-    layer.iconHaloColor = [MGLRuntimeStylingHelper testColor];
-    layer.iconHaloWidth = [MGLRuntimeStylingHelper testNumber];
-    layer.iconOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.iconTranslation = [MGLRuntimeStylingHelper testOffset];
-    layer.iconTranslationAnchor = [MGLRuntimeStylingHelper testEnum:MGLIconTranslationAnchorViewport type:@encode(MGLIconTranslationAnchor)];
-    layer.textColor = [MGLRuntimeStylingHelper testColor];
-    layer.textHaloBlur = [MGLRuntimeStylingHelper testNumber];
-    layer.textHaloColor = [MGLRuntimeStylingHelper testColor];
-    layer.textHaloWidth = [MGLRuntimeStylingHelper testNumber];
-    layer.textOpacity = [MGLRuntimeStylingHelper testNumber];
-    layer.textTranslation = [MGLRuntimeStylingHelper testOffset];
-    layer.textTranslationAnchor = [MGLRuntimeStylingHelper testEnum:MGLTextTranslationAnchorViewport type:@encode(MGLTextTranslationAnchor)];
-
-    MGLSymbolStyleLayer *gLayer = (MGLSymbolStyleLayer *)[self.mapView.style layerWithIdentifier:@"layerID"];
-    XCTAssertTrue([gLayer isKindOfClass:[MGLSymbolStyleLayer class]]);
-    XCTAssertEqualObjects(gLayer.iconAllowsOverlap, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.iconIgnoresPlacement, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.iconImageName, [MGLRuntimeStylingHelper testString]);
-    XCTAssertEqualObjects(gLayer.iconOffset, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssertEqualObjects(gLayer.iconOptional, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.iconPadding, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.iconRotation, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssert([gLayer.iconRotationAlignment isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.iconRotationAlignment, [MGLRuntimeStylingHelper testEnum:MGLIconRotationAlignmentAuto type:@encode(MGLIconRotationAlignment)]);
-    XCTAssertEqualObjects(gLayer.iconScale, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssert([gLayer.iconTextFit isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.iconTextFit, [MGLRuntimeStylingHelper testEnum:MGLIconTextFitBoth type:@encode(MGLIconTextFit)]);
-    XCTAssertEqualObjects(gLayer.iconTextFitPadding, [MGLRuntimeStylingHelper testPadding]);
-    XCTAssertEqualObjects(gLayer.keepsIconUpright, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.keepsTextUpright, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.maximumTextAngle, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.maximumTextWidth, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.symbolAvoidsEdges, [MGLRuntimeStylingHelper testBool]);
-    XCTAssert([gLayer.symbolPlacement isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.symbolPlacement, [MGLRuntimeStylingHelper testEnum:MGLSymbolPlacementLine type:@encode(MGLSymbolPlacement)]);
-    XCTAssertEqualObjects(gLayer.symbolSpacing, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.text, [MGLRuntimeStylingHelper testString]);
-    XCTAssertEqualObjects(gLayer.textAllowsOverlap, [MGLRuntimeStylingHelper testBool]);
-    XCTAssert([gLayer.textAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textAnchor, [MGLRuntimeStylingHelper testEnum:MGLTextAnchorBottomRight type:@encode(MGLTextAnchor)]);
-    XCTAssertEqualObjects(gLayer.textFontNames, [MGLRuntimeStylingHelper testFont]);
-    XCTAssertEqualObjects(gLayer.textFontSize, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textIgnoresPlacement, [MGLRuntimeStylingHelper testBool]);
-    XCTAssert([gLayer.textJustification isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textJustification, [MGLRuntimeStylingHelper testEnum:MGLTextJustificationRight type:@encode(MGLTextJustification)]);
-    XCTAssertEqualObjects(gLayer.textLetterSpacing, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textLineHeight, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textOffset, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssertEqualObjects(gLayer.textOptional, [MGLRuntimeStylingHelper testBool]);
-    XCTAssertEqualObjects(gLayer.textPadding, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssert([gLayer.textPitchAlignment isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textPitchAlignment, [MGLRuntimeStylingHelper testEnum:MGLTextPitchAlignmentAuto type:@encode(MGLTextPitchAlignment)]);
-    XCTAssertEqualObjects(gLayer.textRotation, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssert([gLayer.textRotationAlignment isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textRotationAlignment, [MGLRuntimeStylingHelper testEnum:MGLTextRotationAlignmentAuto type:@encode(MGLTextRotationAlignment)]);
-    XCTAssert([gLayer.textTransform isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textTransform, [MGLRuntimeStylingHelper testEnum:MGLTextTransformLowercase type:@encode(MGLTextTransform)]);
-    XCTAssertEqualObjects(gLayer.iconColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.iconHaloBlur, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.iconHaloColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.iconHaloWidth, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.iconOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.iconTranslation, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssert([gLayer.iconTranslationAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.iconTranslationAnchor, [MGLRuntimeStylingHelper testEnum:MGLIconTranslationAnchorViewport type:@encode(MGLIconTranslationAnchor)]);
-    XCTAssertEqualObjects(gLayer.textColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.textHaloBlur, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textHaloColor, [MGLRuntimeStylingHelper testColor]);
-    XCTAssertEqualObjects(gLayer.textHaloWidth, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textOpacity, [MGLRuntimeStylingHelper testNumber]);
-    XCTAssertEqualObjects(gLayer.textTranslation, [MGLRuntimeStylingHelper testOffset]);
-    XCTAssert([gLayer.textTranslationAnchor isKindOfClass:[MGLStyleConstantValue class]]);
-    XCTAssertEqualObjects(gLayer.textTranslationAnchor, [MGLRuntimeStylingHelper testEnum:MGLTextTranslationAnchorViewport type:@encode(MGLTextTranslationAnchor)]);
-
-    layer.iconAllowsOverlap = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.iconIgnoresPlacement = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.iconImageName = [MGLRuntimeStylingHelper testStringFunction];
-    layer.iconOffset = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.iconOptional = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.iconPadding = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconRotation = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconRotationAlignment = [MGLRuntimeStylingHelper testEnumFunction:MGLIconRotationAlignmentAuto type:@encode(MGLIconRotationAlignment)];
-    layer.iconScale = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconTextFit = [MGLRuntimeStylingHelper testEnumFunction:MGLIconTextFitBoth type:@encode(MGLIconTextFit)];
-    layer.iconTextFitPadding = [MGLRuntimeStylingHelper testPaddingFunction];
-    layer.keepsIconUpright = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.keepsTextUpright = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.maximumTextAngle = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.maximumTextWidth = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.symbolAvoidsEdges = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.symbolPlacement = [MGLRuntimeStylingHelper testEnumFunction:MGLSymbolPlacementLine type:@encode(MGLSymbolPlacement)];
-    layer.symbolSpacing = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.text = [MGLRuntimeStylingHelper testStringFunction];
-    layer.textAllowsOverlap = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.textAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLTextAnchorBottomRight type:@encode(MGLTextAnchor)];
-    layer.textFontNames = [MGLRuntimeStylingHelper testFontFunction];
-    layer.textFontSize = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textIgnoresPlacement = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.textJustification = [MGLRuntimeStylingHelper testEnumFunction:MGLTextJustificationRight type:@encode(MGLTextJustification)];
-    layer.textLetterSpacing = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textLineHeight = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textOffset = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.textOptional = [MGLRuntimeStylingHelper testBoolFunction];
-    layer.textPadding = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textPitchAlignment = [MGLRuntimeStylingHelper testEnumFunction:MGLTextPitchAlignmentAuto type:@encode(MGLTextPitchAlignment)];
-    layer.textRotation = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textRotationAlignment = [MGLRuntimeStylingHelper testEnumFunction:MGLTextRotationAlignmentAuto type:@encode(MGLTextRotationAlignment)];
-    layer.textTransform = [MGLRuntimeStylingHelper testEnumFunction:MGLTextTransformLowercase type:@encode(MGLTextTransform)];
-    layer.iconColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.iconHaloBlur = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconHaloColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.iconHaloWidth = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.iconTranslation = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.iconTranslationAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLIconTranslationAnchorViewport type:@encode(MGLIconTranslationAnchor)];
-    layer.textColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.textHaloBlur = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textHaloColor = [MGLRuntimeStylingHelper testColorFunction];
-    layer.textHaloWidth = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textOpacity = [MGLRuntimeStylingHelper testNumberFunction];
-    layer.textTranslation = [MGLRuntimeStylingHelper testOffsetFunction];
-    layer.textTranslationAnchor = [MGLRuntimeStylingHelper testEnumFunction:MGLTextTranslationAnchorViewport type:@encode(MGLTextTranslationAnchor)];
-
-    XCTAssertEqualObjects(gLayer.iconAllowsOverlap, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.iconIgnoresPlacement, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.iconImageName, [MGLRuntimeStylingHelper testStringFunction]);
-    XCTAssertEqualObjects(gLayer.iconOffset, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.iconOptional, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.iconPadding, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconRotation, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconRotationAlignment, [MGLRuntimeStylingHelper testEnumFunction:MGLIconRotationAlignmentAuto type:@encode(MGLIconRotationAlignment)]);
-    XCTAssertEqualObjects(gLayer.iconScale, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconTextFit, [MGLRuntimeStylingHelper testEnumFunction:MGLIconTextFitBoth type:@encode(MGLIconTextFit)]);
-    XCTAssertEqualObjects(gLayer.iconTextFitPadding, [MGLRuntimeStylingHelper testPaddingFunction]);
-    XCTAssertEqualObjects(gLayer.keepsIconUpright, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.keepsTextUpright, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.maximumTextAngle, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.maximumTextWidth, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.symbolAvoidsEdges, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.symbolPlacement, [MGLRuntimeStylingHelper testEnumFunction:MGLSymbolPlacementLine type:@encode(MGLSymbolPlacement)]);
-    XCTAssertEqualObjects(gLayer.symbolSpacing, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.text, [MGLRuntimeStylingHelper testStringFunction]);
-    XCTAssertEqualObjects(gLayer.textAllowsOverlap, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.textAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLTextAnchorBottomRight type:@encode(MGLTextAnchor)]);
-    XCTAssertEqualObjects(gLayer.textFontNames, [MGLRuntimeStylingHelper testFontFunction]);
-    XCTAssertEqualObjects(gLayer.textFontSize, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textIgnoresPlacement, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.textJustification, [MGLRuntimeStylingHelper testEnumFunction:MGLTextJustificationRight type:@encode(MGLTextJustification)]);
-    XCTAssertEqualObjects(gLayer.textLetterSpacing, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textLineHeight, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textOffset, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.textOptional, [MGLRuntimeStylingHelper testBoolFunction]);
-    XCTAssertEqualObjects(gLayer.textPadding, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textPitchAlignment, [MGLRuntimeStylingHelper testEnumFunction:MGLTextPitchAlignmentAuto type:@encode(MGLTextPitchAlignment)]);
-    XCTAssertEqualObjects(gLayer.textRotation, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textRotationAlignment, [MGLRuntimeStylingHelper testEnumFunction:MGLTextRotationAlignmentAuto type:@encode(MGLTextRotationAlignment)]);
-    XCTAssertEqualObjects(gLayer.textTransform, [MGLRuntimeStylingHelper testEnumFunction:MGLTextTransformLowercase type:@encode(MGLTextTransform)]);
-    XCTAssertEqualObjects(gLayer.iconColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.iconHaloBlur, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconHaloColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.iconHaloWidth, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.iconTranslation, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.iconTranslationAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLIconTranslationAnchorViewport type:@encode(MGLIconTranslationAnchor)]);
-    XCTAssertEqualObjects(gLayer.textColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.textHaloBlur, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textHaloColor, [MGLRuntimeStylingHelper testColorFunction]);
-    XCTAssertEqualObjects(gLayer.textHaloWidth, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textOpacity, [MGLRuntimeStylingHelper testNumberFunction]);
-    XCTAssertEqualObjects(gLayer.textTranslation, [MGLRuntimeStylingHelper testOffsetFunction]);
-    XCTAssertEqualObjects(gLayer.textTranslationAnchor, [MGLRuntimeStylingHelper testEnumFunction:MGLTextTranslationAnchorViewport type:@encode(MGLTextTranslationAnchor)]);
-}
-
-- (void)testPropertyNames {
-    [self testPropertyName:@"icon-allows-overlap" isBoolean:YES];
-    [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-rotation" isBoolean:NO];
-    [self testPropertyName:@"icon-rotation-alignment" isBoolean:NO];
-    [self testPropertyName:@"icon-scale" isBoolean:NO];
-    [self testPropertyName:@"icon-text-fit" isBoolean:NO];
-    [self testPropertyName:@"icon-text-fit-padding" isBoolean:NO];
-    [self testPropertyName:@"keeps-icon-upright" isBoolean:YES];
-    [self testPropertyName:@"keeps-text-upright" isBoolean:YES];
-    [self testPropertyName:@"maximum-text-angle" isBoolean:NO];
-    [self testPropertyName:@"maximum-text-width" isBoolean:NO];
-    [self testPropertyName:@"symbol-avoids-edges" isBoolean:YES];
-    [self testPropertyName:@"symbol-placement" isBoolean:NO];
-    [self testPropertyName:@"symbol-spacing" isBoolean:NO];
-    [self testPropertyName:@"text" isBoolean:NO];
-    [self testPropertyName:@"text-allows-overlap" isBoolean:YES];
-    [self testPropertyName:@"text-anchor" isBoolean:NO];
-    [self testPropertyName:@"text-font-names" isBoolean:NO];
-    [self testPropertyName:@"text-font-size" isBoolean:NO];
-    [self testPropertyName:@"text-ignores-placement" isBoolean:YES];
-    [self testPropertyName:@"text-justification" isBoolean:NO];
-    [self testPropertyName:@"text-letter-spacing" isBoolean:NO];
-    [self testPropertyName:@"text-line-height" isBoolean:NO];
-    [self testPropertyName:@"text-offset" isBoolean:NO];
-    [self testPropertyName:@"is-text-optional" isBoolean:YES];
-    [self testPropertyName:@"text-padding" isBoolean:NO];
-    [self testPropertyName:@"text-pitch-alignment" isBoolean:NO];
-    [self testPropertyName:@"text-rotation" isBoolean:NO];
-    [self testPropertyName:@"text-rotation-alignment" isBoolean:NO];
-    [self testPropertyName:@"text-transform" isBoolean:NO];
-    [self testPropertyName:@"icon-color" isBoolean:NO];
-    [self testPropertyName:@"icon-halo-blur" isBoolean:NO];
-    [self testPropertyName:@"icon-halo-color" isBoolean:NO];
-    [self testPropertyName:@"icon-halo-width" isBoolean:NO];
-    [self testPropertyName:@"icon-opacity" isBoolean:NO];
-    [self testPropertyName:@"icon-translation" isBoolean:NO];
-    [self testPropertyName:@"icon-translation-anchor" isBoolean:NO];
-    [self testPropertyName:@"text-color" isBoolean:NO];
-    [self testPropertyName:@"text-halo-blur" isBoolean:NO];
-    [self testPropertyName:@"text-halo-color" isBoolean:NO];
-    [self testPropertyName:@"text-halo-width" isBoolean:NO];
-    [self testPropertyName:@"text-opacity" isBoolean:NO];
-    [self testPropertyName:@"text-translation" isBoolean:NO];
-    [self testPropertyName:@"text-translation-anchor" isBoolean:NO];
-}
-
-@end
diff --git a/platform/darwin/test/MGLSymbolStyleLayerTests.mm b/platform/darwin/test/MGLSymbolStyleLayerTests.mm
new file mode 100644
index 0000000000..c4dee559fc
--- /dev/null
+++ b/platform/darwin/test/MGLSymbolStyleLayerTests.mm
@@ -0,0 +1,1797 @@
+// This file is generated. 
+// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`.
+
+#import "MGLStyleLayerTests.h"
+
+#import "MGLStyleLayer_Private.h"
+
+#include <mbgl/style/layers/symbol_layer.hpp>
+
+@interface MGLSymbolLayerTests : MGLStyleLayerTests
+@end
+
+@implementation MGLSymbolLayerTests
+
++ (NSString *)layerType {
+    return @"symbol";
+}
+
+- (void)testPredicates {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    MGLSymbolStyleLayer *layer = [[MGLSymbolStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    layer.sourceLayerIdentifier = @"layerID";
+    XCTAssertEqualObjects(layer.sourceLayerIdentifier, @"layerID");
+    layer.sourceLayerIdentifier = nil;
+    XCTAssertNil(layer.sourceLayerIdentifier);
+    
+    XCTAssertNil(layer.predicate);
+    layer.predicate = [NSPredicate predicateWithValue:NO];
+    XCTAssertEqualObjects(layer.predicate, [NSPredicate predicateWithValue:NO]);
+    layer.predicate = nil;
+    XCTAssertNil(layer.predicate);
+}
+
+- (void)testProperties {
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    MGLShapeSource *source = [[MGLShapeSource alloc] initWithIdentifier:@"sourceID" shape:feature options:nil];
+    
+    MGLSymbolStyleLayer *layer = [[MGLSymbolStyleLayer alloc] initWithIdentifier:@"layerID" source:source];
+    XCTAssertNotEqual(layer.rawLayer, nullptr);
+    XCTAssertTrue(layer.rawLayer->is<mbgl::style::SymbolLayer>());
+    auto rawLayer = layer.rawLayer->as<mbgl::style::SymbolLayer>();
+    
+    // icon-allow-overlap
+    {
+        XCTAssertTrue(rawLayer->getIconAllowOverlap().isUndefined(),
+                      @"icon-allow-overlap should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconAllowsOverlap;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.iconAllowsOverlap = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getIconAllowOverlap(), propertyValue,
+                       @"Setting iconAllowsOverlap to a constant value should update icon-allow-overlap.");
+        XCTAssertEqualObjects(layer.iconAllowsOverlap, styleValue,
+                              @"iconAllowsOverlap should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconAllowsOverlap = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconAllowOverlap(), propertyValue,
+                       @"Setting iconAllowsOverlap to a function should update icon-allow-overlap.");
+        XCTAssertEqualObjects(layer.iconAllowsOverlap, styleValue,
+                              @"iconAllowsOverlap should round-trip functions.");
+        
+        layer.iconAllowsOverlap = nil;
+        XCTAssertTrue(rawLayer->getIconAllowOverlap().isUndefined(),
+                      @"Unsetting iconAllowsOverlap should return icon-allow-overlap to the default value.");
+        XCTAssertEqualObjects(layer.iconAllowsOverlap, defaultStyleValue,
+                              @"iconAllowsOverlap should return the default value after being unset.");
+    }
+    
+    // icon-ignore-placement
+    {
+        XCTAssertTrue(rawLayer->getIconIgnorePlacement().isUndefined(),
+                      @"icon-ignore-placement should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconIgnoresPlacement;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.iconIgnoresPlacement = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getIconIgnorePlacement(), propertyValue,
+                       @"Setting iconIgnoresPlacement to a constant value should update icon-ignore-placement.");
+        XCTAssertEqualObjects(layer.iconIgnoresPlacement, styleValue,
+                              @"iconIgnoresPlacement should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconIgnoresPlacement = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconIgnorePlacement(), propertyValue,
+                       @"Setting iconIgnoresPlacement to a function should update icon-ignore-placement.");
+        XCTAssertEqualObjects(layer.iconIgnoresPlacement, styleValue,
+                              @"iconIgnoresPlacement should round-trip functions.");
+        
+        layer.iconIgnoresPlacement = nil;
+        XCTAssertTrue(rawLayer->getIconIgnorePlacement().isUndefined(),
+                      @"Unsetting iconIgnoresPlacement should return icon-ignore-placement to the default value.");
+        XCTAssertEqualObjects(layer.iconIgnoresPlacement, defaultStyleValue,
+                              @"iconIgnoresPlacement should return the default value after being unset.");
+    }
+    
+    // icon-image
+    {
+        XCTAssertTrue(rawLayer->getIconImage().isUndefined(),
+                      @"icon-image should be unset initially.");
+        MGLStyleValue<NSString *> *defaultStyleValue = layer.iconImageName;
+        
+        MGLStyleValue<NSString *> *styleValue = [MGLStyleValue<NSString *> valueWithRawValue:@"Icon Image"];
+        layer.iconImageName = styleValue;
+        mbgl::style::PropertyValue<std::string> propertyValue = { "Icon Image" };
+        XCTAssertEqual(rawLayer->getIconImage(), propertyValue,
+                       @"Setting iconImageName to a constant value should update icon-image.");
+        XCTAssertEqualObjects(layer.iconImageName, styleValue,
+                              @"iconImageName should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSString *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconImageName = styleValue;
+        propertyValue = { mbgl::style::Function<std::string> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconImage(), propertyValue,
+                       @"Setting iconImageName to a function should update icon-image.");
+        XCTAssertEqualObjects(layer.iconImageName, styleValue,
+                              @"iconImageName should round-trip functions.");
+        
+        layer.iconImageName = nil;
+        XCTAssertTrue(rawLayer->getIconImage().isUndefined(),
+                      @"Unsetting iconImageName should return icon-image to the default value.");
+        XCTAssertEqualObjects(layer.iconImageName, defaultStyleValue,
+                              @"iconImageName should return the default value after being unset.");
+    }
+    
+    // icon-offset
+    {
+        XCTAssertTrue(rawLayer->getIconOffset().isUndefined(),
+                      @"icon-offset should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconOffset;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.iconOffset = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getIconOffset(), propertyValue,
+                       @"Setting iconOffset to a constant value should update icon-offset.");
+        XCTAssertEqualObjects(layer.iconOffset, styleValue,
+                              @"iconOffset should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconOffset = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconOffset(), propertyValue,
+                       @"Setting iconOffset to a function should update icon-offset.");
+        XCTAssertEqualObjects(layer.iconOffset, styleValue,
+                              @"iconOffset should round-trip functions.");
+        
+        layer.iconOffset = nil;
+        XCTAssertTrue(rawLayer->getIconOffset().isUndefined(),
+                      @"Unsetting iconOffset should return icon-offset to the default value.");
+        XCTAssertEqualObjects(layer.iconOffset, defaultStyleValue,
+                              @"iconOffset should return the default value after being unset.");
+    }
+    
+    // icon-optional
+    {
+        XCTAssertTrue(rawLayer->getIconOptional().isUndefined(),
+                      @"icon-optional should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconOptional;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.iconOptional = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getIconOptional(), propertyValue,
+                       @"Setting iconOptional to a constant value should update icon-optional.");
+        XCTAssertEqualObjects(layer.iconOptional, styleValue,
+                              @"iconOptional should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconOptional = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconOptional(), propertyValue,
+                       @"Setting iconOptional to a function should update icon-optional.");
+        XCTAssertEqualObjects(layer.iconOptional, styleValue,
+                              @"iconOptional should round-trip functions.");
+        
+        layer.iconOptional = nil;
+        XCTAssertTrue(rawLayer->getIconOptional().isUndefined(),
+                      @"Unsetting iconOptional should return icon-optional to the default value.");
+        XCTAssertEqualObjects(layer.iconOptional, defaultStyleValue,
+                              @"iconOptional should return the default value after being unset.");
+    }
+    
+    // icon-padding
+    {
+        XCTAssertTrue(rawLayer->getIconPadding().isUndefined(),
+                      @"icon-padding should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconPadding;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconPadding = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconPadding(), propertyValue,
+                       @"Setting iconPadding to a constant value should update icon-padding.");
+        XCTAssertEqualObjects(layer.iconPadding, styleValue,
+                              @"iconPadding should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconPadding = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconPadding(), propertyValue,
+                       @"Setting iconPadding to a function should update icon-padding.");
+        XCTAssertEqualObjects(layer.iconPadding, styleValue,
+                              @"iconPadding should round-trip functions.");
+        
+        layer.iconPadding = nil;
+        XCTAssertTrue(rawLayer->getIconPadding().isUndefined(),
+                      @"Unsetting iconPadding should return icon-padding to the default value.");
+        XCTAssertEqualObjects(layer.iconPadding, defaultStyleValue,
+                              @"iconPadding should return the default value after being unset.");
+    }
+    
+    // icon-rotate
+    {
+        XCTAssertTrue(rawLayer->getIconRotate().isUndefined(),
+                      @"icon-rotate should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconRotation;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconRotation = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconRotate(), propertyValue,
+                       @"Setting iconRotation to a constant value should update icon-rotate.");
+        XCTAssertEqualObjects(layer.iconRotation, styleValue,
+                              @"iconRotation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconRotation = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconRotate(), propertyValue,
+                       @"Setting iconRotation to a function should update icon-rotate.");
+        XCTAssertEqualObjects(layer.iconRotation, styleValue,
+                              @"iconRotation should round-trip functions.");
+        
+        layer.iconRotation = nil;
+        XCTAssertTrue(rawLayer->getIconRotate().isUndefined(),
+                      @"Unsetting iconRotation should return icon-rotate to the default value.");
+        XCTAssertEqualObjects(layer.iconRotation, defaultStyleValue,
+                              @"iconRotation should return the default value after being unset.");
+    }
+    
+    // icon-rotation-alignment
+    {
+        XCTAssertTrue(rawLayer->getIconRotationAlignment().isUndefined(),
+                      @"icon-rotation-alignment should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconRotationAlignment;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentAuto]];
+        layer.iconRotationAlignment = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::AlignmentType> propertyValue = { mbgl::style::AlignmentType::Auto };
+        XCTAssertEqual(rawLayer->getIconRotationAlignment(), propertyValue,
+                       @"Setting iconRotationAlignment to a constant value should update icon-rotation-alignment.");
+        XCTAssertEqualObjects(layer.iconRotationAlignment, styleValue,
+                              @"iconRotationAlignment should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconRotationAlignment = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::AlignmentType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconRotationAlignment(), propertyValue,
+                       @"Setting iconRotationAlignment to a function should update icon-rotation-alignment.");
+        XCTAssertEqualObjects(layer.iconRotationAlignment, styleValue,
+                              @"iconRotationAlignment should round-trip functions.");
+        
+        layer.iconRotationAlignment = nil;
+        XCTAssertTrue(rawLayer->getIconRotationAlignment().isUndefined(),
+                      @"Unsetting iconRotationAlignment should return icon-rotation-alignment to the default value.");
+        XCTAssertEqualObjects(layer.iconRotationAlignment, defaultStyleValue,
+                              @"iconRotationAlignment should return the default value after being unset.");
+    }
+    
+    // icon-size
+    {
+        XCTAssertTrue(rawLayer->getIconSize().isUndefined(),
+                      @"icon-size should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconScale;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconScale = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconSize(), propertyValue,
+                       @"Setting iconScale to a constant value should update icon-size.");
+        XCTAssertEqualObjects(layer.iconScale, styleValue,
+                              @"iconScale should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconScale = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconSize(), propertyValue,
+                       @"Setting iconScale to a function should update icon-size.");
+        XCTAssertEqualObjects(layer.iconScale, styleValue,
+                              @"iconScale should round-trip functions.");
+        
+        layer.iconScale = nil;
+        XCTAssertTrue(rawLayer->getIconSize().isUndefined(),
+                      @"Unsetting iconScale should return icon-size to the default value.");
+        XCTAssertEqualObjects(layer.iconScale, defaultStyleValue,
+                              @"iconScale should return the default value after being unset.");
+    }
+    
+    // icon-text-fit
+    {
+        XCTAssertTrue(rawLayer->getIconTextFit().isUndefined(),
+                      @"icon-text-fit should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconTextFit;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLIconTextFit:MGLIconTextFitBoth]];
+        layer.iconTextFit = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::IconTextFitType> propertyValue = { mbgl::style::IconTextFitType::Both };
+        XCTAssertEqual(rawLayer->getIconTextFit(), propertyValue,
+                       @"Setting iconTextFit to a constant value should update icon-text-fit.");
+        XCTAssertEqualObjects(layer.iconTextFit, styleValue,
+                              @"iconTextFit should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconTextFit = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::IconTextFitType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconTextFit(), propertyValue,
+                       @"Setting iconTextFit to a function should update icon-text-fit.");
+        XCTAssertEqualObjects(layer.iconTextFit, styleValue,
+                              @"iconTextFit should round-trip functions.");
+        
+        layer.iconTextFit = nil;
+        XCTAssertTrue(rawLayer->getIconTextFit().isUndefined(),
+                      @"Unsetting iconTextFit should return icon-text-fit to the default value.");
+        XCTAssertEqualObjects(layer.iconTextFit, defaultStyleValue,
+                              @"iconTextFit should return the default value after being unset.");
+    }
+    
+    // icon-text-fit-padding
+    {
+        XCTAssertTrue(rawLayer->getIconTextFitPadding().isUndefined(),
+                      @"icon-text-fit-padding should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconTextFitPadding;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithUIEdgeInsets:UIEdgeInsetsMake(1, 1, 1, 1)]
+#else
+            [NSValue valueWithEdgeInsets:NSEdgeInsetsMake(1, 1, 1, 1)]
+#endif
+        ];
+        layer.iconTextFitPadding = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 4>> propertyValue = { { 1, 1, 1, 1 } };
+        XCTAssertEqual(rawLayer->getIconTextFitPadding(), propertyValue,
+                       @"Setting iconTextFitPadding to a constant value should update icon-text-fit-padding.");
+        XCTAssertEqualObjects(layer.iconTextFitPadding, styleValue,
+                              @"iconTextFitPadding should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconTextFitPadding = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 4>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconTextFitPadding(), propertyValue,
+                       @"Setting iconTextFitPadding to a function should update icon-text-fit-padding.");
+        XCTAssertEqualObjects(layer.iconTextFitPadding, styleValue,
+                              @"iconTextFitPadding should round-trip functions.");
+        
+        layer.iconTextFitPadding = nil;
+        XCTAssertTrue(rawLayer->getIconTextFitPadding().isUndefined(),
+                      @"Unsetting iconTextFitPadding should return icon-text-fit-padding to the default value.");
+        XCTAssertEqualObjects(layer.iconTextFitPadding, defaultStyleValue,
+                              @"iconTextFitPadding should return the default value after being unset.");
+    }
+    
+    // icon-keep-upright
+    {
+        XCTAssertTrue(rawLayer->getIconKeepUpright().isUndefined(),
+                      @"icon-keep-upright should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.keepsIconUpright;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.keepsIconUpright = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getIconKeepUpright(), propertyValue,
+                       @"Setting keepsIconUpright to a constant value should update icon-keep-upright.");
+        XCTAssertEqualObjects(layer.keepsIconUpright, styleValue,
+                              @"keepsIconUpright should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.keepsIconUpright = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconKeepUpright(), propertyValue,
+                       @"Setting keepsIconUpright to a function should update icon-keep-upright.");
+        XCTAssertEqualObjects(layer.keepsIconUpright, styleValue,
+                              @"keepsIconUpright should round-trip functions.");
+        
+        layer.keepsIconUpright = nil;
+        XCTAssertTrue(rawLayer->getIconKeepUpright().isUndefined(),
+                      @"Unsetting keepsIconUpright should return icon-keep-upright to the default value.");
+        XCTAssertEqualObjects(layer.keepsIconUpright, defaultStyleValue,
+                              @"keepsIconUpright should return the default value after being unset.");
+    }
+    
+    // text-keep-upright
+    {
+        XCTAssertTrue(rawLayer->getTextKeepUpright().isUndefined(),
+                      @"text-keep-upright should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.keepsTextUpright;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@NO];
+        layer.keepsTextUpright = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { false };
+        XCTAssertEqual(rawLayer->getTextKeepUpright(), propertyValue,
+                       @"Setting keepsTextUpright to a constant value should update text-keep-upright.");
+        XCTAssertEqualObjects(layer.keepsTextUpright, styleValue,
+                              @"keepsTextUpright should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.keepsTextUpright = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextKeepUpright(), propertyValue,
+                       @"Setting keepsTextUpright to a function should update text-keep-upright.");
+        XCTAssertEqualObjects(layer.keepsTextUpright, styleValue,
+                              @"keepsTextUpright should round-trip functions.");
+        
+        layer.keepsTextUpright = nil;
+        XCTAssertTrue(rawLayer->getTextKeepUpright().isUndefined(),
+                      @"Unsetting keepsTextUpright should return text-keep-upright to the default value.");
+        XCTAssertEqualObjects(layer.keepsTextUpright, defaultStyleValue,
+                              @"keepsTextUpright should return the default value after being unset.");
+    }
+    
+    // text-max-angle
+    {
+        XCTAssertTrue(rawLayer->getTextMaxAngle().isUndefined(),
+                      @"text-max-angle should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.maximumTextAngle;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.maximumTextAngle = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextMaxAngle(), propertyValue,
+                       @"Setting maximumTextAngle to a constant value should update text-max-angle.");
+        XCTAssertEqualObjects(layer.maximumTextAngle, styleValue,
+                              @"maximumTextAngle should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.maximumTextAngle = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextMaxAngle(), propertyValue,
+                       @"Setting maximumTextAngle to a function should update text-max-angle.");
+        XCTAssertEqualObjects(layer.maximumTextAngle, styleValue,
+                              @"maximumTextAngle should round-trip functions.");
+        
+        layer.maximumTextAngle = nil;
+        XCTAssertTrue(rawLayer->getTextMaxAngle().isUndefined(),
+                      @"Unsetting maximumTextAngle should return text-max-angle to the default value.");
+        XCTAssertEqualObjects(layer.maximumTextAngle, defaultStyleValue,
+                              @"maximumTextAngle should return the default value after being unset.");
+    }
+    
+    // text-max-width
+    {
+        XCTAssertTrue(rawLayer->getTextMaxWidth().isUndefined(),
+                      @"text-max-width should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.maximumTextWidth;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.maximumTextWidth = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextMaxWidth(), propertyValue,
+                       @"Setting maximumTextWidth to a constant value should update text-max-width.");
+        XCTAssertEqualObjects(layer.maximumTextWidth, styleValue,
+                              @"maximumTextWidth should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.maximumTextWidth = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextMaxWidth(), propertyValue,
+                       @"Setting maximumTextWidth to a function should update text-max-width.");
+        XCTAssertEqualObjects(layer.maximumTextWidth, styleValue,
+                              @"maximumTextWidth should round-trip functions.");
+        
+        layer.maximumTextWidth = nil;
+        XCTAssertTrue(rawLayer->getTextMaxWidth().isUndefined(),
+                      @"Unsetting maximumTextWidth should return text-max-width to the default value.");
+        XCTAssertEqualObjects(layer.maximumTextWidth, defaultStyleValue,
+                              @"maximumTextWidth should return the default value after being unset.");
+    }
+    
+    // symbol-avoid-edges
+    {
+        XCTAssertTrue(rawLayer->getSymbolAvoidEdges().isUndefined(),
+                      @"symbol-avoid-edges should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.symbolAvoidsEdges;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.symbolAvoidsEdges = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getSymbolAvoidEdges(), propertyValue,
+                       @"Setting symbolAvoidsEdges to a constant value should update symbol-avoid-edges.");
+        XCTAssertEqualObjects(layer.symbolAvoidsEdges, styleValue,
+                              @"symbolAvoidsEdges should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.symbolAvoidsEdges = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getSymbolAvoidEdges(), propertyValue,
+                       @"Setting symbolAvoidsEdges to a function should update symbol-avoid-edges.");
+        XCTAssertEqualObjects(layer.symbolAvoidsEdges, styleValue,
+                              @"symbolAvoidsEdges should round-trip functions.");
+        
+        layer.symbolAvoidsEdges = nil;
+        XCTAssertTrue(rawLayer->getSymbolAvoidEdges().isUndefined(),
+                      @"Unsetting symbolAvoidsEdges should return symbol-avoid-edges to the default value.");
+        XCTAssertEqualObjects(layer.symbolAvoidsEdges, defaultStyleValue,
+                              @"symbolAvoidsEdges should return the default value after being unset.");
+    }
+    
+    // symbol-placement
+    {
+        XCTAssertTrue(rawLayer->getSymbolPlacement().isUndefined(),
+                      @"symbol-placement should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.symbolPlacement;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLSymbolPlacement:MGLSymbolPlacementLine]];
+        layer.symbolPlacement = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::SymbolPlacementType> propertyValue = { mbgl::style::SymbolPlacementType::Line };
+        XCTAssertEqual(rawLayer->getSymbolPlacement(), propertyValue,
+                       @"Setting symbolPlacement to a constant value should update symbol-placement.");
+        XCTAssertEqualObjects(layer.symbolPlacement, styleValue,
+                              @"symbolPlacement should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.symbolPlacement = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::SymbolPlacementType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getSymbolPlacement(), propertyValue,
+                       @"Setting symbolPlacement to a function should update symbol-placement.");
+        XCTAssertEqualObjects(layer.symbolPlacement, styleValue,
+                              @"symbolPlacement should round-trip functions.");
+        
+        layer.symbolPlacement = nil;
+        XCTAssertTrue(rawLayer->getSymbolPlacement().isUndefined(),
+                      @"Unsetting symbolPlacement should return symbol-placement to the default value.");
+        XCTAssertEqualObjects(layer.symbolPlacement, defaultStyleValue,
+                              @"symbolPlacement should return the default value after being unset.");
+    }
+    
+    // symbol-spacing
+    {
+        XCTAssertTrue(rawLayer->getSymbolSpacing().isUndefined(),
+                      @"symbol-spacing should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.symbolSpacing;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.symbolSpacing = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getSymbolSpacing(), propertyValue,
+                       @"Setting symbolSpacing to a constant value should update symbol-spacing.");
+        XCTAssertEqualObjects(layer.symbolSpacing, styleValue,
+                              @"symbolSpacing should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.symbolSpacing = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getSymbolSpacing(), propertyValue,
+                       @"Setting symbolSpacing to a function should update symbol-spacing.");
+        XCTAssertEqualObjects(layer.symbolSpacing, styleValue,
+                              @"symbolSpacing should round-trip functions.");
+        
+        layer.symbolSpacing = nil;
+        XCTAssertTrue(rawLayer->getSymbolSpacing().isUndefined(),
+                      @"Unsetting symbolSpacing should return symbol-spacing to the default value.");
+        XCTAssertEqualObjects(layer.symbolSpacing, defaultStyleValue,
+                              @"symbolSpacing should return the default value after being unset.");
+    }
+    
+    // text-field
+    {
+        XCTAssertTrue(rawLayer->getTextField().isUndefined(),
+                      @"text-field should be unset initially.");
+        MGLStyleValue<NSString *> *defaultStyleValue = layer.text;
+        
+        MGLStyleValue<NSString *> *styleValue = [MGLStyleValue<NSString *> valueWithRawValue:@"Text Field"];
+        layer.text = styleValue;
+        mbgl::style::PropertyValue<std::string> propertyValue = { "Text Field" };
+        XCTAssertEqual(rawLayer->getTextField(), propertyValue,
+                       @"Setting text to a constant value should update text-field.");
+        XCTAssertEqualObjects(layer.text, styleValue,
+                              @"text should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSString *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.text = styleValue;
+        propertyValue = { mbgl::style::Function<std::string> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextField(), propertyValue,
+                       @"Setting text to a function should update text-field.");
+        XCTAssertEqualObjects(layer.text, styleValue,
+                              @"text should round-trip functions.");
+        
+        layer.text = nil;
+        XCTAssertTrue(rawLayer->getTextField().isUndefined(),
+                      @"Unsetting text should return text-field to the default value.");
+        XCTAssertEqualObjects(layer.text, defaultStyleValue,
+                              @"text should return the default value after being unset.");
+    }
+    
+    // text-allow-overlap
+    {
+        XCTAssertTrue(rawLayer->getTextAllowOverlap().isUndefined(),
+                      @"text-allow-overlap should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textAllowsOverlap;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.textAllowsOverlap = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getTextAllowOverlap(), propertyValue,
+                       @"Setting textAllowsOverlap to a constant value should update text-allow-overlap.");
+        XCTAssertEqualObjects(layer.textAllowsOverlap, styleValue,
+                              @"textAllowsOverlap should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textAllowsOverlap = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextAllowOverlap(), propertyValue,
+                       @"Setting textAllowsOverlap to a function should update text-allow-overlap.");
+        XCTAssertEqualObjects(layer.textAllowsOverlap, styleValue,
+                              @"textAllowsOverlap should round-trip functions.");
+        
+        layer.textAllowsOverlap = nil;
+        XCTAssertTrue(rawLayer->getTextAllowOverlap().isUndefined(),
+                      @"Unsetting textAllowsOverlap should return text-allow-overlap to the default value.");
+        XCTAssertEqualObjects(layer.textAllowsOverlap, defaultStyleValue,
+                              @"textAllowsOverlap should return the default value after being unset.");
+    }
+    
+    // text-anchor
+    {
+        XCTAssertTrue(rawLayer->getTextAnchor().isUndefined(),
+                      @"text-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextAnchor:MGLTextAnchorBottomRight]];
+        layer.textAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TextAnchorType> propertyValue = { mbgl::style::TextAnchorType::BottomRight };
+        XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue,
+                       @"Setting textAnchor to a constant value should update text-anchor.");
+        XCTAssertEqualObjects(layer.textAnchor, styleValue,
+                              @"textAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TextAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue,
+                       @"Setting textAnchor to a function should update text-anchor.");
+        XCTAssertEqualObjects(layer.textAnchor, styleValue,
+                              @"textAnchor should round-trip functions.");
+        
+        layer.textAnchor = nil;
+        XCTAssertTrue(rawLayer->getTextAnchor().isUndefined(),
+                      @"Unsetting textAnchor should return text-anchor to the default value.");
+        XCTAssertEqualObjects(layer.textAnchor, defaultStyleValue,
+                              @"textAnchor should return the default value after being unset.");
+    }
+    
+    // text-font
+    {
+        XCTAssertTrue(rawLayer->getTextFont().isUndefined(),
+                      @"text-font should be unset initially.");
+        MGLStyleValue<NSArray<NSString *> *> *defaultStyleValue = layer.textFontNames;
+        
+        MGLStyleValue<NSArray<NSString *> *> *styleValue = [MGLStyleValue<NSArray<NSString *> *> valueWithRawValue:@[@"Text Font", @"Tnof Txet"]];
+        layer.textFontNames = styleValue;
+        mbgl::style::PropertyValue<std::vector<std::string>> propertyValue = { { "Text Font", "Tnof Txet" } };
+        XCTAssertEqual(rawLayer->getTextFont(), propertyValue,
+                       @"Setting textFontNames to a constant value should update text-font.");
+        XCTAssertEqualObjects(layer.textFontNames, styleValue,
+                              @"textFontNames should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSArray<NSString *> *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textFontNames = styleValue;
+        propertyValue = { mbgl::style::Function<std::vector<std::string>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextFont(), propertyValue,
+                       @"Setting textFontNames to a function should update text-font.");
+        XCTAssertEqualObjects(layer.textFontNames, styleValue,
+                              @"textFontNames should round-trip functions.");
+        
+        layer.textFontNames = nil;
+        XCTAssertTrue(rawLayer->getTextFont().isUndefined(),
+                      @"Unsetting textFontNames should return text-font to the default value.");
+        XCTAssertEqualObjects(layer.textFontNames, defaultStyleValue,
+                              @"textFontNames should return the default value after being unset.");
+    }
+    
+    // text-size
+    {
+        XCTAssertTrue(rawLayer->getTextSize().isUndefined(),
+                      @"text-size should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textFontSize;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textFontSize = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextSize(), propertyValue,
+                       @"Setting textFontSize to a constant value should update text-size.");
+        XCTAssertEqualObjects(layer.textFontSize, styleValue,
+                              @"textFontSize should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textFontSize = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextSize(), propertyValue,
+                       @"Setting textFontSize to a function should update text-size.");
+        XCTAssertEqualObjects(layer.textFontSize, styleValue,
+                              @"textFontSize should round-trip functions.");
+        
+        layer.textFontSize = nil;
+        XCTAssertTrue(rawLayer->getTextSize().isUndefined(),
+                      @"Unsetting textFontSize should return text-size to the default value.");
+        XCTAssertEqualObjects(layer.textFontSize, defaultStyleValue,
+                              @"textFontSize should return the default value after being unset.");
+    }
+    
+    // text-ignore-placement
+    {
+        XCTAssertTrue(rawLayer->getTextIgnorePlacement().isUndefined(),
+                      @"text-ignore-placement should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textIgnoresPlacement;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.textIgnoresPlacement = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getTextIgnorePlacement(), propertyValue,
+                       @"Setting textIgnoresPlacement to a constant value should update text-ignore-placement.");
+        XCTAssertEqualObjects(layer.textIgnoresPlacement, styleValue,
+                              @"textIgnoresPlacement should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textIgnoresPlacement = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextIgnorePlacement(), propertyValue,
+                       @"Setting textIgnoresPlacement to a function should update text-ignore-placement.");
+        XCTAssertEqualObjects(layer.textIgnoresPlacement, styleValue,
+                              @"textIgnoresPlacement should round-trip functions.");
+        
+        layer.textIgnoresPlacement = nil;
+        XCTAssertTrue(rawLayer->getTextIgnorePlacement().isUndefined(),
+                      @"Unsetting textIgnoresPlacement should return text-ignore-placement to the default value.");
+        XCTAssertEqualObjects(layer.textIgnoresPlacement, defaultStyleValue,
+                              @"textIgnoresPlacement should return the default value after being unset.");
+    }
+    
+    // text-justify
+    {
+        XCTAssertTrue(rawLayer->getTextJustify().isUndefined(),
+                      @"text-justify should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textJustification;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextJustification:MGLTextJustificationRight]];
+        layer.textJustification = styleValue;
+        mbgl::style::PropertyValue<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, styleValue,
+                              @"textJustification should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textJustification = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TextJustifyType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextJustify(), propertyValue,
+                       @"Setting textJustification to a function should update text-justify.");
+        XCTAssertEqualObjects(layer.textJustification, styleValue,
+                              @"textJustification should round-trip functions.");
+        
+        layer.textJustification = nil;
+        XCTAssertTrue(rawLayer->getTextJustify().isUndefined(),
+                      @"Unsetting textJustification should return text-justify to the default value.");
+        XCTAssertEqualObjects(layer.textJustification, defaultStyleValue,
+                              @"textJustification should return the default value after being unset.");
+    }
+    
+    // text-letter-spacing
+    {
+        XCTAssertTrue(rawLayer->getTextLetterSpacing().isUndefined(),
+                      @"text-letter-spacing should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textLetterSpacing;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textLetterSpacing = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextLetterSpacing(), propertyValue,
+                       @"Setting textLetterSpacing to a constant value should update text-letter-spacing.");
+        XCTAssertEqualObjects(layer.textLetterSpacing, styleValue,
+                              @"textLetterSpacing should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textLetterSpacing = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextLetterSpacing(), propertyValue,
+                       @"Setting textLetterSpacing to a function should update text-letter-spacing.");
+        XCTAssertEqualObjects(layer.textLetterSpacing, styleValue,
+                              @"textLetterSpacing should round-trip functions.");
+        
+        layer.textLetterSpacing = nil;
+        XCTAssertTrue(rawLayer->getTextLetterSpacing().isUndefined(),
+                      @"Unsetting textLetterSpacing should return text-letter-spacing to the default value.");
+        XCTAssertEqualObjects(layer.textLetterSpacing, defaultStyleValue,
+                              @"textLetterSpacing should return the default value after being unset.");
+    }
+    
+    // text-line-height
+    {
+        XCTAssertTrue(rawLayer->getTextLineHeight().isUndefined(),
+                      @"text-line-height should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textLineHeight;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textLineHeight = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextLineHeight(), propertyValue,
+                       @"Setting textLineHeight to a constant value should update text-line-height.");
+        XCTAssertEqualObjects(layer.textLineHeight, styleValue,
+                              @"textLineHeight should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textLineHeight = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextLineHeight(), propertyValue,
+                       @"Setting textLineHeight to a function should update text-line-height.");
+        XCTAssertEqualObjects(layer.textLineHeight, styleValue,
+                              @"textLineHeight should round-trip functions.");
+        
+        layer.textLineHeight = nil;
+        XCTAssertTrue(rawLayer->getTextLineHeight().isUndefined(),
+                      @"Unsetting textLineHeight should return text-line-height to the default value.");
+        XCTAssertEqualObjects(layer.textLineHeight, defaultStyleValue,
+                              @"textLineHeight should return the default value after being unset.");
+    }
+    
+    // text-offset
+    {
+        XCTAssertTrue(rawLayer->getTextOffset().isUndefined(),
+                      @"text-offset should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textOffset;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.textOffset = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getTextOffset(), propertyValue,
+                       @"Setting textOffset to a constant value should update text-offset.");
+        XCTAssertEqualObjects(layer.textOffset, styleValue,
+                              @"textOffset should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textOffset = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextOffset(), propertyValue,
+                       @"Setting textOffset to a function should update text-offset.");
+        XCTAssertEqualObjects(layer.textOffset, styleValue,
+                              @"textOffset should round-trip functions.");
+        
+        layer.textOffset = nil;
+        XCTAssertTrue(rawLayer->getTextOffset().isUndefined(),
+                      @"Unsetting textOffset should return text-offset to the default value.");
+        XCTAssertEqualObjects(layer.textOffset, defaultStyleValue,
+                              @"textOffset should return the default value after being unset.");
+    }
+    
+    // text-optional
+    {
+        XCTAssertTrue(rawLayer->getTextOptional().isUndefined(),
+                      @"text-optional should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textOptional;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@YES];
+        layer.textOptional = styleValue;
+        mbgl::style::PropertyValue<bool> propertyValue = { true };
+        XCTAssertEqual(rawLayer->getTextOptional(), propertyValue,
+                       @"Setting textOptional to a constant value should update text-optional.");
+        XCTAssertEqualObjects(layer.textOptional, styleValue,
+                              @"textOptional should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textOptional = styleValue;
+        propertyValue = { mbgl::style::Function<bool> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextOptional(), propertyValue,
+                       @"Setting textOptional to a function should update text-optional.");
+        XCTAssertEqualObjects(layer.textOptional, styleValue,
+                              @"textOptional should round-trip functions.");
+        
+        layer.textOptional = nil;
+        XCTAssertTrue(rawLayer->getTextOptional().isUndefined(),
+                      @"Unsetting textOptional should return text-optional to the default value.");
+        XCTAssertEqualObjects(layer.textOptional, defaultStyleValue,
+                              @"textOptional should return the default value after being unset.");
+    }
+    
+    // text-padding
+    {
+        XCTAssertTrue(rawLayer->getTextPadding().isUndefined(),
+                      @"text-padding should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textPadding;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textPadding = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextPadding(), propertyValue,
+                       @"Setting textPadding to a constant value should update text-padding.");
+        XCTAssertEqualObjects(layer.textPadding, styleValue,
+                              @"textPadding should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textPadding = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextPadding(), propertyValue,
+                       @"Setting textPadding to a function should update text-padding.");
+        XCTAssertEqualObjects(layer.textPadding, styleValue,
+                              @"textPadding should round-trip functions.");
+        
+        layer.textPadding = nil;
+        XCTAssertTrue(rawLayer->getTextPadding().isUndefined(),
+                      @"Unsetting textPadding should return text-padding to the default value.");
+        XCTAssertEqualObjects(layer.textPadding, defaultStyleValue,
+                              @"textPadding should return the default value after being unset.");
+    }
+    
+    // text-pitch-alignment
+    {
+        XCTAssertTrue(rawLayer->getTextPitchAlignment().isUndefined(),
+                      @"text-pitch-alignment should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textPitchAlignment;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextPitchAlignment:MGLTextPitchAlignmentAuto]];
+        layer.textPitchAlignment = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::AlignmentType> propertyValue = { mbgl::style::AlignmentType::Auto };
+        XCTAssertEqual(rawLayer->getTextPitchAlignment(), propertyValue,
+                       @"Setting textPitchAlignment to a constant value should update text-pitch-alignment.");
+        XCTAssertEqualObjects(layer.textPitchAlignment, styleValue,
+                              @"textPitchAlignment should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textPitchAlignment = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::AlignmentType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextPitchAlignment(), propertyValue,
+                       @"Setting textPitchAlignment to a function should update text-pitch-alignment.");
+        XCTAssertEqualObjects(layer.textPitchAlignment, styleValue,
+                              @"textPitchAlignment should round-trip functions.");
+        
+        layer.textPitchAlignment = nil;
+        XCTAssertTrue(rawLayer->getTextPitchAlignment().isUndefined(),
+                      @"Unsetting textPitchAlignment should return text-pitch-alignment to the default value.");
+        XCTAssertEqualObjects(layer.textPitchAlignment, defaultStyleValue,
+                              @"textPitchAlignment should return the default value after being unset.");
+    }
+    
+    // text-rotate
+    {
+        XCTAssertTrue(rawLayer->getTextRotate().isUndefined(),
+                      @"text-rotate should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textRotation;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textRotation = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextRotate(), propertyValue,
+                       @"Setting textRotation to a constant value should update text-rotate.");
+        XCTAssertEqualObjects(layer.textRotation, styleValue,
+                              @"textRotation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textRotation = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextRotate(), propertyValue,
+                       @"Setting textRotation to a function should update text-rotate.");
+        XCTAssertEqualObjects(layer.textRotation, styleValue,
+                              @"textRotation should round-trip functions.");
+        
+        layer.textRotation = nil;
+        XCTAssertTrue(rawLayer->getTextRotate().isUndefined(),
+                      @"Unsetting textRotation should return text-rotate to the default value.");
+        XCTAssertEqualObjects(layer.textRotation, defaultStyleValue,
+                              @"textRotation should return the default value after being unset.");
+    }
+    
+    // text-rotation-alignment
+    {
+        XCTAssertTrue(rawLayer->getTextRotationAlignment().isUndefined(),
+                      @"text-rotation-alignment should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textRotationAlignment;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextRotationAlignment:MGLTextRotationAlignmentAuto]];
+        layer.textRotationAlignment = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::AlignmentType> propertyValue = { mbgl::style::AlignmentType::Auto };
+        XCTAssertEqual(rawLayer->getTextRotationAlignment(), propertyValue,
+                       @"Setting textRotationAlignment to a constant value should update text-rotation-alignment.");
+        XCTAssertEqualObjects(layer.textRotationAlignment, styleValue,
+                              @"textRotationAlignment should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textRotationAlignment = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::AlignmentType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextRotationAlignment(), propertyValue,
+                       @"Setting textRotationAlignment to a function should update text-rotation-alignment.");
+        XCTAssertEqualObjects(layer.textRotationAlignment, styleValue,
+                              @"textRotationAlignment should round-trip functions.");
+        
+        layer.textRotationAlignment = nil;
+        XCTAssertTrue(rawLayer->getTextRotationAlignment().isUndefined(),
+                      @"Unsetting textRotationAlignment should return text-rotation-alignment to the default value.");
+        XCTAssertEqualObjects(layer.textRotationAlignment, defaultStyleValue,
+                              @"textRotationAlignment should return the default value after being unset.");
+    }
+    
+    // text-transform
+    {
+        XCTAssertTrue(rawLayer->getTextTransform().isUndefined(),
+                      @"text-transform should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textTransform;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextTransform:MGLTextTransformLowercase]];
+        layer.textTransform = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TextTransformType> propertyValue = { mbgl::style::TextTransformType::Lowercase };
+        XCTAssertEqual(rawLayer->getTextTransform(), propertyValue,
+                       @"Setting textTransform to a constant value should update text-transform.");
+        XCTAssertEqualObjects(layer.textTransform, styleValue,
+                              @"textTransform should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textTransform = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TextTransformType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextTransform(), propertyValue,
+                       @"Setting textTransform to a function should update text-transform.");
+        XCTAssertEqualObjects(layer.textTransform, styleValue,
+                              @"textTransform should round-trip functions.");
+        
+        layer.textTransform = nil;
+        XCTAssertTrue(rawLayer->getTextTransform().isUndefined(),
+                      @"Unsetting textTransform should return text-transform to the default value.");
+        XCTAssertEqualObjects(layer.textTransform, defaultStyleValue,
+                              @"textTransform should return the default value after being unset.");
+    }
+    
+    // icon-color
+    {
+        XCTAssertTrue(rawLayer->getIconColor().isUndefined(),
+                      @"icon-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.iconColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.iconColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getIconColor(), propertyValue,
+                       @"Setting iconColor to a constant value should update icon-color.");
+        XCTAssertEqualObjects(layer.iconColor, styleValue,
+                              @"iconColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconColor(), propertyValue,
+                       @"Setting iconColor to a function should update icon-color.");
+        XCTAssertEqualObjects(layer.iconColor, styleValue,
+                              @"iconColor should round-trip functions.");
+        
+        layer.iconColor = nil;
+        XCTAssertTrue(rawLayer->getIconColor().isUndefined(),
+                      @"Unsetting iconColor should return icon-color to the default value.");
+        XCTAssertEqualObjects(layer.iconColor, defaultStyleValue,
+                              @"iconColor should return the default value after being unset.");
+    }
+    
+    // icon-halo-blur
+    {
+        XCTAssertTrue(rawLayer->getIconHaloBlur().isUndefined(),
+                      @"icon-halo-blur should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconHaloBlur;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconHaloBlur = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconHaloBlur(), propertyValue,
+                       @"Setting iconHaloBlur to a constant value should update icon-halo-blur.");
+        XCTAssertEqualObjects(layer.iconHaloBlur, styleValue,
+                              @"iconHaloBlur should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconHaloBlur = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconHaloBlur(), propertyValue,
+                       @"Setting iconHaloBlur to a function should update icon-halo-blur.");
+        XCTAssertEqualObjects(layer.iconHaloBlur, styleValue,
+                              @"iconHaloBlur should round-trip functions.");
+        
+        layer.iconHaloBlur = nil;
+        XCTAssertTrue(rawLayer->getIconHaloBlur().isUndefined(),
+                      @"Unsetting iconHaloBlur should return icon-halo-blur to the default value.");
+        XCTAssertEqualObjects(layer.iconHaloBlur, defaultStyleValue,
+                              @"iconHaloBlur should return the default value after being unset.");
+    }
+    
+    // icon-halo-color
+    {
+        XCTAssertTrue(rawLayer->getIconHaloColor().isUndefined(),
+                      @"icon-halo-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.iconHaloColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.iconHaloColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getIconHaloColor(), propertyValue,
+                       @"Setting iconHaloColor to a constant value should update icon-halo-color.");
+        XCTAssertEqualObjects(layer.iconHaloColor, styleValue,
+                              @"iconHaloColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconHaloColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconHaloColor(), propertyValue,
+                       @"Setting iconHaloColor to a function should update icon-halo-color.");
+        XCTAssertEqualObjects(layer.iconHaloColor, styleValue,
+                              @"iconHaloColor should round-trip functions.");
+        
+        layer.iconHaloColor = nil;
+        XCTAssertTrue(rawLayer->getIconHaloColor().isUndefined(),
+                      @"Unsetting iconHaloColor should return icon-halo-color to the default value.");
+        XCTAssertEqualObjects(layer.iconHaloColor, defaultStyleValue,
+                              @"iconHaloColor should return the default value after being unset.");
+    }
+    
+    // icon-halo-width
+    {
+        XCTAssertTrue(rawLayer->getIconHaloWidth().isUndefined(),
+                      @"icon-halo-width should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconHaloWidth;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconHaloWidth = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconHaloWidth(), propertyValue,
+                       @"Setting iconHaloWidth to a constant value should update icon-halo-width.");
+        XCTAssertEqualObjects(layer.iconHaloWidth, styleValue,
+                              @"iconHaloWidth should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconHaloWidth = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconHaloWidth(), propertyValue,
+                       @"Setting iconHaloWidth to a function should update icon-halo-width.");
+        XCTAssertEqualObjects(layer.iconHaloWidth, styleValue,
+                              @"iconHaloWidth should round-trip functions.");
+        
+        layer.iconHaloWidth = nil;
+        XCTAssertTrue(rawLayer->getIconHaloWidth().isUndefined(),
+                      @"Unsetting iconHaloWidth should return icon-halo-width to the default value.");
+        XCTAssertEqualObjects(layer.iconHaloWidth, defaultStyleValue,
+                              @"iconHaloWidth should return the default value after being unset.");
+    }
+    
+    // icon-opacity
+    {
+        XCTAssertTrue(rawLayer->getIconOpacity().isUndefined(),
+                      @"icon-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.iconOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.iconOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getIconOpacity(), propertyValue,
+                       @"Setting iconOpacity to a constant value should update icon-opacity.");
+        XCTAssertEqualObjects(layer.iconOpacity, styleValue,
+                              @"iconOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconOpacity(), propertyValue,
+                       @"Setting iconOpacity to a function should update icon-opacity.");
+        XCTAssertEqualObjects(layer.iconOpacity, styleValue,
+                              @"iconOpacity should round-trip functions.");
+        
+        layer.iconOpacity = nil;
+        XCTAssertTrue(rawLayer->getIconOpacity().isUndefined(),
+                      @"Unsetting iconOpacity should return icon-opacity to the default value.");
+        XCTAssertEqualObjects(layer.iconOpacity, defaultStyleValue,
+                              @"iconOpacity should return the default value after being unset.");
+    }
+    
+    // icon-translate
+    {
+        XCTAssertTrue(rawLayer->getIconTranslate().isUndefined(),
+                      @"icon-translate should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconTranslation;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.iconTranslation = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getIconTranslate(), propertyValue,
+                       @"Setting iconTranslation to a constant value should update icon-translate.");
+        XCTAssertEqualObjects(layer.iconTranslation, styleValue,
+                              @"iconTranslation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconTranslation = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconTranslate(), propertyValue,
+                       @"Setting iconTranslation to a function should update icon-translate.");
+        XCTAssertEqualObjects(layer.iconTranslation, styleValue,
+                              @"iconTranslation should round-trip functions.");
+        
+        layer.iconTranslation = nil;
+        XCTAssertTrue(rawLayer->getIconTranslate().isUndefined(),
+                      @"Unsetting iconTranslation should return icon-translate to the default value.");
+        XCTAssertEqualObjects(layer.iconTranslation, defaultStyleValue,
+                              @"iconTranslation should return the default value after being unset.");
+    }
+    
+    // icon-translate-anchor
+    {
+        XCTAssertTrue(rawLayer->getIconTranslateAnchor().isUndefined(),
+                      @"icon-translate-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.iconTranslationAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLIconTranslationAnchor:MGLIconTranslationAnchorViewport]];
+        layer.iconTranslationAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TranslateAnchorType> propertyValue = { mbgl::style::TranslateAnchorType::Viewport };
+        XCTAssertEqual(rawLayer->getIconTranslateAnchor(), propertyValue,
+                       @"Setting iconTranslationAnchor to a constant value should update icon-translate-anchor.");
+        XCTAssertEqualObjects(layer.iconTranslationAnchor, styleValue,
+                              @"iconTranslationAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.iconTranslationAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TranslateAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getIconTranslateAnchor(), propertyValue,
+                       @"Setting iconTranslationAnchor to a function should update icon-translate-anchor.");
+        XCTAssertEqualObjects(layer.iconTranslationAnchor, styleValue,
+                              @"iconTranslationAnchor should round-trip functions.");
+        
+        layer.iconTranslationAnchor = nil;
+        XCTAssertTrue(rawLayer->getIconTranslateAnchor().isUndefined(),
+                      @"Unsetting iconTranslationAnchor should return icon-translate-anchor to the default value.");
+        XCTAssertEqualObjects(layer.iconTranslationAnchor, defaultStyleValue,
+                              @"iconTranslationAnchor should return the default value after being unset.");
+    }
+    
+    // text-color
+    {
+        XCTAssertTrue(rawLayer->getTextColor().isUndefined(),
+                      @"text-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.textColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.textColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getTextColor(), propertyValue,
+                       @"Setting textColor to a constant value should update text-color.");
+        XCTAssertEqualObjects(layer.textColor, styleValue,
+                              @"textColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextColor(), propertyValue,
+                       @"Setting textColor to a function should update text-color.");
+        XCTAssertEqualObjects(layer.textColor, styleValue,
+                              @"textColor should round-trip functions.");
+        
+        layer.textColor = nil;
+        XCTAssertTrue(rawLayer->getTextColor().isUndefined(),
+                      @"Unsetting textColor should return text-color to the default value.");
+        XCTAssertEqualObjects(layer.textColor, defaultStyleValue,
+                              @"textColor should return the default value after being unset.");
+    }
+    
+    // text-halo-blur
+    {
+        XCTAssertTrue(rawLayer->getTextHaloBlur().isUndefined(),
+                      @"text-halo-blur should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textHaloBlur;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textHaloBlur = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextHaloBlur(), propertyValue,
+                       @"Setting textHaloBlur to a constant value should update text-halo-blur.");
+        XCTAssertEqualObjects(layer.textHaloBlur, styleValue,
+                              @"textHaloBlur should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textHaloBlur = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextHaloBlur(), propertyValue,
+                       @"Setting textHaloBlur to a function should update text-halo-blur.");
+        XCTAssertEqualObjects(layer.textHaloBlur, styleValue,
+                              @"textHaloBlur should round-trip functions.");
+        
+        layer.textHaloBlur = nil;
+        XCTAssertTrue(rawLayer->getTextHaloBlur().isUndefined(),
+                      @"Unsetting textHaloBlur should return text-halo-blur to the default value.");
+        XCTAssertEqualObjects(layer.textHaloBlur, defaultStyleValue,
+                              @"textHaloBlur should return the default value after being unset.");
+    }
+    
+    // text-halo-color
+    {
+        XCTAssertTrue(rawLayer->getTextHaloColor().isUndefined(),
+                      @"text-halo-color should be unset initially.");
+        MGLStyleValue<MGLColor *> *defaultStyleValue = layer.textHaloColor;
+        
+        MGLStyleValue<MGLColor *> *styleValue = [MGLStyleValue<MGLColor *> valueWithRawValue:[MGLColor redColor]];
+        layer.textHaloColor = styleValue;
+        mbgl::style::PropertyValue<mbgl::Color> propertyValue = { { .r = 1, .g = 0, .b = 0, .a = 1 } };
+        XCTAssertEqual(rawLayer->getTextHaloColor(), propertyValue,
+                       @"Setting textHaloColor to a constant value should update text-halo-color.");
+        XCTAssertEqualObjects(layer.textHaloColor, styleValue,
+                              @"textHaloColor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<MGLColor *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textHaloColor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::Color> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextHaloColor(), propertyValue,
+                       @"Setting textHaloColor to a function should update text-halo-color.");
+        XCTAssertEqualObjects(layer.textHaloColor, styleValue,
+                              @"textHaloColor should round-trip functions.");
+        
+        layer.textHaloColor = nil;
+        XCTAssertTrue(rawLayer->getTextHaloColor().isUndefined(),
+                      @"Unsetting textHaloColor should return text-halo-color to the default value.");
+        XCTAssertEqualObjects(layer.textHaloColor, defaultStyleValue,
+                              @"textHaloColor should return the default value after being unset.");
+    }
+    
+    // text-halo-width
+    {
+        XCTAssertTrue(rawLayer->getTextHaloWidth().isUndefined(),
+                      @"text-halo-width should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textHaloWidth;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textHaloWidth = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextHaloWidth(), propertyValue,
+                       @"Setting textHaloWidth to a constant value should update text-halo-width.");
+        XCTAssertEqualObjects(layer.textHaloWidth, styleValue,
+                              @"textHaloWidth should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textHaloWidth = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextHaloWidth(), propertyValue,
+                       @"Setting textHaloWidth to a function should update text-halo-width.");
+        XCTAssertEqualObjects(layer.textHaloWidth, styleValue,
+                              @"textHaloWidth should round-trip functions.");
+        
+        layer.textHaloWidth = nil;
+        XCTAssertTrue(rawLayer->getTextHaloWidth().isUndefined(),
+                      @"Unsetting textHaloWidth should return text-halo-width to the default value.");
+        XCTAssertEqualObjects(layer.textHaloWidth, defaultStyleValue,
+                              @"textHaloWidth should return the default value after being unset.");
+    }
+    
+    // text-opacity
+    {
+        XCTAssertTrue(rawLayer->getTextOpacity().isUndefined(),
+                      @"text-opacity should be unset initially.");
+        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.textOpacity;
+        
+        MGLStyleValue<NSNumber *> *styleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
+        layer.textOpacity = styleValue;
+        mbgl::style::PropertyValue<float> propertyValue = { 0xff };
+        XCTAssertEqual(rawLayer->getTextOpacity(), propertyValue,
+                       @"Setting textOpacity to a constant value should update text-opacity.");
+        XCTAssertEqualObjects(layer.textOpacity, styleValue,
+                              @"textOpacity should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSNumber *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textOpacity = styleValue;
+        propertyValue = { mbgl::style::Function<float> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextOpacity(), propertyValue,
+                       @"Setting textOpacity to a function should update text-opacity.");
+        XCTAssertEqualObjects(layer.textOpacity, styleValue,
+                              @"textOpacity should round-trip functions.");
+        
+        layer.textOpacity = nil;
+        XCTAssertTrue(rawLayer->getTextOpacity().isUndefined(),
+                      @"Unsetting textOpacity should return text-opacity to the default value.");
+        XCTAssertEqualObjects(layer.textOpacity, defaultStyleValue,
+                              @"textOpacity should return the default value after being unset.");
+    }
+    
+    // text-translate
+    {
+        XCTAssertTrue(rawLayer->getTextTranslate().isUndefined(),
+                      @"text-translate should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textTranslation;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:
+#if TARGET_OS_IPHONE
+            [NSValue valueWithCGVector:CGVectorMake(1, 1)]
+#else
+            [NSValue valueWithMGLVector:CGVectorMake(1, -1)]
+#endif
+        ];
+        layer.textTranslation = styleValue;
+        mbgl::style::PropertyValue<std::array<float, 2>> propertyValue = { { 1, 1 } };
+        XCTAssertEqual(rawLayer->getTextTranslate(), propertyValue,
+                       @"Setting textTranslation to a constant value should update text-translate.");
+        XCTAssertEqualObjects(layer.textTranslation, styleValue,
+                              @"textTranslation should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textTranslation = styleValue;
+        propertyValue = { mbgl::style::Function<std::array<float, 2>> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextTranslate(), propertyValue,
+                       @"Setting textTranslation to a function should update text-translate.");
+        XCTAssertEqualObjects(layer.textTranslation, styleValue,
+                              @"textTranslation should round-trip functions.");
+        
+        layer.textTranslation = nil;
+        XCTAssertTrue(rawLayer->getTextTranslate().isUndefined(),
+                      @"Unsetting textTranslation should return text-translate to the default value.");
+        XCTAssertEqualObjects(layer.textTranslation, defaultStyleValue,
+                              @"textTranslation should return the default value after being unset.");
+    }
+    
+    // text-translate-anchor
+    {
+        XCTAssertTrue(rawLayer->getTextTranslateAnchor().isUndefined(),
+                      @"text-translate-anchor should be unset initially.");
+        MGLStyleValue<NSValue *> *defaultStyleValue = layer.textTranslationAnchor;
+        
+        MGLStyleValue<NSValue *> *styleValue = [MGLStyleValue<NSValue *> valueWithRawValue:[NSValue valueWithMGLTextTranslationAnchor:MGLTextTranslationAnchorViewport]];
+        layer.textTranslationAnchor = styleValue;
+        mbgl::style::PropertyValue<mbgl::style::TranslateAnchorType> propertyValue = { mbgl::style::TranslateAnchorType::Viewport };
+        XCTAssertEqual(rawLayer->getTextTranslateAnchor(), propertyValue,
+                       @"Setting textTranslationAnchor to a constant value should update text-translate-anchor.");
+        XCTAssertEqualObjects(layer.textTranslationAnchor, styleValue,
+                              @"textTranslationAnchor should round-trip constant values.");
+        
+        styleValue = [MGLStyleValue<NSValue *> valueWithStops:@{
+            @18: styleValue,
+        }];
+        layer.textTranslationAnchor = styleValue;
+        propertyValue = { mbgl::style::Function<mbgl::style::TranslateAnchorType> {
+            {{ 18, propertyValue.asConstant() }},
+            1,
+        }};
+        XCTAssertEqual(rawLayer->getTextTranslateAnchor(), propertyValue,
+                       @"Setting textTranslationAnchor to a function should update text-translate-anchor.");
+        XCTAssertEqualObjects(layer.textTranslationAnchor, styleValue,
+                              @"textTranslationAnchor should round-trip functions.");
+        
+        layer.textTranslationAnchor = nil;
+        XCTAssertTrue(rawLayer->getTextTranslateAnchor().isUndefined(),
+                      @"Unsetting textTranslationAnchor should return text-translate-anchor to the default value.");
+        XCTAssertEqualObjects(layer.textTranslationAnchor, defaultStyleValue,
+                              @"textTranslationAnchor should return the default value after being unset.");
+    }
+}
+
+- (void)testPropertyNames {
+    [self testPropertyName:@"icon-allows-overlap" isBoolean:YES];
+    [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-rotation" isBoolean:NO];
+    [self testPropertyName:@"icon-rotation-alignment" isBoolean:NO];
+    [self testPropertyName:@"icon-scale" isBoolean:NO];
+    [self testPropertyName:@"icon-text-fit" isBoolean:NO];
+    [self testPropertyName:@"icon-text-fit-padding" isBoolean:NO];
+    [self testPropertyName:@"keeps-icon-upright" isBoolean:YES];
+    [self testPropertyName:@"keeps-text-upright" isBoolean:YES];
+    [self testPropertyName:@"maximum-text-angle" isBoolean:NO];
+    [self testPropertyName:@"maximum-text-width" isBoolean:NO];
+    [self testPropertyName:@"symbol-avoids-edges" isBoolean:YES];
+    [self testPropertyName:@"symbol-placement" isBoolean:NO];
+    [self testPropertyName:@"symbol-spacing" isBoolean:NO];
+    [self testPropertyName:@"text" isBoolean:NO];
+    [self testPropertyName:@"text-allows-overlap" isBoolean:YES];
+    [self testPropertyName:@"text-anchor" isBoolean:NO];
+    [self testPropertyName:@"text-font-names" isBoolean:NO];
+    [self testPropertyName:@"text-font-size" isBoolean:NO];
+    [self testPropertyName:@"text-ignores-placement" isBoolean:YES];
+    [self testPropertyName:@"text-justification" isBoolean:NO];
+    [self testPropertyName:@"text-letter-spacing" isBoolean:NO];
+    [self testPropertyName:@"text-line-height" isBoolean:NO];
+    [self testPropertyName:@"text-offset" isBoolean:NO];
+    [self testPropertyName:@"is-text-optional" isBoolean:YES];
+    [self testPropertyName:@"text-padding" isBoolean:NO];
+    [self testPropertyName:@"text-pitch-alignment" isBoolean:NO];
+    [self testPropertyName:@"text-rotation" isBoolean:NO];
+    [self testPropertyName:@"text-rotation-alignment" isBoolean:NO];
+    [self testPropertyName:@"text-transform" isBoolean:NO];
+    [self testPropertyName:@"icon-color" isBoolean:NO];
+    [self testPropertyName:@"icon-halo-blur" isBoolean:NO];
+    [self testPropertyName:@"icon-halo-color" isBoolean:NO];
+    [self testPropertyName:@"icon-halo-width" isBoolean:NO];
+    [self testPropertyName:@"icon-opacity" isBoolean:NO];
+    [self testPropertyName:@"icon-translation" isBoolean:NO];
+    [self testPropertyName:@"icon-translation-anchor" isBoolean:NO];
+    [self testPropertyName:@"text-color" isBoolean:NO];
+    [self testPropertyName:@"text-halo-blur" isBoolean:NO];
+    [self testPropertyName:@"text-halo-color" isBoolean:NO];
+    [self testPropertyName:@"text-halo-width" isBoolean:NO];
+    [self testPropertyName:@"text-opacity" isBoolean:NO];
+    [self testPropertyName:@"text-translation" isBoolean:NO];
+    [self testPropertyName:@"text-translation-anchor" isBoolean:NO];
+}
+
+- (void)testValueAdditions {
+    XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentMap].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentViewport].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentViewport);
+    XCTAssertEqual([NSValue valueWithMGLIconRotationAlignment:MGLIconRotationAlignmentAuto].MGLIconRotationAlignmentValue, MGLIconRotationAlignmentAuto);
+    XCTAssertEqual([NSValue valueWithMGLIconTextFit:MGLIconTextFitNone].MGLIconTextFitValue, MGLIconTextFitNone);
+    XCTAssertEqual([NSValue valueWithMGLIconTextFit:MGLIconTextFitWidth].MGLIconTextFitValue, MGLIconTextFitWidth);
+    XCTAssertEqual([NSValue valueWithMGLIconTextFit:MGLIconTextFitHeight].MGLIconTextFitValue, MGLIconTextFitHeight);
+    XCTAssertEqual([NSValue valueWithMGLIconTextFit:MGLIconTextFitBoth].MGLIconTextFitValue, MGLIconTextFitBoth);
+    XCTAssertEqual([NSValue valueWithMGLSymbolPlacement:MGLSymbolPlacementPoint].MGLSymbolPlacementValue, MGLSymbolPlacementPoint);
+    XCTAssertEqual([NSValue valueWithMGLSymbolPlacement:MGLSymbolPlacementLine].MGLSymbolPlacementValue, MGLSymbolPlacementLine);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorCenter].MGLTextAnchorValue, MGLTextAnchorCenter);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorLeft].MGLTextAnchorValue, MGLTextAnchorLeft);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorRight].MGLTextAnchorValue, MGLTextAnchorRight);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorTop].MGLTextAnchorValue, MGLTextAnchorTop);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorBottom].MGLTextAnchorValue, MGLTextAnchorBottom);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorTopLeft].MGLTextAnchorValue, MGLTextAnchorTopLeft);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorTopRight].MGLTextAnchorValue, MGLTextAnchorTopRight);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorBottomLeft].MGLTextAnchorValue, MGLTextAnchorBottomLeft);
+    XCTAssertEqual([NSValue valueWithMGLTextAnchor:MGLTextAnchorBottomRight].MGLTextAnchorValue, MGLTextAnchorBottomRight);
+    XCTAssertEqual([NSValue valueWithMGLTextJustification:MGLTextJustificationLeft].MGLTextJustificationValue, MGLTextJustificationLeft);
+    XCTAssertEqual([NSValue valueWithMGLTextJustification:MGLTextJustificationCenter].MGLTextJustificationValue, MGLTextJustificationCenter);
+    XCTAssertEqual([NSValue valueWithMGLTextJustification:MGLTextJustificationRight].MGLTextJustificationValue, MGLTextJustificationRight);
+    XCTAssertEqual([NSValue valueWithMGLTextPitchAlignment:MGLTextPitchAlignmentMap].MGLTextPitchAlignmentValue, MGLTextPitchAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLTextPitchAlignment:MGLTextPitchAlignmentViewport].MGLTextPitchAlignmentValue, MGLTextPitchAlignmentViewport);
+    XCTAssertEqual([NSValue valueWithMGLTextPitchAlignment:MGLTextPitchAlignmentAuto].MGLTextPitchAlignmentValue, MGLTextPitchAlignmentAuto);
+    XCTAssertEqual([NSValue valueWithMGLTextRotationAlignment:MGLTextRotationAlignmentMap].MGLTextRotationAlignmentValue, MGLTextRotationAlignmentMap);
+    XCTAssertEqual([NSValue valueWithMGLTextRotationAlignment:MGLTextRotationAlignmentViewport].MGLTextRotationAlignmentValue, MGLTextRotationAlignmentViewport);
+    XCTAssertEqual([NSValue valueWithMGLTextRotationAlignment:MGLTextRotationAlignmentAuto].MGLTextRotationAlignmentValue, MGLTextRotationAlignmentAuto);
+    XCTAssertEqual([NSValue valueWithMGLTextTransform:MGLTextTransformNone].MGLTextTransformValue, MGLTextTransformNone);
+    XCTAssertEqual([NSValue valueWithMGLTextTransform:MGLTextTransformUppercase].MGLTextTransformValue, MGLTextTransformUppercase);
+    XCTAssertEqual([NSValue valueWithMGLTextTransform:MGLTextTransformLowercase].MGLTextTransformValue, MGLTextTransformLowercase);
+    XCTAssertEqual([NSValue valueWithMGLIconTranslationAnchor:MGLIconTranslationAnchorMap].MGLIconTranslationAnchorValue, MGLIconTranslationAnchorMap);
+    XCTAssertEqual([NSValue valueWithMGLIconTranslationAnchor:MGLIconTranslationAnchorViewport].MGLIconTranslationAnchorValue, MGLIconTranslationAnchorViewport);
+    XCTAssertEqual([NSValue valueWithMGLTextTranslationAnchor:MGLTextTranslationAnchorMap].MGLTextTranslationAnchorValue, MGLTextTranslationAnchorMap);
+    XCTAssertEqual([NSValue valueWithMGLTextTranslationAnchor:MGLTextTranslationAnchorViewport].MGLTextTranslationAnchorValue, MGLTextTranslationAnchorViewport);
+}
+
+@end
diff --git a/platform/ios/ios.xcodeproj/project.pbxproj b/platform/ios/ios.xcodeproj/project.pbxproj
index cc73e47f7c..892dbdd39f 100644
--- a/platform/ios/ios.xcodeproj/project.pbxproj
+++ b/platform/ios/ios.xcodeproj/project.pbxproj
@@ -86,13 +86,12 @@
 		3566C76F1D4A8DFA008152BC /* MGLRasterSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */; };
 		3566C7711D4A9198008152BC /* MGLSource_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7701D4A9198008152BC /* MGLSource_Private.h */; };
 		3566C7721D4A9198008152BC /* MGLSource_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7701D4A9198008152BC /* MGLSource_Private.h */; };
-		357579801D501E09000B822E /* MGLFillStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */; };
-		357579831D502AE6000B822E /* MGLRasterStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */; };
-		357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */; };
-		357579871D502AFE000B822E /* MGLLineStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */; };
-		357579891D502B06000B822E /* MGLCircleStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */; };
-		3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */; };
-		3575798E1D502EC7000B822E /* MGLRuntimeStylingHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */; };
+		357579801D501E09000B822E /* MGLFillStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3575797F1D501E09000B822E /* MGLFillStyleLayerTests.mm */; };
+		357579831D502AE6000B822E /* MGLRasterStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 357579821D502AE6000B822E /* MGLRasterStyleLayerTests.mm */; };
+		357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.mm */; };
+		357579871D502AFE000B822E /* MGLLineStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 357579861D502AFE000B822E /* MGLLineStyleLayerTests.mm */; };
+		357579891D502B06000B822E /* MGLCircleStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 357579881D502B06000B822E /* MGLCircleStyleLayerTests.mm */; };
+		3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.mm */; };
 		357FE2DD1E02D2B20068B753 /* NSCoder+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 357FE2DB1E02D2B20068B753 /* NSCoder+MGLAdditions.h */; };
 		357FE2DE1E02D2B20068B753 /* NSCoder+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 357FE2DB1E02D2B20068B753 /* NSCoder+MGLAdditions.h */; };
 		357FE2DF1E02D2B20068B753 /* NSCoder+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 357FE2DC1E02D2B20068B753 /* NSCoder+MGLAdditions.mm */; };
@@ -553,14 +552,12 @@
 		3566C76A1D4A8DFA008152BC /* MGLRasterSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLRasterSource.h; sourceTree = "<group>"; };
 		3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterSource.mm; sourceTree = "<group>"; };
 		3566C7701D4A9198008152BC /* MGLSource_Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLSource_Private.h; sourceTree = "<group>"; };
-		3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLFillStyleLayerTests.m; path = ../../darwin/test/MGLFillStyleLayerTests.m; sourceTree = "<group>"; };
-		357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRasterStyleLayerTests.m; path = ../../darwin/test/MGLRasterStyleLayerTests.m; sourceTree = "<group>"; };
-		357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLSymbolStyleLayerTests.m; path = ../../darwin/test/MGLSymbolStyleLayerTests.m; sourceTree = "<group>"; };
-		357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLLineStyleLayerTests.m; path = ../../darwin/test/MGLLineStyleLayerTests.m; sourceTree = "<group>"; };
-		357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCircleStyleLayerTests.m; path = ../../darwin/test/MGLCircleStyleLayerTests.m; sourceTree = "<group>"; };
-		3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLBackgroundStyleLayerTests.m; path = ../../darwin/test/MGLBackgroundStyleLayerTests.m; sourceTree = "<group>"; };
-		3575798C1D502EC7000B822E /* MGLRuntimeStylingHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLRuntimeStylingHelper.h; path = ../../darwin/test/MGLRuntimeStylingHelper.h; sourceTree = "<group>"; };
-		3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRuntimeStylingHelper.m; path = ../../darwin/test/MGLRuntimeStylingHelper.m; sourceTree = "<group>"; };
+		3575797F1D501E09000B822E /* MGLFillStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLFillStyleLayerTests.mm; path = ../../darwin/test/MGLFillStyleLayerTests.mm; sourceTree = "<group>"; };
+		357579821D502AE6000B822E /* MGLRasterStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLRasterStyleLayerTests.mm; path = ../../darwin/test/MGLRasterStyleLayerTests.mm; sourceTree = "<group>"; };
+		357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLSymbolStyleLayerTests.mm; path = ../../darwin/test/MGLSymbolStyleLayerTests.mm; sourceTree = "<group>"; };
+		357579861D502AFE000B822E /* MGLLineStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLLineStyleLayerTests.mm; path = ../../darwin/test/MGLLineStyleLayerTests.mm; sourceTree = "<group>"; };
+		357579881D502B06000B822E /* MGLCircleStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLCircleStyleLayerTests.mm; path = ../../darwin/test/MGLCircleStyleLayerTests.mm; sourceTree = "<group>"; };
+		3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLBackgroundStyleLayerTests.mm; path = ../../darwin/test/MGLBackgroundStyleLayerTests.mm; sourceTree = "<group>"; };
 		357F09091DF84F3800941873 /* MGLStyleValueTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLStyleValueTests.h; path = ../../darwin/test/MGLStyleValueTests.h; sourceTree = "<group>"; };
 		357FE2DB1E02D2B20068B753 /* NSCoder+MGLAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "NSCoder+MGLAdditions.h"; path = "../../darwin/src/NSCoder+MGLAdditions.h"; sourceTree = "<group>"; };
 		357FE2DC1E02D2B20068B753 /* NSCoder+MGLAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = "NSCoder+MGLAdditions.mm"; path = "../../darwin/src/NSCoder+MGLAdditions.mm"; sourceTree = "<group>"; };
@@ -664,6 +661,7 @@
 		DA35A2C81CCAAAD200E826B2 /* NSValue+MGLAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSValue+MGLAdditions.m"; sourceTree = "<group>"; };
 		DA35A2D11CCAB25200E826B2 /* jazzy.yml */ = {isa = PBXFileReference; lastKnownFileType = text; path = jazzy.yml; sourceTree = "<group>"; };
 		DA35D0871E1A6309007DED41 /* one-liner.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; name = "one-liner.json"; path = "../../darwin/test/one-liner.json"; sourceTree = "<group>"; };
+		DA3C6FF21E2859E700F962BE /* test-Bridging-Header.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "test-Bridging-Header.h"; path = "../../darwin/test/test-Bridging-Header.h"; sourceTree = "<group>"; };
 		DA4A26961CB6E795000B7809 /* Mapbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = Mapbox.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		DA6408D91DA4E7D300908C90 /* MGLVectorStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLVectorStyleLayer.h; sourceTree = "<group>"; };
 		DA6408DA1DA4E7D300908C90 /* MGLVectorStyleLayer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLVectorStyleLayer.m; sourceTree = "<group>"; };
@@ -764,7 +762,7 @@
 		DA8963341CC549A100684375 /* sprites */ = {isa = PBXFileReference; lastKnownFileType = folder; path = sprites; sourceTree = "<group>"; };
 		DA8963351CC549A100684375 /* styles */ = {isa = PBXFileReference; lastKnownFileType = folder; path = styles; sourceTree = "<group>"; };
 		DA8963361CC549A100684375 /* tiles */ = {isa = PBXFileReference; lastKnownFileType = folder; path = tiles; sourceTree = "<group>"; };
-		DA8F25B91D51D2570010E6B5 /* MGLStyleLayerTests.m.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; name = MGLStyleLayerTests.m.ejs; path = ../test/MGLStyleLayerTests.m.ejs; sourceTree = "<group>"; };
+		DA8F25B91D51D2570010E6B5 /* MGLStyleLayerTests.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; name = MGLStyleLayerTests.mm.ejs; path = ../test/MGLStyleLayerTests.mm.ejs; sourceTree = "<group>"; };
 		DA8F25BA1D51D2570010E6B5 /* MGLStyleLayer.h.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.h.ejs; sourceTree = "<group>"; };
 		DA8F25BB1D51D2570010E6B5 /* MGLStyleLayer.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.mm.ejs; sourceTree = "<group>"; };
 		DAA4E4021CBB5C2F00178DFB /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
@@ -942,14 +940,15 @@
 		3575798F1D513EF1000B822E /* Layers */ = {
 			isa = PBXGroup;
 			children = (
-				3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */,
-				357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */,
-				357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */,
-				357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */,
-				357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */,
-				3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */,
-				3575798C1D502EC7000B822E /* MGLRuntimeStylingHelper.h */,
-				3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */,
+				DA2DBBCC1D51E80400D38FF9 /* MGLStyleLayerTests.h */,
+				DA2DBBCD1D51E80400D38FF9 /* MGLStyleLayerTests.m */,
+				DA3C6FF21E2859E700F962BE /* test-Bridging-Header.h */,
+				3575797F1D501E09000B822E /* MGLFillStyleLayerTests.mm */,
+				357579821D502AE6000B822E /* MGLRasterStyleLayerTests.mm */,
+				357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.mm */,
+				357579861D502AFE000B822E /* MGLLineStyleLayerTests.mm */,
+				357579881D502B06000B822E /* MGLCircleStyleLayerTests.mm */,
+				3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.mm */,
 			);
 			name = Layers;
 			sourceTree = "<group>";
@@ -1094,8 +1093,6 @@
 				DD58A4C51D822BD000E1F038 /* MGLExpressionTests.mm */,
 				DA0CD58F1CF56F6A00A5F5A5 /* MGLFeatureTests.mm */,
 				DA2E885C1CC0382C00F24E7B /* MGLGeometryTests.mm */,
-				DA2DBBCC1D51E80400D38FF9 /* MGLStyleLayerTests.h */,
-				DA2DBBCD1D51E80400D38FF9 /* MGLStyleLayerTests.m */,
 				35E208A61D24210F00EC9A46 /* MGLNSDataAdditionsTests.m */,
 				DAE7DEC11E245455007505A6 /* MGLNSStringAdditionsTests.m */,
 				DA2E885D1CC0382C00F24E7B /* MGLOfflinePackTests.m */,
@@ -1258,7 +1255,7 @@
 			children = (
 				DA8F25BA1D51D2570010E6B5 /* MGLStyleLayer.h.ejs */,
 				DA8F25BB1D51D2570010E6B5 /* MGLStyleLayer.mm.ejs */,
-				DA8F25B91D51D2570010E6B5 /* MGLStyleLayerTests.m.ejs */,
+				DA8F25B91D51D2570010E6B5 /* MGLStyleLayerTests.mm.ejs */,
 			);
 			name = "Foundation Templates";
 			path = ../../darwin/src;
@@ -1949,27 +1946,26 @@
 				3599A3E61DF708BC00E77FB2 /* MGLStyleValueTests.m in Sources */,
 				DA2E88651CC0382C00F24E7B /* MGLStyleTests.mm in Sources */,
 				DA2E88611CC0382C00F24E7B /* MGLGeometryTests.mm in Sources */,
-				357579801D501E09000B822E /* MGLFillStyleLayerTests.m in Sources */,
+				357579801D501E09000B822E /* MGLFillStyleLayerTests.mm in Sources */,
 				35D9DDE21DA25EEC00DAAD69 /* MGLCodingTests.m in Sources */,
 				DA2E88641CC0382C00F24E7B /* MGLOfflineStorageTests.m in Sources */,
 				DA2DBBCE1D51E80400D38FF9 /* MGLStyleLayerTests.m in Sources */,
 				DA35A2C61CCA9F8300E826B2 /* MGLCompassDirectionFormatterTests.m in Sources */,
 				DAE7DEC21E245455007505A6 /* MGLNSStringAdditionsTests.m in Sources */,
-				3575798E1D502EC7000B822E /* MGLRuntimeStylingHelper.m in Sources */,
 				4085AF091D933DEA00F11B22 /* MGLTileSetTests.mm in Sources */,
 				DAEDC4341D603417000224FF /* MGLAttributionInfoTests.m in Sources */,
-				357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.m in Sources */,
-				357579871D502AFE000B822E /* MGLLineStyleLayerTests.m in Sources */,
-				357579891D502B06000B822E /* MGLCircleStyleLayerTests.m in Sources */,
+				357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.mm in Sources */,
+				357579871D502AFE000B822E /* MGLLineStyleLayerTests.mm in Sources */,
+				357579891D502B06000B822E /* MGLCircleStyleLayerTests.mm in Sources */,
 				DA2207BF1DC0805F0002F84D /* MGLStyleValueTests.swift in Sources */,
 				40CFA6511D7875BB008103BD /* MGLShapeSourceTests.mm in Sources */,
 				DA35A2C51CCA9F8300E826B2 /* MGLClockDirectionFormatterTests.m in Sources */,
 				35B8E08C1D6C8B5100E768D2 /* MGLPredicateTests.mm in Sources */,
 				DD58A4C61D822BD000E1F038 /* MGLExpressionTests.mm in Sources */,
-				3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m in Sources */,
+				3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.mm in Sources */,
 				DA2E88621CC0382C00F24E7B /* MGLOfflinePackTests.m in Sources */,
 				DA35A2AA1CCA058D00E826B2 /* MGLCoordinateFormatterTests.m in Sources */,
-				357579831D502AE6000B822E /* MGLRasterStyleLayerTests.m in Sources */,
+				357579831D502AE6000B822E /* MGLRasterStyleLayerTests.mm in Sources */,
 				353D23961D0B0DFE002BE09D /* MGLAnnotationViewTests.m in Sources */,
 				35E208A71D24210F00EC9A46 /* MGLNSDataAdditionsTests.m in Sources */,
 				DA0CD5901CF56F6A00A5F5A5 /* MGLFeatureTests.mm in Sources */,
diff --git a/platform/macos/macos.xcodeproj/project.pbxproj b/platform/macos/macos.xcodeproj/project.pbxproj
index ce3c4dad3b..e31bd7fa01 100644
--- a/platform/macos/macos.xcodeproj/project.pbxproj
+++ b/platform/macos/macos.xcodeproj/project.pbxproj
@@ -67,7 +67,6 @@
 		DA2207BC1DC076940002F84D /* MGLStyleValueTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DA2207BB1DC076940002F84D /* MGLStyleValueTests.swift */; };
 		DA2784FE1DF03060001D5B8D /* Media.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = DA2784FD1DF03060001D5B8D /* Media.xcassets */; };
 		DA29875A1E1A4290002299F5 /* MGLDocumentationExampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DA2987591E1A4290002299F5 /* MGLDocumentationExampleTests.swift */; };
-		DA2DBBCB1D51E30A00D38FF9 /* MGLStyleLayerTests.xib in Resources */ = {isa = PBXBuildFile; fileRef = DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */; };
 		DA35A2A41CC9EB1A00E826B2 /* MGLCoordinateFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = DA35A2A31CC9EB1A00E826B2 /* MGLCoordinateFormatter.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		DA35A2A61CC9EB2700E826B2 /* MGLCoordinateFormatter.m in Sources */ = {isa = PBXBuildFile; fileRef = DA35A2A51CC9EB2700E826B2 /* MGLCoordinateFormatter.m */; };
 		DA35A2A81CC9F41600E826B2 /* MGLCoordinateFormatterTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA35A2A71CC9F41600E826B2 /* MGLCoordinateFormatterTests.m */; };
@@ -101,13 +100,12 @@
 		DA87A99C1DC9D8DD00810D09 /* MGLShapeSource_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = DA87A99B1DC9D8DD00810D09 /* MGLShapeSource_Private.h */; };
 		DA87A99E1DC9DC2100810D09 /* MGLPredicateTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35C5D84B1D6DD75B00E95907 /* MGLPredicateTests.mm */; };
 		DA87A9A01DC9DC6200810D09 /* MGLValueEvaluator.h in Headers */ = {isa = PBXBuildFile; fileRef = DA87A99F1DC9DC6200810D09 /* MGLValueEvaluator.h */; };
-		DA87A9A11DC9DCB400810D09 /* MGLRuntimeStylingHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F257B1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.m */; };
-		DA87A9A21DC9DCF100810D09 /* MGLFillStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.m */; };
-		DA87A9A31DCACC5000810D09 /* MGLRasterStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.m */; };
-		DA87A9A41DCACC5000810D09 /* MGLSymbolStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.m */; };
-		DA87A9A51DCACC5000810D09 /* MGLLineStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.m */; };
-		DA87A9A61DCACC5000810D09 /* MGLCircleStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.m */; };
-		DA87A9A71DCACC5000810D09 /* MGLBackgroundStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.m */; };
+		DA87A9A21DC9DCF100810D09 /* MGLFillStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.mm */; };
+		DA87A9A31DCACC5000810D09 /* MGLRasterStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.mm */; };
+		DA87A9A41DCACC5000810D09 /* MGLSymbolStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.mm */; };
+		DA87A9A51DCACC5000810D09 /* MGLLineStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.mm */; };
+		DA87A9A61DCACC5000810D09 /* MGLCircleStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.mm */; };
+		DA87A9A71DCACC5000810D09 /* MGLBackgroundStyleLayerTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.mm */; };
 		DA8933A51CCD287300E68420 /* MGLAnnotationCallout.xib in Resources */ = {isa = PBXBuildFile; fileRef = DA8933A71CCD287300E68420 /* MGLAnnotationCallout.xib */; };
 		DA8933AE1CCD290700E68420 /* Localizable.strings in Resources */ = {isa = PBXBuildFile; fileRef = DA8933AB1CCD290700E68420 /* Localizable.strings */; };
 		DA8933B51CCD2C2500E68420 /* Foundation.strings in Resources */ = {isa = PBXBuildFile; fileRef = DA8933B31CCD2C2500E68420 /* Foundation.strings */; };
@@ -320,7 +318,6 @@
 		DA2207BB1DC076940002F84D /* MGLStyleValueTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MGLStyleValueTests.swift; sourceTree = "<group>"; };
 		DA2784FD1DF03060001D5B8D /* Media.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Media.xcassets; path = ../../darwin/test/Media.xcassets; sourceTree = "<group>"; };
 		DA2987591E1A4290002299F5 /* MGLDocumentationExampleTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = MGLDocumentationExampleTests.swift; path = ../../darwin/test/MGLDocumentationExampleTests.swift; sourceTree = "<group>"; };
-		DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.xib; path = MGLStyleLayerTests.xib; sourceTree = "<group>"; };
 		DA35A2A31CC9EB1A00E826B2 /* MGLCoordinateFormatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLCoordinateFormatter.h; sourceTree = "<group>"; };
 		DA35A2A51CC9EB2700E826B2 /* MGLCoordinateFormatter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLCoordinateFormatter.m; sourceTree = "<group>"; };
 		DA35A2A71CC9F41600E826B2 /* MGLCoordinateFormatterTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCoordinateFormatterTests.m; path = ../../darwin/test/MGLCoordinateFormatterTests.m; sourceTree = "<group>"; };
@@ -361,14 +358,12 @@
 		DA8933AC1CCD290700E68420 /* Base */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = Base; path = Base.lproj/Localizable.strings; sourceTree = "<group>"; };
 		DA8933B41CCD2C2500E68420 /* Base */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = Base; path = Base.lproj/Foundation.strings; sourceTree = "<group>"; };
 		DA8933B71CCD2C2D00E68420 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.stringsdict; name = en; path = en.lproj/Foundation.stringsdict; sourceTree = "<group>"; };
-		DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLFillStyleLayerTests.m; path = ../../darwin/test/MGLFillStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRasterStyleLayerTests.m; path = ../../darwin/test/MGLRasterStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLSymbolStyleLayerTests.m; path = ../../darwin/test/MGLSymbolStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLLineStyleLayerTests.m; path = ../../darwin/test/MGLLineStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCircleStyleLayerTests.m; path = ../../darwin/test/MGLCircleStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLBackgroundStyleLayerTests.m; path = ../../darwin/test/MGLBackgroundStyleLayerTests.m; sourceTree = "<group>"; };
-		DA8F257A1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLRuntimeStylingHelper.h; path = ../../darwin/test/MGLRuntimeStylingHelper.h; sourceTree = "<group>"; };
-		DA8F257B1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRuntimeStylingHelper.m; path = ../../darwin/test/MGLRuntimeStylingHelper.m; sourceTree = "<group>"; };
+		DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLFillStyleLayerTests.mm; sourceTree = "<group>"; };
+		DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterStyleLayerTests.mm; sourceTree = "<group>"; };
+		DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLSymbolStyleLayerTests.mm; sourceTree = "<group>"; };
+		DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLLineStyleLayerTests.mm; sourceTree = "<group>"; };
+		DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLCircleStyleLayerTests.mm; sourceTree = "<group>"; };
+		DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBackgroundStyleLayerTests.mm; sourceTree = "<group>"; };
 		DA8F25851D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLBackgroundStyleLayer.h; sourceTree = "<group>"; };
 		DA8F25861D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBackgroundStyleLayer.mm; sourceTree = "<group>"; };
 		DA8F25891D51CA540010E6B5 /* MGLLineStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLLineStyleLayer.h; sourceTree = "<group>"; };
@@ -383,7 +378,7 @@
 		DA8F259B1D51CB000010E6B5 /* MGLStyleValue_Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleValue_Private.h; sourceTree = "<group>"; };
 		DA8F25A61D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSValue+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; };
 		DA8F25A71D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSValue+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; };
-		DA8F25B51D51D2240010E6B5 /* MGLStyleLayerTests.m.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; name = MGLStyleLayerTests.m.ejs; path = ../test/MGLStyleLayerTests.m.ejs; sourceTree = "<group>"; };
+		DA8F25B51D51D2240010E6B5 /* MGLStyleLayerTests.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; name = MGLStyleLayerTests.mm.ejs; path = ../test/MGLStyleLayerTests.mm.ejs; sourceTree = "<group>"; };
 		DA8F25B61D51D2240010E6B5 /* MGLStyleLayer.h.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.h.ejs; sourceTree = "<group>"; };
 		DA8F25B71D51D2240010E6B5 /* MGLStyleLayer.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.mm.ejs; sourceTree = "<group>"; };
 		DAA48EFB1D6A4731006A7E36 /* StyleLayerIconTransformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleLayerIconTransformer.h; sourceTree = "<group>"; };
@@ -699,15 +694,12 @@
 				40E1601A1DF216E6005EA6D9 /* MGLStyleLayerTests.h */,
 				40E1601B1DF216E6005EA6D9 /* MGLStyleLayerTests.m */,
 				DA2207BA1DC076930002F84D /* test-Bridging-Header.h */,
-				DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.m */,
-				DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.m */,
-				DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.m */,
-				DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.m */,
-				DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.m */,
-				DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.m */,
-				DA8F257A1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.h */,
-				DA8F257B1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.m */,
-				DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */,
+				DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.mm */,
+				DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.mm */,
+				DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.mm */,
+				DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.mm */,
+				DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.mm */,
+				DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.mm */,
 			);
 			name = Layers;
 			sourceTree = "<group>";
@@ -730,7 +722,7 @@
 			children = (
 				DA8F25B61D51D2240010E6B5 /* MGLStyleLayer.h.ejs */,
 				DA8F25B71D51D2240010E6B5 /* MGLStyleLayer.mm.ejs */,
-				DA8F25B51D51D2240010E6B5 /* MGLStyleLayerTests.m.ejs */,
+				DA8F25B51D51D2240010E6B5 /* MGLStyleLayerTests.mm.ejs */,
 			);
 			name = "Foundation Templates";
 			path = ../../darwin/src;
@@ -1218,7 +1210,6 @@
 			files = (
 				35724FC41D630502002A4AB4 /* amsterdam.geojson in Resources */,
 				DA2784FE1DF03060001D5B8D /* Media.xcassets in Resources */,
-				DA2DBBCB1D51E30A00D38FF9 /* MGLStyleLayerTests.xib in Resources */,
 				DA35D08A1E1A631B007DED41 /* one-liner.json in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -1318,28 +1309,27 @@
 			files = (
 				DA35A2C21CCA9F4A00E826B2 /* MGLClockDirectionFormatterTests.m in Sources */,
 				DAE6C3D41CC34C9900DB3429 /* MGLOfflineRegionTests.m in Sources */,
-				DA87A9A11DC9DCB400810D09 /* MGLRuntimeStylingHelper.m in Sources */,
 				DAE6C3D61CC34C9900DB3429 /* MGLStyleTests.mm in Sources */,
 				DAEDC4371D606291000224FF /* MGLAttributionButtonTests.m in Sources */,
 				DA35A2B61CCA14D700E826B2 /* MGLCompassDirectionFormatterTests.m in Sources */,
 				DAE6C3D21CC34C9900DB3429 /* MGLGeometryTests.mm in Sources */,
-				DA87A9A41DCACC5000810D09 /* MGLSymbolStyleLayerTests.m in Sources */,
+				DA87A9A41DCACC5000810D09 /* MGLSymbolStyleLayerTests.mm in Sources */,
 				DAE6C3D51CC34C9900DB3429 /* MGLOfflineStorageTests.m in Sources */,
 				40E1601D1DF217D6005EA6D9 /* MGLStyleLayerTests.m in Sources */,
-				DA87A9A61DCACC5000810D09 /* MGLCircleStyleLayerTests.m in Sources */,
+				DA87A9A61DCACC5000810D09 /* MGLCircleStyleLayerTests.mm in Sources */,
 				DA87A99E1DC9DC2100810D09 /* MGLPredicateTests.mm in Sources */,
 				DD58A4C91D822C6700E1F038 /* MGLExpressionTests.mm in Sources */,
-				DA87A9A71DCACC5000810D09 /* MGLBackgroundStyleLayerTests.m in Sources */,
+				DA87A9A71DCACC5000810D09 /* MGLBackgroundStyleLayerTests.mm in Sources */,
 				DA29875A1E1A4290002299F5 /* MGLDocumentationExampleTests.swift in Sources */,
 				DAE6C3D31CC34C9900DB3429 /* MGLOfflinePackTests.m in Sources */,
-				DA87A9A51DCACC5000810D09 /* MGLLineStyleLayerTests.m in Sources */,
-				DA87A9A31DCACC5000810D09 /* MGLRasterStyleLayerTests.m in Sources */,
+				DA87A9A51DCACC5000810D09 /* MGLLineStyleLayerTests.mm in Sources */,
+				DA87A9A31DCACC5000810D09 /* MGLRasterStyleLayerTests.mm in Sources */,
 				DA87A9991DC9D88400810D09 /* MGLTileSetTests.mm in Sources */,
 				DA35A2A81CC9F41600E826B2 /* MGLCoordinateFormatterTests.m in Sources */,
 				DAE7DEC41E24549F007505A6 /* MGLNSStringAdditionsTests.m in Sources */,
 				DA87A9981DC9D88400810D09 /* MGLShapeSourceTests.mm in Sources */,
 				3526EABD1DF9B19800006B43 /* MGLCodingTests.m in Sources */,
-				DA87A9A21DC9DCF100810D09 /* MGLFillStyleLayerTests.m in Sources */,
+				DA87A9A21DC9DCF100810D09 /* MGLFillStyleLayerTests.mm in Sources */,
 				3599A3E81DF70E2000E77FB2 /* MGLStyleValueTests.m in Sources */,
 				DAEDC4321D6033F1000224FF /* MGLAttributionInfoTests.m in Sources */,
 				DA0CD58E1CF56F5800A5F5A5 /* MGLFeatureTests.mm in Sources */,