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

10 files changed, 227 insertions, 66 deletions

diff --git a/test/style/conversion/function.test.cpp b/test/style/conversion/function.test.cpp
index 1eff94d939..a48be2c075 100644
--- a/test/style/conversion/function.test.cpp
+++ b/test/style/conversion/function.test.cpp
@@ -1,9 +1,9 @@
 #include <mbgl/test/util.hpp>
 
-#include <mbgl/style/conversion.hpp>
-#include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/constant.hpp>
 #include <mbgl/style/conversion/function.hpp>
+#include <mbgl/style/conversion/data_driven_property_value.hpp>
 #include <mbgl/util/rapidjson.hpp>
 
 using namespace mbgl;
@@ -13,10 +13,8 @@ using namespace mbgl::style::conversion;
 TEST(StyleConversion, Function) {
     Error error;
 
-    auto parseFunction = [&](const std::string& src) {
-        JSDocument doc;
-        doc.Parse<0>(src);
-        return convert<CameraFunction<float>, JSValue>(doc, error);
+    auto parseFunction = [&](const std::string& json) {
+        return convertJSON<CameraFunction<float>>(json, error);
     };
 
     auto fn1 = parseFunction(R"({"stops":[]})");
@@ -54,3 +52,29 @@ TEST(StyleConversion, Function) {
     ASSERT_FALSE(fn9);
     ASSERT_EQ("function base must be a number", error.message);
 }
+
+TEST(StyleConversion, CompositeFunctionExpression) {
+    Error error;
+
+    auto parseFunction = [&](const std::string& src) {
+        JSDocument doc;
+        doc.Parse<0>(src);
+        return convert<DataDrivenPropertyValue<float>>(doc, error);
+    };
+
+    auto fn1 = parseFunction(R"(["interpolate", ["linear"], ["zoom"], 0, ["number", ["get", "x"]], 10, 10])");
+    ASSERT_TRUE(fn1);
+    
+    auto fn2 = parseFunction(R"(["coalesce", ["interpolate", ["linear"], ["zoom"], 0, ["number", ["get", "x"]], 10, 10], 0])");
+    ASSERT_TRUE(fn2);
+
+    auto fn3 = parseFunction(R"(["let", "a", 0, ["interpolate", ["linear"], ["zoom"], 0, ["number", ["get", "x"]], 10, 10] ])");
+    ASSERT_TRUE(fn3);
+
+    auto fn4 = parseFunction(R"(["coalesce", ["let", "a", 0, ["interpolate", ["linear"], ["zoom"], 0, ["number", ["get", "x"]], 10, 10], 0 ])");
+    ASSERT_TRUE(fn4);
+
+    auto fn5 = parseFunction(R"(["coalesce", ["interpolate", ["linear"], ["number", ["get", "x"]], 0, ["zoom"], 10, 10], 0])");
+    ASSERT_FALSE(fn5);
+    ASSERT_EQ(R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)", error.message);
+}
diff --git a/test/style/conversion/geojson_options.test.cpp b/test/style/conversion/geojson_options.test.cpp
index e6bd984f36..4c5a0c9aa4 100644
--- a/test/style/conversion/geojson_options.test.cpp
+++ b/test/style/conversion/geojson_options.test.cpp
@@ -1,8 +1,7 @@
 #include <mbgl/test/util.hpp>
 
-#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/geojson_options.hpp>
-#include <mbgl/test/conversion_stubs.hpp>
 
 #include <mbgl/util/logging.hpp>
 
@@ -10,29 +9,26 @@ using namespace mbgl::style;
 using namespace mbgl::style::conversion;
 
 TEST(GeoJSONOptions, Basic) {
-    ValueMap map;
-    Value raw(map);
     Error error;
-    mbgl::optional<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw, error);
+    mbgl::optional<GeoJSONOptions> converted = convertJSON<GeoJSONOptions>("{}", error);
     ASSERT_TRUE((bool) converted);
 }
 
 TEST(GeoJSONOptions, ErrorHandling) {
-    ValueMap map {{"maxzoom", std::string{"should not be a string"}}};
-    Value raw(map);
     Error error;
-    mbgl::optional<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw, error);
+    mbgl::optional<GeoJSONOptions> converted = convertJSON<GeoJSONOptions>(R"JSON({
+        "maxzoom": "should not be a string"
+    })JSON", error);
     ASSERT_FALSE((bool) converted);
 }
 
 TEST(GeoJSONOptions, RetainsDefaults) {
-    ValueMap map;
-    Value raw(map);
     Error error;
-    GeoJSONOptions converted = *convert<GeoJSONOptions>(raw, error);
+    GeoJSONOptions converted = *convertJSON<GeoJSONOptions>("{}", error);
     GeoJSONOptions defaults;
 
     // GeoJSON-VT
+    ASSERT_EQ(converted.minzoom, defaults.minzoom);
     ASSERT_EQ(converted.maxzoom, defaults.maxzoom);
     ASSERT_EQ(converted.buffer, defaults.buffer);
     ASSERT_EQ(converted.tolerance, defaults.tolerance);
@@ -43,24 +39,19 @@ TEST(GeoJSONOptions, RetainsDefaults) {
     ASSERT_EQ(converted.clusterMaxZoom, defaults.clusterMaxZoom);
 }
 
-
 TEST(GeoJSONOptions, FullConversion) {
-    ValueMap map {
-        // GeoJSON-VT
-        {"maxzoom", 1.0f},
-        {"buffer", 2.0f},
-        {"tolerance", 3.0f},
-
-        // Supercluster
-        {"cluster", true},
-        {"clusterRadius", 4.0f},
-        {"clusterMaxZoom", 5.0f}
-    };
-    Value raw(map);
     Error error;
-    GeoJSONOptions converted = *convert<GeoJSONOptions>(raw, error);
+    GeoJSONOptions converted = *convertJSON<GeoJSONOptions>(R"JSON({
+        "maxzoom": 1,
+        "buffer": 2,
+        "tolerance": 3,
+        "cluster": true,
+        "clusterRadius": 4,
+        "clusterMaxZoom": 5
+    })JSON", error);
 
     // GeoJSON-VT
+    ASSERT_EQ(converted.minzoom, 0);
     ASSERT_EQ(converted.maxzoom, 1);
     ASSERT_EQ(converted.buffer, 2);
     ASSERT_EQ(converted.tolerance, 3);
diff --git a/test/style/conversion/layer.test.cpp b/test/style/conversion/layer.test.cpp
index d51d7d33e2..33cd329999 100644
--- a/test/style/conversion/layer.test.cpp
+++ b/test/style/conversion/layer.test.cpp
@@ -1,10 +1,8 @@
 #include <mbgl/test/util.hpp>
 
-#include <mbgl/style/conversion.hpp>
-#include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
-#include <mbgl/util/rapidjson.hpp>
 
 using namespace mbgl;
 using namespace mbgl::style;
@@ -12,10 +10,8 @@ using namespace mbgl::style::conversion;
 using namespace std::literals::chrono_literals;
 
 std::unique_ptr<Layer> parseLayer(const std::string& src) {
-    JSDocument doc;
-    doc.Parse<0>(src);
     Error error;
-    return std::move(*convert<std::unique_ptr<Layer>, JSValue>(doc, error));
+    return std::move(*convertJSON<std::unique_ptr<Layer>>(src, error));
 }
 
 TEST(StyleConversion, LayerTransition) {
diff --git a/test/style/conversion/light.test.cpp b/test/style/conversion/light.test.cpp
index 28e22b3550..67e48c942e 100644
--- a/test/style/conversion/light.test.cpp
+++ b/test/style/conversion/light.test.cpp
@@ -1,11 +1,10 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/style/conversion.hpp>
-#include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/constant.hpp>
 #include <mbgl/style/conversion/light.hpp>
 #include <mbgl/style/position.hpp>
-#include <mbgl/util/rapidjson.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/chrono.hpp>
 
@@ -19,9 +18,7 @@ TEST(StyleConversion, Light) {
     Error error;
 
     auto parseLight = [&](const std::string& src) {
-        JSDocument doc;
-        doc.Parse<0>(src);
-        return convert<Light>(doc, error);
+        return convertJSON<Light>(src, error);
     };
 
     {
diff --git a/test/style/expression/expression.test.cpp b/test/style/expression/expression.test.cpp
new file mode 100644
index 0000000000..694569695c
--- /dev/null
+++ b/test/style/expression/expression.test.cpp
@@ -0,0 +1,91 @@
+#include <mbgl/test/util.hpp>
+#include <mbgl/util/io.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/util/rapidjson.hpp>
+#include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/expression/is_expression.hpp>
+
+#include <rapidjson/document.h>
+
+#include <iostream>
+#include <fstream>
+#include <dirent.h>
+
+
+using namespace mbgl;
+using namespace mbgl::style;
+
+TEST(Expression, IsExpression) {
+    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> spec;
+    spec.Parse<0>(util::read_file("mapbox-gl-js/src/style-spec/reference/v8.json").c_str());
+    ASSERT_FALSE(spec.HasParseError());
+    ASSERT_TRUE(spec.IsObject() &&
+                spec.HasMember("expression_name") &&
+                spec["expression_name"].IsObject() &&
+                spec["expression_name"].HasMember("values") &&
+                spec["expression_name"]["values"].IsObject());
+    
+    const auto& allExpressions = spec["expression_name"]["values"];
+    
+    for(auto& entry : allExpressions.GetObject()) {
+        const std::string name { entry.name.GetString(), entry.name.GetStringLength() };
+        JSDocument document;
+        document.Parse<0>(R"([")" + name + R"("])");
+
+        const JSValue* expression = &document;
+        EXPECT_TRUE(expression::isExpression(conversion::Convertible(expression))) << name;
+    }
+}
+
+class ExpressionEqualityTest : public ::testing::TestWithParam<std::string> {};
+
+TEST_P(ExpressionEqualityTest, ExpressionEquality) {
+    const std::string base = std::string("test/fixtures/expression_equality/") + GetParam();
+
+    std::string error;
+    auto parse = [&](std::string filename, std::string& error_) -> std::unique_ptr<expression::Expression> {
+        rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> document;
+        document.Parse<0>(util::read_file(filename).c_str());
+        assert(!document.HasParseError());
+        const JSValue* expression = &document;
+        expression::ParsingContext ctx;
+        expression::ParseResult parsed = ctx.parse(conversion::Convertible(expression));
+        if (!parsed) {
+            error_ = ctx.getErrors().size() > 0 ? ctx.getErrors()[0].message : "failed to parse";
+        };
+        return std::move(*parsed);
+    };
+
+    std::unique_ptr<expression::Expression> expression_a1 = parse(base + ".a.json", error);
+    ASSERT_TRUE(expression_a1) << GetParam() << ": " << error;
+
+    std::unique_ptr<expression::Expression> expression_a2 = parse(base + ".a.json", error);
+    ASSERT_TRUE(expression_a2) << GetParam() << ": " << error;
+
+    std::unique_ptr<expression::Expression> expression_b = parse(base + ".b.json", error);
+    ASSERT_TRUE(expression_b) << GetParam() << ": " << error;
+
+
+    EXPECT_TRUE(*expression_a1 == *expression_a2);
+    EXPECT_TRUE(*expression_a1 != *expression_b);
+}
+
+INSTANTIATE_TEST_CASE_P(Expression, ExpressionEqualityTest, ::testing::ValuesIn([] {
+    std::vector<std::string> names;
+    const std::string ending = ".a.json";
+
+    const std::string style_directory = "test/fixtures/expression_equality";
+    DIR *dir = opendir(style_directory.c_str());
+    if (dir != nullptr) {
+        for (dirent *dp = nullptr; (dp = readdir(dir)) != nullptr;) {
+            const std::string name = dp->d_name;
+            if (name.length() >= ending.length() && name.compare(name.length() - ending.length(), ending.length(), ending) == 0) {
+                names.push_back(name.substr(0, name.length() - ending.length()));
+            }
+        }
+        closedir(dir);
+    }
+
+    EXPECT_GT(names.size(), 0u);
+    return names;
+}()));
diff --git a/test/style/expression/util.test.cpp b/test/style/expression/util.test.cpp
new file mode 100644
index 0000000000..0337cd871f
--- /dev/null
+++ b/test/style/expression/util.test.cpp
@@ -0,0 +1,23 @@
+#include <mbgl/test/util.hpp>
+#include <mbgl/style/expression/util.hpp>
+
+using namespace mbgl;
+using namespace mbgl::style::expression;
+
+TEST(Expression, Util_rgba) {
+    Result<Color> valid = rgba(0, 0, 0, 0);
+    ASSERT_TRUE(valid);
+    ASSERT_EQ(valid->r, 0);
+    ASSERT_EQ(valid->g, 0);
+    ASSERT_EQ(valid->b, 0);
+    ASSERT_EQ(valid->a, 0);
+
+    ASSERT_FALSE(rgba(0, 0, 0, -0.1));
+    ASSERT_FALSE(rgba(0, 0, 0, 1.1));
+    ASSERT_FALSE(rgba(0, 0, -1, 1));
+    ASSERT_FALSE(rgba(0, 0, 256, 1));
+    ASSERT_FALSE(rgba(0, -1, 0, 1));
+    ASSERT_FALSE(rgba(0, 256, 0, 1));
+    ASSERT_FALSE(rgba(-1, 1, 0, 1));
+    ASSERT_FALSE(rgba(-256, 1, 0, 1));
+}
diff --git a/test/style/filter.test.cpp b/test/style/filter.test.cpp
index 96de125945..73f8e7626d 100644
--- a/test/style/filter.test.cpp
+++ b/test/style/filter.test.cpp
@@ -4,20 +4,15 @@
 
 #include <mbgl/style/filter.hpp>
 #include <mbgl/style/filter_evaluator.hpp>
-#include <mbgl/style/rapidjson_conversion.hpp>
-#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/filter.hpp>
 
-#include <rapidjson/document.h>
-
 using namespace mbgl;
 using namespace mbgl::style;
 
 Filter parse(const char * expression) {
-    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
-    doc.Parse<0>(expression);
     conversion::Error error;
-    optional<Filter> filter = conversion::convert<Filter, JSValue>(doc, error);
+    optional<Filter> filter = conversion::convertJSON<Filter>(expression, error);
     EXPECT_TRUE(bool(filter));
     return *filter;
 }
diff --git a/test/style/function/source_function.test.cpp b/test/style/function/source_function.test.cpp
index 260620c8d0..46ad961002 100644
--- a/test/style/function/source_function.test.cpp
+++ b/test/style/function/source_function.test.cpp
@@ -76,11 +76,14 @@ TEST(SourceFunction, Categorical) {
     EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ int64_t(1), 1.0f }}))
         .evaluate(oneString, 0.0f));
 
