Merge branch 'master' into new-labelling

Conflicts:
	src/mbgl/map/tile_parser.cpp
	src/mbgl/map/tile_parser.hpp
	src/mbgl/renderer/painter.hpp
	src/mbgl/renderer/painter_symbol.cpp
	src/mbgl/renderer/symbol_bucket.cpp
	src/mbgl/renderer/symbol_bucket.hpp
	src/mbgl/text/collision.cpp
	src/mbgl/text/collision.hpp
	src/mbgl/text/placement.cpp

6 files changed, 368 insertions, 0 deletions

diff --git a/test/miscellaneous/binpack.cpp b/test/miscellaneous/binpack.cpp
new file mode 100644
index 0000000000..a597f0a299
--- /dev/null
+++ b/test/miscellaneous/binpack.cpp
@@ -0,0 +1,51 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/geometry/binpack.hpp>
+
+#include <iosfwd>
+#include <array>
+
+namespace mbgl {
+template <typename T> ::std::ostream& operator<<(::std::ostream& os, const Rect<T>& t) {
+    return os << "Rect { " << t.x << ", " << t.y << ", " << t.w << ", " << t.h << " }";
+}
+}
+
+TEST(BinPack, Allocating) {
+    mbgl::BinPack<uint16_t> bin(128, 128);
+    std::array<mbgl::Rect<uint16_t>, 4> rects;
+
+    rects[0] = bin.allocate(32, 48);
+    ASSERT_EQ(mbgl::Rect<uint16_t>(0, 0, 32, 48), rects[0]);
+    rects[1] = bin.allocate(8, 17);
+    ASSERT_EQ(mbgl::Rect<uint16_t>(32, 0, 8, 17), rects[1]);
+    rects[2] = bin.allocate(8, 17);
+    ASSERT_EQ(mbgl::Rect<uint16_t>(0, 48, 8, 17), rects[2]);
+
+    bin.release(rects[0]);
+    rects[0] = bin.allocate(32, 24);
+    ASSERT_EQ(mbgl::Rect<uint16_t>(0, 0, 32, 24), rects[0]);
+    rects[3] = bin.allocate(32, 24);
+    ASSERT_EQ(mbgl::Rect<uint16_t>(32, 17, 32, 24), rects[3]);
+}
+
+
+TEST(BinPack, Full) {
+    mbgl::BinPack<uint16_t> bin(128, 128);
+    std::vector<mbgl::Rect<uint16_t>> rects;
+
+    for (int j = 0; j < 3; j++) {
+        for (int i = 0; i < 256; i++) {
+            auto rect = bin.allocate(8, 8);
+            ASSERT_TRUE(rect.hasArea());
+            rects.push_back(rect);
+        }
+
+        ASSERT_FALSE(bin.allocate(8, 8).hasArea());
+
+        for (auto& rect: rects) {
+            bin.release(rect);
+        }
+        rects.clear();
+    }
+}
diff --git a/test/miscellaneous/comparisons.cpp b/test/miscellaneous/comparisons.cpp
index 315416c135..afb3990f80 100644
--- a/test/miscellaneous/comparisons.cpp
+++ b/test/miscellaneous/comparisons.cpp
@@ -72,6 +72,13 @@ TEST(FilterComparison, EqualsType) {
     ASSERT_TRUE(evaluate(f, {{}}, FeatureType::LineString));
 }
 
