diff options
Diffstat (limited to 'test/style')
| -rw-r--r-- | test/style/conversion/function.test.cpp | 54 | ||||
| -rw-r--r-- | test/style/conversion/geojson_options.test.cpp | 14 | ||||
| -rw-r--r-- | test/style/conversion/stringify.test.cpp | 98 | ||||
| -rw-r--r-- | test/style/filter.test.cpp | 6 | ||||
| -rw-r--r-- | test/style/functions.test.cpp | 42 | ||||
| -rw-r--r-- | test/style/group_by_layout.test.cpp | 44 | ||||
| -rw-r--r-- | test/style/paint_property.test.cpp | 94 | ||||
| -rw-r--r-- | test/style/source.test.cpp | 6 |
8 files changed, 326 insertions, 32 deletions
diff --git a/test/style/conversion/function.test.cpp b/test/style/conversion/function.test.cpp new file mode 100644 index 0000000000..e93207ea13 --- /dev/null +++ b/test/style/conversion/function.test.cpp @@ -0,0 +1,54 @@ +#include <mbgl/test/util.hpp> + +#include <mbgl/style/conversion.hpp> +#include <mbgl/style/rapidjson_conversion.hpp> +#include <mbgl/style/conversion/constant.hpp> +#include <mbgl/style/conversion/function.hpp> +#include <mbgl/util/rapidjson.hpp> + +using namespace mbgl; +using namespace mbgl::style; +using namespace mbgl::style::conversion; + +auto parseFunction(const std::string& src) { + JSDocument doc; + doc.Parse<0>(src); + return convert<Function<float>>(doc); +} + +TEST(StyleConversion, Function) { + auto fn1 = parseFunction("{\"stops\":[]}"); + ASSERT_FALSE(fn1); + ASSERT_EQ("function must have at least one stop", fn1.error().message); + + auto fn2 = parseFunction("{\"stops\":[1]}"); + ASSERT_FALSE(fn2); + ASSERT_EQ("function stop must be an array", fn2.error().message); + + auto fn3 = parseFunction("{\"stops\":[[]]}"); + ASSERT_FALSE(fn3); + ASSERT_EQ("function stop must have two elements", fn3.error().message); + + auto fn4 = parseFunction("{\"stops\":[[-1,-1]]}"); + ASSERT_TRUE(bool(fn4)); + + auto fn5 = parseFunction("{\"stops\":[[0,1,2]]}"); + ASSERT_FALSE(fn5); + ASSERT_EQ("function stop must have two elements", fn5.error().message); + + auto fn6 = parseFunction("{\"stops\":[[0,\"x\"]]}"); + ASSERT_FALSE(fn6); + ASSERT_EQ("value must be a number", fn6.error().message); + + auto fn7 = parseFunction("{}"); + ASSERT_FALSE(fn7); + ASSERT_EQ("function value must specify stops", fn7.error().message); + + auto fn8 = parseFunction("[]"); + ASSERT_FALSE(fn8); + ASSERT_EQ("function must be an object", fn8.error().message); + + auto fn9 = parseFunction("{\"stops\":[[0,0]],\"base\":false}"); + ASSERT_FALSE(fn9); + ASSERT_EQ("function base must be a number", fn9.error().message); +} diff --git a/test/style/conversion/geojson_options.test.cpp b/test/style/conversion/geojson_options.test.cpp index 46a2aa950b..14a7adbba7 100644 --- a/test/style/conversion/geojson_options.test.cpp +++ b/test/style/conversion/geojson_options.test.cpp @@ -4,7 +4,7 @@ #include <mbgl/style/conversion/geojson_options.hpp> #include <mbgl/test/conversion_stubs.hpp> -#include <mbgl/platform/log.hpp> +#include <mbgl/util/logging.hpp> using namespace mbgl::style; using namespace mbgl::style::conversion; @@ -17,7 +17,7 @@ TEST(GeoJSONOptions, Basic) { } TEST(GeoJSONOptions, ErrorHandling) { - ValueMap map {{"maxzoom", "should not be a string"}}; + ValueMap map {{"maxzoom", std::string{"should not be a string"}}}; Value raw(map); Result<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw); ASSERT_FALSE((bool) converted); @@ -44,14 +44,14 @@ TEST(GeoJSONOptions, RetainsDefaults) { TEST(GeoJSONOptions, FullConversion) { ValueMap map { //GeoJSON-VT - {"maxzoom", 1}, - {"buffer", 2}, - {"tolerance", 3}, + {"maxzoom", 1.0f}, + {"buffer", 2.0f}, + {"tolerance", 3.0f}, //Supercluster {"cluster", true}, - {"clusterRadius", 4}, - {"clusterMaxZoom", 5} + {"clusterRadius", 4.0f}, + {"clusterMaxZoom", 5.0f} }; Value raw(map); GeoJSONOptions converted = *convert<GeoJSONOptions>(raw); diff --git a/test/style/conversion/stringify.test.cpp b/test/style/conversion/stringify.test.cpp new file mode 100644 index 0000000000..be5d65d4ce --- /dev/null +++ b/test/style/conversion/stringify.test.cpp @@ -0,0 +1,98 @@ +#include <mbgl/test/util.hpp> + +#include <mbgl/style/conversion/stringify.hpp> +#include <mbgl/style/types.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> +#include <mbgl/util/rapidjson.hpp> + +#include <rapidjson/writer.h> +#include <rapidjson/stringbuffer.h> + +using namespace mbgl; +using namespace mbgl::style; +using namespace mbgl::style::conversion; + +template <class T> +std::string stringify(const T& t) { + rapidjson::StringBuffer s; + rapidjson::Writer<rapidjson::StringBuffer> writer(s); + stringify(writer, t); + return s.GetString(); +} + +TEST(Stringify, NullValue) { + ASSERT_EQ(stringify(NullValue()), "null"); +} + +TEST(Stringify, Boolean) { + ASSERT_EQ(stringify(true), "true"); + ASSERT_EQ(stringify(false), "false"); +} + +TEST(Stringify, Uint64) { + ASSERT_EQ(stringify(uint64_t(0)), "0"); + ASSERT_EQ(stringify(uint64_t(1)), "1"); +} + +TEST(Stringify, Int64) { + ASSERT_EQ(stringify(int64_t(0)), "0"); + ASSERT_EQ(stringify(int64_t(-1)), "-1"); +} + +TEST(Stringify, Double) { + ASSERT_EQ(stringify(0.0), "0.0"); + ASSERT_EQ(stringify(10.1234), "10.1234"); +} + +TEST(Stringify, String) { + ASSERT_EQ(stringify(std::string("test")), "\"test\""); +} + +TEST(Stringify, Enum) { + ASSERT_EQ(stringify(VisibilityType::Visible), "\"visible\""); +} + +TEST(Stringify, Color) { + ASSERT_EQ(stringify(Color::blue()), "\"rgba(0,0,255,1)\""); +} + +TEST(Stringify, Array) { + ASSERT_EQ(stringify(std::array<float, 2> {{ 1, 2 }}), "[1.0,2.0]"); +} + +TEST(Stringify, Vector) { + ASSERT_EQ(stringify(std::vector<float> {{ 1, 2 }}), "[1.0,2.0]"); +} + +TEST(Stringify, Map) { + ASSERT_EQ(stringify(std::unordered_map<std::string, float> {{ "a", 1 }}), "{\"a\":1.0}"); +} + +TEST(Stringify, Value) { + ASSERT_EQ(stringify(Value(true)), "true"); + ASSERT_EQ(stringify(Value(uint64_t(0))), "0"); + ASSERT_EQ(stringify(Value(1.2)), "1.2"); +} + +TEST(Stringify, Filter) { + ASSERT_EQ(stringify(NullFilter()), "null"); + ASSERT_EQ(stringify(EqualsFilter { "a", 1.0 }), "[\"==\",\"a\",1.0]"); +} + +TEST(Stringify, Function) { + ASSERT_EQ(stringify(Function<float>({{0, 1}}, 2)), "{\"base\":2.0,\"stops\":[[0.0,1.0]]}"); +} + +TEST(Stringify, PropertyValue) { + ASSERT_EQ(stringify(PropertyValue<float>(1)), "1.0"); + ASSERT_EQ(stringify(PropertyValue<float>(Function<float>({{0, 1}}, 2))), "{\"base\":2.0,\"stops\":[[0.0,1.0]]}"); +} + +TEST(Stringify, Layout) { + ASSERT_EQ(stringify(SymbolLayoutProperties()), "{}"); + + SymbolLayoutProperties layout; + layout.unevaluated.get<SymbolAvoidEdges>() = true; + layout.unevaluated.get<IconPadding>() = 2.0; + ASSERT_EQ(stringify(layout), "{\"symbol-avoid-edges\":true,\"icon-padding\":2.0}"); +} diff --git a/test/style/filter.test.cpp b/test/style/filter.test.cpp index b49f424a39..33b64978f5 100644 --- a/test/style/filter.test.cpp +++ b/test/style/filter.test.cpp @@ -42,7 +42,7 @@ TEST(Filter, EqualsNumber) { ASSERT_FALSE(f(feature({{ "foo", std::string("0") }}))); ASSERT_FALSE(f(feature({{ "foo", false }}))); ASSERT_FALSE(f(feature({{ "foo", true }}))); - ASSERT_FALSE(f(feature({{ "foo", nullptr }}))); + ASSERT_FALSE(f(feature({{ "foo", mapbox::geometry::null_value }}))); ASSERT_FALSE(f(feature({{}}))); } @@ -113,13 +113,13 @@ TEST(Filter, NotHas) { TEST(Filter, ID) { Feature feature1 { Point<double>() }; - feature1.id = { 1234 }; + feature1.id = { uint64_t(1234) }; ASSERT_TRUE(parse("[\"==\", \"$id\", 1234]")(feature1)); ASSERT_FALSE(parse("[\"==\", \"$id\", \"1234\"]")(feature1)); Feature feature2 { Point<double>() }; - feature2.properties["id"] = { 1234 }; + feature2.properties["id"] = { uint64_t(1234) }; ASSERT_FALSE(parse("[\"==\", \"$id\", 1234]")(feature2)); } diff --git a/test/style/functions.test.cpp b/test/style/functions.test.cpp index 9577bcc633..8553d13349 100644 --- a/test/style/functions.test.cpp +++ b/test/style/functions.test.cpp @@ -2,28 +2,31 @@ #include <mbgl/test/util.hpp> #include <mbgl/style/property_evaluator.hpp> -#include <mbgl/style/calculation_parameters.hpp> +#include <mbgl/style/property_evaluation_parameters.hpp> using namespace mbgl; using namespace mbgl::style; float evaluate(PropertyValue<float> value, float zoom) { - return PropertyValue<float>::visit(value, PropertyEvaluator<float>(CalculationParameters(zoom), 0)); + return value.evaluate(PropertyEvaluator<float>(PropertyEvaluationParameters(zoom), 0)); } std::string evaluate(PropertyValue<std::string> value, float zoom) { - return PropertyValue<std::string>::visit(value, PropertyEvaluator<std::string>(CalculationParameters(zoom), "")); + return value.evaluate(PropertyEvaluator<std::string>(PropertyEvaluationParameters(zoom), "")); +} +bool evaluate(PropertyValue<bool> value, float zoom) { + return value.evaluate(PropertyEvaluator<bool>(PropertyEvaluationParameters(zoom), false)); } TEST(Function, Constant) { - EXPECT_EQ(2.0f, evaluate(2, 0)); - EXPECT_EQ(3.8f, evaluate(3.8, 0)); - EXPECT_EQ(22.0f, evaluate(22, 0)); - EXPECT_EQ(2.0f, evaluate(2, 4)); - EXPECT_EQ(3.8f, evaluate(3.8, 4)); - EXPECT_EQ(22.0f, evaluate(22, 4)); - EXPECT_EQ(2.0f, evaluate(2, 22)); - EXPECT_EQ(3.8f, evaluate(3.8, 22)); - EXPECT_EQ(22.0f, evaluate(22, 22)); + EXPECT_EQ(2.0f, evaluate(PropertyValue<float>(2.0), 0)); + EXPECT_EQ(3.8f, evaluate(PropertyValue<float>(3.8), 0)); + EXPECT_EQ(22.0f, evaluate(PropertyValue<float>(22.0), 0)); + EXPECT_EQ(2.0f, evaluate(PropertyValue<float>(2.0), 4)); + EXPECT_EQ(3.8f, evaluate(PropertyValue<float>(3.8), 4)); + EXPECT_EQ(22.0f, evaluate(PropertyValue<float>(22.0), 4)); + EXPECT_EQ(2.0f, evaluate(PropertyValue<float>(2.0), 22)); + EXPECT_EQ(3.8f, evaluate(PropertyValue<float>(3.8), 22)); + EXPECT_EQ(22.0f, evaluate(PropertyValue<float>(22.0), 22)); } TEST(Function, Stops) { @@ -50,12 +53,6 @@ TEST(Function, Stops) { EXPECT_EQ(3.0, evaluate(slope_2, 15)); EXPECT_EQ(3.0, evaluate(slope_2, 22)); - // Test no values. - Function<float> slope_3({}, 1.75); - EXPECT_EQ(1, evaluate(slope_3, 2)); - EXPECT_EQ(1, evaluate(slope_3, 6)); - EXPECT_EQ(1, evaluate(slope_3, 12)); - // Explicit constant slope in fringe regions. Function<float> slope_4({ { 0, 2 }, { 8, 10 } }, 1); @@ -66,10 +63,17 @@ TEST(Function, Stops) { EXPECT_EQ(10, evaluate(slope_4, 8)); // discrete values - Function<std::string> discrete_0({{ 3, "string0"}, {6, "string1"}, {9, "string2"}}, 1); + Function<std::string> discrete_0({{3, "string0"}, {6, "string1"}, {9, "string2"}}, 1); EXPECT_EQ("string0", evaluate(discrete_0, 2)); EXPECT_EQ("string0", evaluate(discrete_0, 4)); EXPECT_EQ("string1", evaluate(discrete_0, 7)); EXPECT_EQ("string2", evaluate(discrete_0, 9)); EXPECT_EQ("string2", evaluate(discrete_0, 10)); + + Function<bool> discreteBool({{1, false}, {3, true}}, 1); + EXPECT_FALSE(evaluate(discreteBool, 0)); + EXPECT_FALSE(evaluate(discreteBool, 1)); + EXPECT_FALSE(evaluate(discreteBool, 2)); + EXPECT_TRUE(evaluate(discreteBool, 3)); + EXPECT_TRUE(evaluate(discreteBool, 4)); } diff --git a/test/style/group_by_layout.test.cpp b/test/style/group_by_layout.test.cpp new file mode 100644 index 0000000000..600ba6a0f1 --- /dev/null +++ b/test/style/group_by_layout.test.cpp @@ -0,0 +1,44 @@ +#include <mbgl/test/util.hpp> + +#include <mbgl/style/group_by_layout.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/line_layer.hpp> + +using namespace mbgl; +using namespace mbgl::style; + +TEST(GroupByLayout, Related) { + std::vector<std::unique_ptr<Layer>> layers; + layers.push_back(std::make_unique<LineLayer>("a", "source")); + layers.push_back(std::make_unique<LineLayer>("b", "source")); + auto result = groupByLayout(layers); + ASSERT_EQ(1u, result.size()); + ASSERT_EQ(2u, result[0].size()); +} + +TEST(GroupByLayout, UnrelatedType) { + std::vector<std::unique_ptr<Layer>> layers; + layers.push_back(std::make_unique<BackgroundLayer>("background")); + layers.push_back(std::make_unique<CircleLayer>("circle", "source")); + auto result = groupByLayout(layers); + ASSERT_EQ(2u, result.size()); +} + +TEST(GroupByLayout, UnrelatedFilter) { + std::vector<std::unique_ptr<Layer>> layers; + layers.push_back(std::make_unique<LineLayer>("a", "source")); + layers.push_back(std::make_unique<LineLayer>("b", "source")); + layers[0]->as<LineLayer>()->setFilter(EqualsFilter()); + auto result = groupByLayout(layers); + ASSERT_EQ(2u, result.size()); +} + +TEST(GroupByLayout, UnrelatedLayout) { + std::vector<std::unique_ptr<Layer>> layers; + layers.push_back(std::make_unique<LineLayer>("a", "source")); + layers.push_back(std::make_unique<LineLayer>("b", "source")); + layers[0]->as<LineLayer>()->setLineCap(LineCapType::Square); + auto result = groupByLayout(layers); + ASSERT_EQ(2u, result.size()); +} diff --git a/test/style/paint_property.test.cpp b/test/style/paint_property.test.cpp new file mode 100644 index 0000000000..487dbe9652 --- /dev/null +++ b/test/style/paint_property.test.cpp @@ -0,0 +1,94 @@ +#include <mbgl/test/util.hpp> + +#include <mbgl/style/paint_property.hpp> + +using namespace mbgl; +using namespace mbgl::style; +using namespace std::literals::chrono_literals; + +TEST(UnevaluatedPaintProperty, EvaluateDefaultValue) { + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> property; + ASSERT_EQ(0.0f, property.evaluate(PropertyEvaluationParameters(0), 0.0f)); +} + +TEST(UnevaluatedPaintProperty, EvaluateUntransitionedConstant) { + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> property { + PropertyValue<float>(1.0f), + UnevaluatedPaintProperty<float, PropertyEvaluator<float>>(), + TransitionOptions(), + TimePoint::min() + }; + + ASSERT_EQ(1.0f, property.evaluate(PropertyEvaluationParameters(0), 0.0f)); +} + +TEST(UnevaluatedPaintProperty, EvaluateTransitionedConstantWithoutDelay) { + TransitionOptions transition; + transition.duration = { 1000ms }; + + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> t0 { + PropertyValue<float>(0.0f), + UnevaluatedPaintProperty<float, PropertyEvaluator<float>>(), + TransitionOptions(), + TimePoint::min() + }; + + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> t1 { + PropertyValue<float>(1.0f), + t0, + transition, + TimePoint::min() + }; + + auto evaluate = [&] (Duration delta) { + PropertyEvaluationParameters parameters { + 0, + TimePoint::min() + delta, + ZoomHistory(), + Duration::zero() + }; + + return t1.evaluate(parameters, 0.0f); + }; + + ASSERT_FLOAT_EQ(0.0f, evaluate(0ms)); + ASSERT_FLOAT_EQ(0.823099f, evaluate(500ms)); + ASSERT_FLOAT_EQ(1.0f, evaluate(1500ms)); +} + +TEST(UnevaluatedPaintProperty, EvaluateTransitionedConstantWithDelay) { + TransitionOptions transition; + transition.delay = { 1000ms }; + transition.duration = { 1000ms }; + + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> t0 { + PropertyValue<float>(0.0f), + UnevaluatedPaintProperty<float, PropertyEvaluator<float>>(), + TransitionOptions(), + TimePoint::min() + }; + + UnevaluatedPaintProperty<float, PropertyEvaluator<float>> t1 { + PropertyValue<float>(1.0f), + t0, + transition, + TimePoint::min() + }; + + auto evaluate = [&] (Duration delta) { + PropertyEvaluationParameters parameters { + 0, + TimePoint::min() + delta, + ZoomHistory(), + Duration::zero() + }; + + return t1.evaluate(parameters, 0.0f); + }; + + ASSERT_FLOAT_EQ(0.0f, evaluate(0ms)); + ASSERT_FLOAT_EQ(0.0f, evaluate(500ms)); + ASSERT_FLOAT_EQ(0.0f, evaluate(612ms)); + ASSERT_FLOAT_EQ(0.823099f, evaluate(1500ms)); + ASSERT_FLOAT_EQ(1.0f, evaluate(2500ms)); +} diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp index 73908a144b..01f54d6b18 100644 --- a/test/style/source.test.cpp +++ b/test/style/source.test.cpp @@ -11,8 +11,8 @@ #include <mbgl/util/string.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/tileset.hpp> -#include <mbgl/platform/default/thread_pool.hpp> -#include <mbgl/platform/log.hpp> +#include <mbgl/util/default_thread_pool.hpp> +#include <mbgl/util/logging.hpp> #include <mbgl/map/transform.hpp> #include <mbgl/style/style.hpp> @@ -50,7 +50,7 @@ public: // Squelch logging. Log::setObserver(std::make_unique<Log::NullObserver>()); - transform.resize({{ 512, 512 }}); + transform.resize({ 512, 512 }); transform.setLatLngZoom({0, 0}, 0); transformState = transform.getState(); |