-    EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
+    CategoricalStops<float>::Stops stops;
+    stops["1"s] = 1.0f;
+
+    EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
         .evaluate(oneInteger, 0.0f));
-    EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
+    EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
         .evaluate(oneDouble, 0.0f));
-    EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
+    EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
         .evaluate(oneString, 0.0f));
 
     EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>({{ true, 1.0f }}))
diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp
index eaa3c72877..eb419e8080 100644
--- a/test/style/source.test.cpp
+++ b/test/style/source.test.cpp
@@ -3,11 +3,13 @@
 #include <mbgl/test/stub_style_observer.hpp>
 #include <mbgl/test/stub_render_source_observer.hpp>
 
+#include <mbgl/style/style.hpp>
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/sources/raster_source.hpp>
 #include <mbgl/style/sources/vector_source.hpp>
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/style/sources/image_source.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
 #include <mbgl/style/layers/raster_layer.cpp>
 #include <mbgl/style/layers/line_layer.hpp>
 
@@ -23,7 +25,7 @@
 #include <mbgl/util/image.hpp>
 
 #include <mbgl/util/tileset.hpp>
-#include <mbgl/util/default_thread_pool.hpp>
+#include <mbgl/util/shared_thread_pool.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/range.hpp>
@@ -37,6 +39,7 @@
 #include <cstdint>
 
 using namespace mbgl;