+TEST(FilterComparison, InType) {
+    FilterExpression f = parse("[\"in\", \"$type\", \"LineString\", \"Polygon\"]");
+    ASSERT_FALSE(evaluate(f, {{}}, FeatureType::Point));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::LineString));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::Polygon));
+}
+
 TEST(FilterComparison, Any) {
     ASSERT_FALSE(evaluate(parse("[\"any\"]"), {{}}));
     ASSERT_TRUE(evaluate(parse("[\"any\", [\"==\", \"foo\", 1]]"),
diff --git a/test/miscellaneous/map.cpp b/test/miscellaneous/map.cpp
new file mode 100644
index 0000000000..b8707f3902
--- /dev/null
+++ b/test/miscellaneous/map.cpp
@@ -0,0 +1,59 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/map/map.hpp>
+#include <mbgl/platform/default/headless_view.hpp>
+#include <mbgl/platform/default/headless_display.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+
+using namespace mbgl;
+
+TEST(Map, PauseResume) {
+    using namespace mbgl;
+
+    auto display = std::make_shared<mbgl::HeadlessDisplay>();
+    HeadlessView view(display);
+    DefaultFileSource fileSource(nullptr);
+
+    Map map(view, fileSource, MapMode::Continuous);
+
+    map.pause();
+    map.resume();
+}
+
+TEST(Map, DoublePause) {
+    using namespace mbgl;
+
+    auto display = std::make_shared<mbgl::HeadlessDisplay>();
+    HeadlessView view(display);
+    DefaultFileSource fileSource(nullptr);
+
+    Map map(view, fileSource, MapMode::Continuous);
+
+    map.pause();
+    map.pause();
+    map.resume();
+}
+
+TEST(Map, ResumeWithoutPause) {
+    using namespace mbgl;
+
+    auto display = std::make_shared<mbgl::HeadlessDisplay>();
+    HeadlessView view(display);
+    DefaultFileSource fileSource(nullptr);
+
+    Map map(view, fileSource, MapMode::Continuous);
+
+    map.resume();
+}
+
+TEST(Map, DestroyPaused) {
+    using namespace mbgl;
+
+    auto display = std::make_shared<mbgl::HeadlessDisplay>();
+    HeadlessView view(display);
+    DefaultFileSource fileSource(nullptr);
+
+    Map map(view, fileSource, MapMode::Continuous);
+
+    map.pause();
+}
diff --git a/test/miscellaneous/map_context.cpp b/test/miscellaneous/map_context.cpp
new file mode 100644
index 0000000000..ed51923036
--- /dev/null
+++ b/test/miscellaneous/map_context.cpp
@@ -0,0 +1,22 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/map/map_data.hpp>
+#include <mbgl/map/map_context.hpp>
+#include <mbgl/platform/default/headless_view.hpp>
+#include <mbgl/platform/default/headless_display.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/util/thread.hpp>
+
+using namespace mbgl;
+
+TEST(MapContext, DoubleStyleLoad) {
+    std::shared_ptr<HeadlessDisplay> display = std::make_shared<HeadlessDisplay>();
+    HeadlessView view(display, 512, 512, 1);
+    DefaultFileSource fileSource(nullptr);
+    MapData data(view, MapMode::Continuous);
+
+    util::Thread<MapContext> context("Map", util::ThreadPriority::Regular, view, fileSource, data);
+
+    context.invokeSync(&MapContext::setStyleJSON, "", "");
+    context.invokeSync(&MapContext::setStyleJSON, "", "");
+}
diff --git a/test/miscellaneous/transform.cpp b/test/miscellaneous/transform.cpp
new file mode 100644
index 0000000000..6025cbce40
--- /dev/null
+++ b/test/miscellaneous/transform.cpp
@@ -0,0 +1,125 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/util/run_loop.hpp>
+#include <mbgl/map/map_data.hpp>
+#include <mbgl/map/map_context.hpp>
+#include <mbgl/platform/default/headless_view.hpp>
+#include <mbgl/platform/default/headless_display.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+
+#include <cstdlib>
+
+using namespace mbgl;
+
+class MockView : public View {
+public:
+    void activate() override {
+    }
+    void deactivate() override {
+    }
+    void notify() override {
+    }
+    void invalidate(std::function<void()>) override {
+    }
+};
+
+TEST(Transform, InvalidScale) {
+    MockView view;
+    Transform transform(view);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(1, transform.getScale());
+
+    transform.setScale(2);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+
+    const double invalid = std::nan("");
+    transform.setScale(invalid);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+
+    transform.scaleBy(invalid);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+
+    transform.setZoom(invalid);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+
+    transform.setLatLngZoom({ 0, 0 }, invalid);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+}
+
+TEST(Transform, InvalidLatLng) {
+    MockView view;
+    Transform transform(view);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(1, transform.getScale());
+
+    transform.setScale(2);
+    transform.setLatLng({ 8, 10 });
+
+    ASSERT_DOUBLE_EQ(8, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(10, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+
+    transform.setLatLngZoom({ 10, 8 }, 2);
+
+    ASSERT_DOUBLE_EQ(10, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(8, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(4, transform.getScale());
+
+    const double invalid = std::nan("");
+    transform.setLatLngZoom({ invalid, 8 }, 2);
+
+    ASSERT_DOUBLE_EQ(10, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(8, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(4, transform.getScale());
+
+    transform.setLatLngZoom({ 10, invalid }, 2);
+
+    ASSERT_DOUBLE_EQ(10, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(8, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(4, transform.getScale());
+}
+
+
+TEST(Transform, InvalidBearing) {
+    MockView view;
+    Transform transform(view);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(1, transform.getScale());
+
+    transform.setScale(2);
+    transform.setAngle(2);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+    ASSERT_DOUBLE_EQ(2, transform.getAngle());
+
+    const double invalid = std::nan("");
+    transform.setAngle(invalid);
+
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude);
+    ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude);
+    ASSERT_DOUBLE_EQ(2, transform.getScale());
+    ASSERT_DOUBLE_EQ(2, transform.getAngle());
+}
diff --git a/test/miscellaneous/worker.cpp b/test/miscellaneous/worker.cpp
new file mode 100644
index 0000000000..3d3c781b8c
--- /dev/null
+++ b/test/miscellaneous/worker.cpp
@@ -0,0 +1,104 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/util/worker.hpp>
+#include <mbgl/util/work_request.hpp>
+#include <mbgl/util/run_loop.hpp>
+
+using namespace mbgl;
+using namespace mbgl::util;
+
+TEST(Worker, ExecutesWorkAndAfter) {
+    RunLoop loop(uv_default_loop());
+
+    Worker worker(1);
+    std::unique_ptr<WorkRequest> request;
+
+    bool didWork = false;
+    bool didAfter = false;
+
+    loop.invoke([&] {
+        request = worker.send([&] {
+            didWork = true;
+        }, [&] {
+            didAfter = true;
+            loop.stop();
+        });
+    });
+
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+    EXPECT_TRUE(didWork);
+    EXPECT_TRUE(didAfter);
+}
+
+TEST(Worker, WorkRequestDeletionWaitsForWorkToComplete) {
+    RunLoop loop(uv_default_loop());
+
+    Worker worker(1);
+    std::promise<void> started;
+    bool didWork = false;
+
+    loop.invoke([&] {
+        auto request = worker.send([&] {
+            started.set_value();
+            usleep(10000);
+            didWork = true;
+        }, [&] {});
+        started.get_future().get();
+
+        request.reset();
+        EXPECT_TRUE(didWork);
+        loop.stop();
+    });
+
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+}
+
+TEST(Worker, WorkRequestJoinCancelsAfter) {
+    RunLoop loop(uv_default_loop());
+
+    Worker worker(1);
+    std::promise<void> started;
+    bool didAfter = false;
+
+    loop.invoke([&] {
+        auto request = worker.send([&] {
+            started.set_value();
+        }, [&] {
+            didAfter = true;
+        });
+        started.get_future().get();
+
+        request.reset();
+        loop.stop();
+    });
+
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+    EXPECT_FALSE(didAfter);
+}
+
+TEST(Worker, WorkRequestCancelsImmediately) {
+    RunLoop loop(uv_default_loop());
+
+    Worker worker(1);
+
+    loop.invoke([&] {
+        std::promise<void> started;
+        // First worker item.
+        auto request1 = worker.send([&] {
+            usleep(10000);
+            started.set_value();
+        }, [&] {});
+
+        auto request2 = worker.send([&] {
+            ADD_FAILURE() << "Second work item should not be invoked";
+        }, [&] {});
+        request2.reset();
+
+        started.get_future().get();
+        request1.reset();
+
+        loop.stop();
+    });
+
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+}