+using SourceType = mbgl::style::SourceType;
 
 class SourceTest {
 public:
@@ -47,7 +50,8 @@ public:
     Transform transform;
     TransformState transformState;
     ThreadPool threadPool { 1 };
-    AnnotationManager annotationManager;
+    Style style { loop, fileSource, 1 };
+    AnnotationManager annotationManager { style };
     ImageManager imageManager;
     GlyphManager glyphManager { fileSource };
 
@@ -60,7 +64,8 @@ public:
         MapMode::Continuous,
         annotationManager,
         imageManager,
-        glyphManager
+        glyphManager,
+        0
     };
 
     SourceTest() {
@@ -530,11 +535,11 @@ TEST(Source, ImageSourceImageUpdate) {
 
     // Load initial, so the source state will be loaded=true
     source.loadDescription(test.fileSource);
-    UnassociatedImage rgba({ 1, 1 });
+    PremultipliedImage rgba({ 1, 1 });
     rgba.data[0] = 255;
     rgba.data[1] = 254;
     rgba.data[2] = 253;
-    rgba.data[3] = 128;
+    rgba.data[3] = 0;
 
     // Schedule an update
     test.loop.invoke([&] () {
@@ -544,3 +549,39 @@ TEST(Source, ImageSourceImageUpdate) {
 
     test.run();
 }
+
+TEST(Source, CustomGeometrySourceSetTileData) {
+    SourceTest test;
+    std::shared_ptr<ThreadPool> threadPool = sharedThreadPool();
+    CustomGeometrySource source("source", CustomGeometrySource::Options());
+    source.loadDescription(test.fileSource);
+
+    LineLayer layer("id", "source");
+    layer.setSourceLayer("water");
+    std::vector<Immutable<Layer::Impl>> layers {{ layer.baseImpl }};
+
+    test.renderSourceObserver.tileChanged = [&] (RenderSource& source_, const OverscaledTileID&) {
+        EXPECT_EQ("source", source_.baseImpl->id);
+        test.end();
+    };
+
+    test.renderSourceObserver.tileError = [&] (RenderSource&, const OverscaledTileID&, std::exception_ptr) {
+        FAIL() << "Should never be called";
+    };
+
+    auto renderSource = RenderSource::create(source.baseImpl);
+    renderSource->setObserver(&test.renderSourceObserver);
+    renderSource->update(source.baseImpl,
+                         layers,
+                         true,
+                         true,
+                         test.tileParameters);
+
+    test.loop.invoke([&] () {
+        // Set Tile Data
+        source.setTileData(CanonicalTileID(0, 0, 0), GeoJSON{ FeatureCollection{} });
+    });
+
+    test.run();
+}
+
diff --git a/test/style/style.test.cpp b/test/style/style.test.cpp
index ab58eb1024..9bdab37ac6 100644
--- a/test/style/style.test.cpp
+++ b/test/style/style.test.cpp
@@ -28,27 +28,27 @@ TEST(Style, Properties) {
 
     style.loadJSON(R"STYLE({"center": [10, 20]})STYLE");
     ASSERT_EQ("", style.getName());
-    ASSERT_EQ((LatLng{20, 10}), style.getDefaultLatLng());
+    ASSERT_EQ((LatLng{20, 10}), *style.getDefaultCamera().center);
 
     style.loadJSON(R"STYLE({"bearing": 24})STYLE");
     ASSERT_EQ("", style.getName());
-    ASSERT_EQ((LatLng{0, 0}), style.getDefaultLatLng());
-    ASSERT_EQ(24, style.getDefaultBearing());
+    ASSERT_EQ(LatLng {}, *style.getDefaultCamera().center);
+    ASSERT_EQ(24, *style.getDefaultCamera().angle);
 
     style.loadJSON(R"STYLE({"zoom": 13.3})STYLE");
     ASSERT_EQ("", style.getName());
-    ASSERT_EQ(13.3, style.getDefaultZoom());
+    ASSERT_EQ(13.3, *style.getDefaultCamera().zoom);
 
     style.loadJSON(R"STYLE({"pitch": 60})STYLE");
     ASSERT_EQ("", style.getName());
-    ASSERT_EQ(60, style.getDefaultPitch());
+    ASSERT_EQ(60, *style.getDefaultCamera().pitch);
 
     style.loadJSON(R"STYLE({"name": 23, "center": {}, "bearing": "north", "zoom": null, "pitch": "wide"})STYLE");
     ASSERT_EQ("", style.getName());
-    ASSERT_EQ((LatLng{0, 0}), style.getDefaultLatLng());
-    ASSERT_EQ(0, style.getDefaultBearing());
-    ASSERT_EQ(0, style.getDefaultZoom());
-    ASSERT_EQ(0, style.getDefaultPitch());
+    ASSERT_EQ(LatLng {}, *style.getDefaultCamera().center);
+    ASSERT_EQ(0, *style.getDefaultCamera().zoom);
+    ASSERT_EQ(0, *style.getDefaultCamera().angle);
+    ASSERT_EQ(0, *style.getDefaultCamera().pitch);
 }
 
 TEST(Style, DuplicateSource) {