From acae19386129056b9425b114b01f062feecd297e Mon Sep 17 00:00:00 2001
From: Asheem Mamoowala <asheem.mamoowala@mapbox.com>
Date: Wed, 22 Nov 2017 10:18:53 -0800
Subject: [PATCH] [core] Custom Geometry Sources

---
 cmake/core-files.cmake                        |  11 ++
 cmake/test-files.cmake                        |   2 +
 .../custom_geometry_source_options.hpp        |  64 +++++++++
 .../style/sources/custom_geometry_source.hpp  |  56 ++++++++
 include/mbgl/style/sources/geojson_source.hpp |   2 +
 include/mbgl/style/types.hpp                  |   3 +-
 .../default/mbgl/storage/offline_download.cpp |   2 +
 src/mbgl/renderer/render_source.cpp           |   3 +
 .../sources/render_custom_geometry_source.cpp |  86 ++++++++++++
 .../sources/render_custom_geometry_source.hpp |  50 +++++++
 src/mbgl/style/custom_tile_loader.cpp         | 114 +++++++++++++++
 src/mbgl/style/custom_tile_loader.hpp         |  47 +++++++
 .../style/sources/custom_geometry_source.cpp  |  45 ++++++
 .../sources/custom_geometry_source_impl.cpp   |  40 ++++++
 .../sources/custom_geometry_source_impl.hpp   |  29 ++++
 src/mbgl/style/types.cpp                      |   1 +
 src/mbgl/tile/custom_geometry_tile.cpp        |  81 +++++++++++
 src/mbgl/tile/custom_geometry_tile.hpp        |  34 +++++
 test/api/custom_geometry_source.test.cpp      |  71 ++++++++++
 .../custom_geometry_source/grid/expected.png  | Bin 0 -> 8302 bytes
 test/style/source.test.cpp                    |  37 +++++
 test/tile/custom_geometry_tile.test.cpp       | 130 ++++++++++++++++++
 22 files changed, 907 insertions(+), 1 deletion(-)
 create mode 100644 include/mbgl/style/conversion/custom_geometry_source_options.hpp
 create mode 100644 include/mbgl/style/sources/custom_geometry_source.hpp
 create mode 100644 src/mbgl/renderer/sources/render_custom_geometry_source.cpp
 create mode 100644 src/mbgl/renderer/sources/render_custom_geometry_source.hpp
 create mode 100644 src/mbgl/style/custom_tile_loader.cpp
 create mode 100644 src/mbgl/style/custom_tile_loader.hpp
 create mode 100644 src/mbgl/style/sources/custom_geometry_source.cpp
 create mode 100644 src/mbgl/style/sources/custom_geometry_source_impl.cpp
 create mode 100644 src/mbgl/style/sources/custom_geometry_source_impl.hpp
 create mode 100644 src/mbgl/tile/custom_geometry_tile.cpp
 create mode 100644 src/mbgl/tile/custom_geometry_tile.hpp
 create mode 100644 test/api/custom_geometry_source.test.cpp
 create mode 100644 test/fixtures/custom_geometry_source/grid/expected.png
 create mode 100644 test/tile/custom_geometry_tile.test.cpp

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index 2af07f48c..42c25c8ea 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -242,6 +242,8 @@ set(MBGL_CORE_FILES
     src/mbgl/renderer/layers/render_symbol_layer.hpp
 
     # renderer/sources
+    src/mbgl/renderer/sources/render_custom_geometry_source.cpp
+    src/mbgl/renderer/sources/render_custom_geometry_source.hpp
     src/mbgl/renderer/sources/render_geojson_source.cpp
     src/mbgl/renderer/sources/render_geojson_source.hpp
     src/mbgl/renderer/sources/render_image_source.cpp
@@ -334,6 +336,8 @@ set(MBGL_CORE_FILES
     include/mbgl/style/types.hpp
     include/mbgl/style/undefined.hpp
     src/mbgl/style/collection.hpp
+    src/mbgl/style/custom_tile_loader.cpp
+    src/mbgl/style/custom_tile_loader.hpp
     src/mbgl/style/image.cpp
     src/mbgl/style/image_impl.cpp
     src/mbgl/style/image_impl.hpp
@@ -364,6 +368,7 @@ set(MBGL_CORE_FILES
     # style/conversion
     include/mbgl/style/conversion/constant.hpp
     include/mbgl/style/conversion/coordinate.hpp
+    include/mbgl/style/conversion/custom_geometry_source_options.hpp
     include/mbgl/style/conversion/data_driven_property_value.hpp
     include/mbgl/style/conversion/expression.hpp
     include/mbgl/style/conversion/filter.hpp
@@ -506,10 +511,14 @@ set(MBGL_CORE_FILES
     src/mbgl/style/layers/symbol_layer_properties.hpp
 
     # style/sources
+    include/mbgl/style/sources/custom_geometry_source.hpp
     include/mbgl/style/sources/geojson_source.hpp
     include/mbgl/style/sources/image_source.hpp
     include/mbgl/style/sources/raster_source.hpp
     include/mbgl/style/sources/vector_source.hpp
+    src/mbgl/style/sources/custom_geometry_source.cpp
+    src/mbgl/style/sources/custom_geometry_source_impl.cpp
+    src/mbgl/style/sources/custom_geometry_source_impl.hpp
     src/mbgl/style/sources/geojson_source.cpp
     src/mbgl/style/sources/geojson_source_impl.cpp
     src/mbgl/style/sources/geojson_source_impl.hpp
@@ -555,6 +564,8 @@ set(MBGL_CORE_FILES
     # tile
     include/mbgl/tile/tile_id.hpp
     include/mbgl/tile/tile_necessity.hpp
+    src/mbgl/tile/custom_geometry_tile.cpp
+    src/mbgl/tile/custom_geometry_tile.hpp
     src/mbgl/tile/geojson_tile.cpp
     src/mbgl/tile/geojson_tile.hpp
     src/mbgl/tile/geojson_tile_data.hpp
diff --git a/cmake/test-files.cmake b/cmake/test-files.cmake
index b2ddc2b36..43bc1210f 100644
--- a/cmake/test-files.cmake
+++ b/cmake/test-files.cmake
@@ -15,6 +15,7 @@ set(MBGL_TEST_FILES
     # api
     test/api/annotations.test.cpp
     test/api/api_misuse.test.cpp
+    test/api/custom_geometry_source.test.cpp
     test/api/custom_layer.test.cpp
     test/api/query.test.cpp
     test/api/recycle_map.cpp
@@ -117,6 +118,7 @@ set(MBGL_TEST_FILES
     test/text/quads.test.cpp
 
     # tile
+    test/tile/custom_geometry_tile.test.cpp
     test/tile/geojson_tile.test.cpp
     test/tile/geometry_tile_data.test.cpp
     test/tile/raster_tile.test.cpp
diff --git a/include/mbgl/style/conversion/custom_geometry_source_options.hpp b/include/mbgl/style/conversion/custom_geometry_source_options.hpp
new file mode 100644
index 000000000..73b141e79
--- /dev/null
+++ b/include/mbgl/style/conversion/custom_geometry_source_options.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <>
+struct Converter<CustomGeometrySource::Options> {
+
+    template <class V>
+    optional<CustomGeometrySource::Options> operator()(const V& value, Error& error) const {
+        CustomGeometrySource::Options options;
+
+        const auto minzoomValue = objectMember(value, "minzoom");
+        if (minzoomValue) {
+            if (toNumber(*minzoomValue)) {
+                options.zoomRange.min = static_cast<uint8_t>(*toNumber(*minzoomValue));
+            } else {
+                error = { "GeoJSON source minzoom value must be a number" };
+                return {};
+            }
+        }
+
+        const auto maxzoomValue = objectMember(value, "maxzoom");
+        if (maxzoomValue) {
+            if (toNumber(*maxzoomValue)) {
+                options.zoomRange.max = static_cast<uint8_t>(*toNumber(*maxzoomValue));
+            } else {
+                error = { "GeoJSON source maxzoom value must be a number" };
+                return {};
+            }
+        }
+
+        const auto bufferValue = objectMember(value, "buffer");
+        if (bufferValue) {
+            if (toNumber(*bufferValue)) {
+                options.tileOptions.buffer = static_cast<uint16_t>(*toNumber(*bufferValue));
+            } else {
+                error = { "GeoJSON source buffer value must be a number" };
+                return {};
+            }
+        }
+
+        const auto toleranceValue = objectMember(value, "tolerance");
+        if (toleranceValue) {
+            if (toNumber(*toleranceValue)) {
+                options.tileOptions.tolerance = static_cast<double>(*toNumber(*toleranceValue));
+            } else {
+                error = { "GeoJSON source tolerance value must be a number" };
+                return {};
+            }
+        }
+
+        return { options };
+    }
+
+};
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/sources/custom_geometry_source.hpp b/include/mbgl/style/sources/custom_geometry_source.hpp
new file mode 100644
index 000000000..853526ac2
--- /dev/null
+++ b/include/mbgl/style/sources/custom_geometry_source.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <mbgl/style/source.hpp>
+#include <mbgl/util/geo.hpp>
+#include <mbgl/util/geojson.hpp>
+#include <mbgl/util/range.hpp>
+#include <mbgl/util/constants.hpp>
+#include <mbgl/actor/mailbox.hpp>
+
+namespace mbgl {
+
+class OverscaledTileID;
+class CanonicalTileID;
+
+namespace style {
+
+using TileFunction = std::function<void(const CanonicalTileID&)>;
+
+class CustomTileLoader;
+
+class CustomGeometrySource : public Source {
+public:
+    struct TileOptions {
+        double tolerance = 0.375;
+        uint16_t tileSize = util::tileSize;
+        uint16_t buffer = 128;
+    };
+
+    struct Options {
+        TileFunction fetchTileFunction;
+        TileFunction cancelTileFunction;
+        Range<uint8_t> zoomRange = { 0, 18};
+        TileOptions tileOptions;
+    };
+public:
+    CustomGeometrySource(std::string id, CustomGeometrySource::Options options);
+    ~CustomGeometrySource() final;
+    void loadDescription(FileSource&) final;
+    void setTileData(const CanonicalTileID&, const GeoJSON&);
+    void invalidateTile(const CanonicalTileID&);
+    void invalidateRegion(const LatLngBounds&);
+    // Private implementation
+    class Impl;
+    const Impl& impl() const;
+private:
+    std::shared_ptr<Mailbox> mailbox;    
+    std::unique_ptr<CustomTileLoader> loader;
+};
+
+template <>
+inline bool Source::is<CustomGeometrySource>() const {
+    return getType() == SourceType::CustomVector;
+}
+
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/sources/geojson_source.hpp b/include/mbgl/style/sources/geojson_source.hpp
index 5bdf1ef95..372e7c7a7 100644
--- a/include/mbgl/style/sources/geojson_source.hpp
+++ b/include/mbgl/style/sources/geojson_source.hpp
@@ -3,6 +3,7 @@
 #include <mbgl/style/source.hpp>
 #include <mbgl/util/geojson.hpp>
 #include <mbgl/util/optional.hpp>
+#include <mbgl/util/constants.hpp>
 
 namespace mbgl {
 
@@ -14,6 +15,7 @@ struct GeoJSONOptions {
     // GeoJSON-VT options
     uint8_t minzoom = 0;
     uint8_t maxzoom = 18;
+    uint16_t tileSize = util::tileSize;
     uint16_t buffer = 128;
     double tolerance = 0.375;
 
diff --git a/include/mbgl/style/types.hpp b/include/mbgl/style/types.hpp
index 2ed95f08b..6fe457e18 100644
--- a/include/mbgl/style/types.hpp
+++ b/include/mbgl/style/types.hpp
@@ -13,7 +13,8 @@ enum class SourceType : uint8_t {
     GeoJSON,
     Video,
     Annotations,
-    Image
+    Image,
+    CustomVector
 };
 
 enum class VisibilityType : bool {
diff --git a/platform/default/mbgl/storage/offline_download.cpp b/platform/default/mbgl/storage/offline_download.cpp
index ff6111488..8bb16993a 100644
--- a/platform/default/mbgl/storage/offline_download.cpp
+++ b/platform/default/mbgl/storage/offline_download.cpp
@@ -129,6 +129,7 @@ OfflineRegionStatus OfflineDownload::getStatus() const {
 
         case SourceType::Video:
         case SourceType::Annotations:
+        case SourceType::CustomVector:
             break;
         }
     }
@@ -214,6 +215,7 @@ void OfflineDownload::activateDownload() {
 
             case SourceType::Video:
             case SourceType::Annotations:
+            case SourceType::CustomVector:
                 break;
             }
         }
diff --git a/src/mbgl/renderer/render_source.cpp b/src/mbgl/renderer/render_source.cpp
index 7723a1c7c..6624bb7d9 100644
--- a/src/mbgl/renderer/render_source.cpp
+++ b/src/mbgl/renderer/render_source.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/renderer/tile_parameters.hpp>
 #include <mbgl/annotation/render_annotation_source.hpp>
 #include <mbgl/renderer/sources/render_image_source.hpp>
+#include <mbgl/renderer/sources/render_custom_geometry_source.hpp>
 #include <mbgl/tile/tile.hpp>
 
 namespace mbgl {
@@ -27,6 +28,8 @@ std::unique_ptr<RenderSource> RenderSource::create(Immutable<Source::Impl> impl)
         return std::make_unique<RenderAnnotationSource>(staticImmutableCast<AnnotationSource::Impl>(impl));
     case SourceType::Image:
         return std::make_unique<RenderImageSource>(staticImmutableCast<ImageSource::Impl>(impl));
+    case SourceType::CustomVector:
+        return std::make_unique<RenderCustomGeometrySource>(staticImmutableCast<CustomGeometrySource::Impl>(impl));
     }
 
     // Not reachable, but placate GCC.
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
new file mode 100644
index 000000000..111f0234e
--- /dev/null
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
@@ -0,0 +1,86 @@
+#include <mbgl/renderer/sources/render_custom_geometry_source.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
+#include <mbgl/tile/custom_geometry_tile.hpp>
+
+#include <mbgl/algorithm/generate_clip_ids.hpp>
+#include <mbgl/algorithm/generate_clip_ids_impl.hpp>
+
+namespace mbgl {
+
+using namespace style;
+
+RenderCustomGeometrySource::RenderCustomGeometrySource(Immutable<style::CustomGeometrySource::Impl> impl_)
+    : RenderSource(impl_) {
+    tilePyramid.setObserver(this);
+}
+
+const style::CustomGeometrySource::Impl& RenderCustomGeometrySource::impl() const {
+    return static_cast<const style::CustomGeometrySource::Impl&>(*baseImpl);
+}
+
+bool RenderCustomGeometrySource::isLoaded() const {
+    return tilePyramid.isLoaded();
+}
+
+void RenderCustomGeometrySource::update(Immutable<style::Source::Impl> baseImpl_,
+                                 const std::vector<Immutable<Layer::Impl>>& layers,
+                                 const bool needsRendering,
+                                 const bool needsRelayout,
+                                 const TileParameters& parameters) {
+    std::swap(baseImpl, baseImpl_);
+
+    enabled = needsRendering;
+
+    auto tileLoader = impl().getTileLoader();
+    if (!tileLoader) {
+        return;
+    }
+
+    tilePyramid.update(layers,
+                       needsRendering,
+                       needsRelayout,
+                       parameters,
+                       SourceType::CustomVector,
+                       util::tileSize,
+                       impl().getZoomRange(),
+                       [&] (const OverscaledTileID& tileID) {
+                           return std::make_unique<CustomGeometryTile>(tileID, impl().id, parameters, impl().getTileOptions(), *tileLoader);
+                       });
+}
+
+void RenderCustomGeometrySource::startRender(PaintParameters& parameters) {
+    parameters.clipIDGenerator.update(tilePyramid.getRenderTiles());
+    tilePyramid.startRender(parameters);
+}
+
+void RenderCustomGeometrySource::finishRender(PaintParameters& parameters) {
+    tilePyramid.finishRender(parameters);
+}
+
+std::vector<std::reference_wrapper<RenderTile>> RenderCustomGeometrySource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
+}
+
+std::unordered_map<std::string, std::vector<Feature>>
+RenderCustomGeometrySource::queryRenderedFeatures(const ScreenLineString& geometry,
+                                           const TransformState& transformState,
+                                           const std::vector<const RenderLayer*>& layers,
+                                           const RenderedQueryOptions& options,
+                                           const CollisionIndex& collisionIndex) const {
+   return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, collisionIndex);
+}
+
+std::vector<Feature> RenderCustomGeometrySource::querySourceFeatures(const SourceQueryOptions& options) const {
+    return tilePyramid.querySourceFeatures(options);
+}
+
+void RenderCustomGeometrySource::onLowMemory() {
+    tilePyramid.onLowMemory();
+}
+
+void RenderCustomGeometrySource::dumpDebugLogs() const {
+    tilePyramid.dumpDebugLogs();
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
new file mode 100644
index 000000000..82e691d5c
--- /dev/null
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/tile_pyramid.hpp>
+#include <mbgl/style/sources/custom_geometry_source_impl.hpp>
+
+namespace mbgl {
+
+class RenderCustomGeometrySource : public RenderSource {
+public:
+    RenderCustomGeometrySource(Immutable<style::CustomGeometrySource::Impl>);
+
+    bool isLoaded() const final;
+
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
+
+    void startRender(PaintParameters&) final;
+    void finishRender(PaintParameters&) final;
+
+    std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
+
+    std::unordered_map<std::string, std::vector<Feature>>
+    queryRenderedFeatures(const ScreenLineString& geometry,
+                          const TransformState& transformState,
+                          const std::vector<const RenderLayer*>& layers,
+                          const RenderedQueryOptions& options,
+                          const CollisionIndex& collisionIndex) const final;
+
+    std::vector<Feature>
+    querySourceFeatures(const SourceQueryOptions&) const final;
+
+    void onLowMemory() final;
+    void dumpDebugLogs() const final;
+    
+private:
+    const style::CustomGeometrySource::Impl& impl() const;
+
+    TilePyramid tilePyramid;
+};
+
+template <>
+inline bool RenderSource::is<RenderCustomGeometrySource>() const {
+    return baseImpl->type == style::SourceType::CustomVector;
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/style/custom_tile_loader.cpp b/src/mbgl/style/custom_tile_loader.cpp
new file mode 100644
index 000000000..2fc94c9d5
--- /dev/null
+++ b/src/mbgl/style/custom_tile_loader.cpp
@@ -0,0 +1,114 @@
+#include <mbgl/style/custom_tile_loader.hpp>
+
+namespace mbgl {
+namespace style {
+
+CustomTileLoader::CustomTileLoader(const TileFunction& fetchTileFn, const TileFunction& cancelTileFn) {
+    fetchTileFunction = fetchTileFn;
+    cancelTileFunction = cancelTileFn;
+}
+
+void CustomTileLoader::fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef) {
+    std::lock_guard<std::mutex> lock(dataCacheMutex);
+    auto cachedTileData = dataCache.find(tileID.canonical);
+    if (cachedTileData != dataCache.end()) {
+        callbackRef.invoke(&SetTileDataFunction::operator(), *(cachedTileData->second));
+    }
+    auto tileCallbacks = tileCallbackMap.find(tileID.canonical);
+    if (tileCallbacks == tileCallbackMap.end()) {
+        auto tuple = std::make_tuple(tileID.overscaledZ, tileID.wrap, callbackRef);
+        tileCallbackMap.insert({ tileID.canonical, std::vector<OverscaledIDFunctionTuple>(1, tuple) });
+    } else {
+        for (auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
+            if (std::get<0>(*iter) == tileID.overscaledZ && std::get<1>(*iter) == tileID.wrap ) {
+                std::get<2>(*iter) = callbackRef;
+                return;
+            }
+        }
+        tileCallbacks->second.emplace_back(std::make_tuple(tileID.overscaledZ, tileID.wrap, callbackRef));
+    }
+    if (cachedTileData == dataCache.end()) {
+        invokeTileFetch(tileID.canonical);
+    }
+}
+
+void CustomTileLoader::cancelTile(const OverscaledTileID& tileID) {
+    if (tileCallbackMap.find(tileID.canonical) != tileCallbackMap.end()) {
+        invokeTileCancel(tileID.canonical);
+    }
+}
+
+void CustomTileLoader::removeTile(const OverscaledTileID& tileID) {
+    auto tileCallbacks = tileCallbackMap.find(tileID.canonical);
+    if (tileCallbacks == tileCallbackMap.end()) return;
+    for (auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
+        if (std::get<0>(*iter) == tileID.overscaledZ && std::get<1>(*iter) == tileID.wrap ) {
+            tileCallbacks->second.erase(iter);
+            invokeTileCancel(tileID.canonical);
+            break;
+        }
+    }
+    if (tileCallbacks->second.size() == 0) {
+        std::lock_guard<std::mutex> lock(dataCacheMutex);
+        tileCallbackMap.erase(tileCallbacks);
+        dataCache.erase(tileID.canonical);
+    }
+}
+
+void CustomTileLoader::setTileData(const CanonicalTileID& tileID, const GeoJSON& data) {
+    std::lock_guard<std::mutex> lock(dataCacheMutex);
+
+    auto iter = tileCallbackMap.find(tileID);
+    if (iter == tileCallbackMap.end()) return;
+    dataCache[tileID] = std::make_unique<mapbox::geojson::geojson>(std::move(data));;
+    for (auto tuple : iter->second) {
+        auto actor = std::get<2>(tuple);
+        actor.invoke(&SetTileDataFunction::operator(), data);
+    }
+}
+
+void CustomTileLoader::invalidateTile(const CanonicalTileID& tileID) {
+    auto tileCallbacks = tileCallbackMap.find(tileID);
+    if (tileCallbacks == tileCallbackMap.end()) { return; }
+    for (auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
+        auto actor = std::get<2>(*iter);
+        actor.invoke(&SetTileDataFunction::operator(), mapbox::geojson::feature_collection());
+        invokeTileCancel(tileID);
+    }
+    tileCallbackMap.erase(tileCallbacks);
+    {
+        std::lock_guard<std::mutex> lock(dataCacheMutex);
+        dataCache.erase(tileID);
+    }
+}
+
+void CustomTileLoader::invalidateRegion(const LatLngBounds& bounds, Range<uint8_t> ) {
+    for (auto idtuple= tileCallbackMap.begin(); idtuple != tileCallbackMap.end(); idtuple++) {
+        const LatLngBounds tileBounds(idtuple->first);
+        if (tileBounds.intersects(bounds) || bounds.contains(tileBounds) || tileBounds.contains(bounds)) {
+            for (auto iter = idtuple->second.begin(); iter != idtuple->second.end(); iter++) {
+                std::lock_guard<std::mutex> lock(dataCacheMutex);
+                auto actor = std::get<2>(*iter);
+                actor.invoke(&SetTileDataFunction::operator(), mapbox::geojson::feature_collection());
+                invokeTileCancel(idtuple->first);
+                dataCache.erase(idtuple->first);
+            }
+            idtuple->second.clear();
+        }
+    }
+}
+
+void CustomTileLoader::invokeTileFetch(const CanonicalTileID& tileID) {
+    if (fetchTileFunction != nullptr) {
+        fetchTileFunction(tileID);
+    }
+}
+
+void CustomTileLoader::invokeTileCancel(const CanonicalTileID& tileID) {
+    if (cancelTileFunction != nullptr) {
+        cancelTileFunction(tileID);
+    }
+}
+
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/custom_tile_loader.hpp b/src/mbgl/style/custom_tile_loader.hpp
new file mode 100644
index 000000000..fa3173ffc
--- /dev/null
+++ b/src/mbgl/style/custom_tile_loader.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/tile/tile_id.hpp>
+#include <mbgl/util/geo.hpp>
+#include <mbgl/util/geojson.hpp>
+#include <mbgl/actor/actor_ref.hpp>
+
+#include <map>
+#include <mutex>
+
+namespace mbgl {
+namespace style {
+
+using SetTileDataFunction = std::function<void(const GeoJSON&)>;
+
+class CustomTileLoader : private util::noncopyable {
+public:
+
+    using OverscaledIDFunctionTuple = std::tuple<uint8_t, int16_t, ActorRef<SetTileDataFunction>>;
+
+    CustomTileLoader(const TileFunction& fetchTileFn, const TileFunction& cancelTileFn);
+
+    void fetchTile(const OverscaledTileID& tileID, ActorRef<SetTileDataFunction> callbackRef);
+    void cancelTile(const OverscaledTileID& tileID);
+
+    void removeTile(const OverscaledTileID& tileID);
+    void setTileData(const CanonicalTileID& tileID, const GeoJSON& data);
+
+    void invalidateTile(const CanonicalTileID&);
+    void invalidateRegion(const LatLngBounds&, Range<uint8_t>);
+
+private:
+    void invokeTileFetch(const CanonicalTileID& tileID);
+    void invokeTileCancel(const CanonicalTileID& tileID);
+
+    TileFunction fetchTileFunction;
+    TileFunction cancelTileFunction;
+    std::unordered_map<CanonicalTileID, std::vector<OverscaledIDFunctionTuple>> tileCallbackMap;
+    // Keep around a cache of tile data to serve back for wrapped and over-zooomed tiles
+    std::map<CanonicalTileID, std::unique_ptr<GeoJSON>> dataCache;
+    std::mutex dataCacheMutex;
+
+};
+
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/sources/custom_geometry_source.cpp b/src/mbgl/style/sources/custom_geometry_source.cpp
new file mode 100644
index 000000000..657573b1f
--- /dev/null
+++ b/src/mbgl/style/sources/custom_geometry_source.cpp
@@ -0,0 +1,45 @@
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/style/custom_tile_loader.hpp>
+#include <mbgl/style/sources/custom_geometry_source_impl.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/tile/tile_id.hpp>
+
+#include <tuple>
+#include <map>
+
+namespace mbgl {
+namespace style {
+
+CustomGeometrySource::CustomGeometrySource(std::string id,
+                                       const CustomGeometrySource::Options options)
+    : Source(makeMutable<CustomGeometrySource::Impl>(std::move(id), options)),
+    mailbox(std::make_shared<Mailbox>(*Scheduler::GetCurrent())),
+    loader(std::make_unique<CustomTileLoader>(options.fetchTileFunction, options.cancelTileFunction)) {
+}
+
+CustomGeometrySource::~CustomGeometrySource() = default;
+
+const CustomGeometrySource::Impl& CustomGeometrySource::impl() const {
+    return static_cast<const CustomGeometrySource::Impl&>(*baseImpl);
+}
+
+void CustomGeometrySource::loadDescription(FileSource&) {
+    baseImpl = makeMutable<CustomGeometrySource::Impl>(impl(), ActorRef<CustomTileLoader>(*loader, mailbox));
+    loaded = true;
+}
+
+void CustomGeometrySource::setTileData(const CanonicalTileID& tileID,
+                                     const GeoJSON& data) {
+    loader->setTileData(tileID, data);
+}
+
+void CustomGeometrySource::invalidateTile(const CanonicalTileID& tileID) {
+    loader->invalidateTile(tileID);
+}
+
+void CustomGeometrySource::invalidateRegion(const LatLngBounds& bounds) {
+    loader->invalidateRegion(bounds, impl().getZoomRange());
+}
+    
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/sources/custom_geometry_source_impl.cpp b/src/mbgl/style/sources/custom_geometry_source_impl.cpp
new file mode 100644
index 000000000..67d52bdc2
--- /dev/null
+++ b/src/mbgl/style/sources/custom_geometry_source_impl.cpp
@@ -0,0 +1,40 @@
+#include <mbgl/style/sources/custom_geometry_source_impl.hpp>
+#include <mbgl/style/source_observer.hpp>
+
+namespace mbgl {
+namespace style {
+
+CustomGeometrySource::Impl::Impl(std::string id_,
+                               const CustomGeometrySource::Options options)
+    : Source::Impl(SourceType::CustomVector, std::move(id_)),
+      tileOptions(options.tileOptions),
+      zoomRange(options.zoomRange),
+      loaderRef({}) {
+}
+
+CustomGeometrySource::Impl::Impl(const Impl& impl, ActorRef<CustomTileLoader> loaderRef_)
+    : Source::Impl(impl),
+    tileOptions(impl.tileOptions),
+    zoomRange(impl.zoomRange),
+    loaderRef(loaderRef_){
+    
+}
+
+optional<std::string> CustomGeometrySource::Impl::getAttribution() const {
+    return {};
+}
+
+CustomGeometrySource::TileOptions CustomGeometrySource::Impl::getTileOptions() const {
+    return tileOptions;
+}
+
+Range<uint8_t> CustomGeometrySource::Impl::getZoomRange() const {
+    return zoomRange;
+}
+
+optional<ActorRef<CustomTileLoader>> CustomGeometrySource::Impl::getTileLoader() const {
+    return loaderRef;
+}
+
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/sources/custom_geometry_source_impl.hpp b/src/mbgl/style/sources/custom_geometry_source_impl.hpp
new file mode 100644
index 000000000..ce7187202
--- /dev/null
+++ b/src/mbgl/style/sources/custom_geometry_source_impl.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/style/custom_tile_loader.hpp>
+#include <mbgl/actor/actor_ref.hpp>
+
+namespace mbgl {
+namespace style {
+
+class CustomGeometrySource::Impl : public Source::Impl {
+public:
+    Impl(std::string id, CustomGeometrySource::Options options);
+    Impl(const Impl&, ActorRef<CustomTileLoader>);
+
+    optional<std::string> getAttribution() const final;
+
+    CustomGeometrySource::TileOptions getTileOptions() const;
+    Range<uint8_t> getZoomRange() const;
+    optional<ActorRef<CustomTileLoader>> getTileLoader() const;
+
+private:
+    CustomGeometrySource::TileOptions tileOptions;
+    Range<uint8_t> zoomRange;
+    optional<ActorRef<CustomTileLoader>> loaderRef;
+};
+
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/types.cpp b/src/mbgl/style/types.cpp
index 0a1781e01..cd5e597fc 100644
--- a/src/mbgl/style/types.cpp
+++ b/src/mbgl/style/types.cpp
@@ -12,6 +12,7 @@ MBGL_DEFINE_ENUM(SourceType, {
     { SourceType::Video, "video" },
     { SourceType::Annotations, "annotations" },
     { SourceType::Image, "image" },
+    { SourceType::CustomVector, "customvector" }
 });
 
 MBGL_DEFINE_ENUM(VisibilityType, {
diff --git a/src/mbgl/tile/custom_geometry_tile.cpp b/src/mbgl/tile/custom_geometry_tile.cpp
new file mode 100644
index 000000000..0d0ff5be6
--- /dev/null
+++ b/src/mbgl/tile/custom_geometry_tile.cpp
@@ -0,0 +1,81 @@
+#include <mbgl/tile/custom_geometry_tile.hpp>
+#include <mbgl/tile/geojson_tile_data.hpp>
+#include <mbgl/renderer/query.hpp>
+#include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/style/filter_evaluator.hpp>
+
+#include <mapbox/geojsonvt.hpp>
+
+namespace mbgl {
+
+CustomGeometryTile::CustomGeometryTile(const OverscaledTileID& overscaledTileID,
+                         std::string sourceID_,
+                         const TileParameters& parameters,
+                         const style::CustomGeometrySource::TileOptions options_,
+                         ActorRef<style::CustomTileLoader> loader_)
+    : GeometryTile(overscaledTileID, sourceID_, parameters),
+    necessity(TileNecessity::Optional),
+    options(options_),
+    loader(loader_),
+    actor(*Scheduler::GetCurrent(), std::bind(&CustomGeometryTile::setTileData, this, std::placeholders::_1)) {
+}
+
+CustomGeometryTile::~CustomGeometryTile() {
+    loader.invoke(&style::CustomTileLoader::removeTile, id);
+}
+
+void CustomGeometryTile::setTileData(const GeoJSON& geoJSON) {
+
+    auto featureData = mapbox::geometry::feature_collection<int16_t>();
+    if (geoJSON.is<FeatureCollection>() && !geoJSON.get<FeatureCollection>().empty()) {
+        const double scale = util::EXTENT / options.tileSize;
+
+        mapbox::geojsonvt::TileOptions vtOptions;
+        vtOptions.extent = util::EXTENT;
+        vtOptions.buffer = std::round(scale * options.buffer);
+        vtOptions.tolerance = scale * options.tolerance;
+        featureData = mapbox::geojsonvt::geoJSONToTile(geoJSON, id.canonical.z, id.canonical.x, id.canonical.y, vtOptions).features;
+    } else {
+        setNecessity(TileNecessity::Optional);
+    }
+    setData(std::make_unique<GeoJSONTileData>(std::move(featureData)));
+}
+
+//Fetching tile data for custom sources is assumed to be an expensive operation.
+// Only required tiles make fetchTile requests. Attempt to cancel a tile
+// that is no longer required.
+void CustomGeometryTile::setNecessity(TileNecessity newNecessity) {
+   if (newNecessity != necessity) {
+        necessity = newNecessity;
+        if (necessity == TileNecessity::Required) {
+            loader.invoke(&style::CustomTileLoader::fetchTile, id, actor.self());
+        } else if (!isRenderable()) {
+            loader.invoke(&style::CustomTileLoader::cancelTile, id);
+        }
+    }
+}
+
+void CustomGeometryTile::querySourceFeatures(
+    std::vector<Feature>& result,
+    const SourceQueryOptions& queryOptions) {
+
+    // Ignore the sourceLayer, there is only one
+    auto layer = getData()->getLayer({});
+
+    if (layer) {
+        auto featureCount = layer->featureCount();
+        for (std::size_t i = 0; i < featureCount; i++) {
+            auto feature = layer->getFeature(i);
+            
+            // Apply filter, if any
+            if (queryOptions.filter && !(*queryOptions.filter)(*feature)) {
+                continue;
+            }
+
+            result.push_back(convertFeature(*feature, id.canonical));
+        }
+    }
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/tile/custom_geometry_tile.hpp b/src/mbgl/tile/custom_geometry_tile.hpp
new file mode 100644
index 000000000..66cc412e8
--- /dev/null
+++ b/src/mbgl/tile/custom_geometry_tile.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/util/feature.hpp>
+#include <mbgl/style/custom_tile_loader.hpp>
+
+namespace mbgl {
+
+class TileParameters;
+
+class CustomGeometryTile: public GeometryTile {
+public:
+    CustomGeometryTile(const OverscaledTileID&,
+               std::string sourceID,
+               const TileParameters&,
+               const style::CustomGeometrySource::TileOptions,
+               ActorRef<style::CustomTileLoader> loader);
+    ~CustomGeometryTile() override;
+    void setTileData(const GeoJSON& data);
+
+    void setNecessity(TileNecessity) final;
+
+    void querySourceFeatures(
+        std::vector<Feature>& result,
+        const SourceQueryOptions&) override;
+
+private:
+    TileNecessity necessity;
+    const style::CustomGeometrySource::TileOptions options;
+    ActorRef<style::CustomTileLoader> loader;
+    Actor<style::SetTileDataFunction> actor;
+};
+
+} // namespace mbgl
diff --git a/test/api/custom_geometry_source.test.cpp b/test/api/custom_geometry_source.test.cpp
new file mode 100644
index 000000000..83d1543a0
--- /dev/null
+++ b/test/api/custom_geometry_source.test.cpp
@@ -0,0 +1,71 @@
+#include <mbgl/test/util.hpp>
+
+#include <mbgl/gl/gl.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/util/shared_thread_pool.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/util/geojson.hpp>
+#include <mbgl/util/io.hpp>
+#include <mbgl/util/mat4.hpp>
+#include <mbgl/util/run_loop.hpp>
+
+using namespace mbgl;
+using namespace mbgl::style;
+
+TEST(CustomGeometrySource, Grid) {
+    util::RunLoop loop;
+
+    DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
+    auto threadPool = sharedThreadPool();
+    float pixelRatio { 1 };
+    HeadlessFrontend frontend { pixelRatio, fileSource, *threadPool };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
+            *threadPool, MapMode::Static);
+    map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
+    map.setLatLngZoom({ 37.8, -122.5 }, 10);
+
+    CustomGeometrySource::Options options;
+    options.fetchTileFunction = [&map](const mbgl::CanonicalTileID& tileID) {
+        double gridSpacing = 0.1;
+        FeatureCollection features;
+        const LatLngBounds bounds(tileID);
+        for (double y = ceil(bounds.north() / gridSpacing) * gridSpacing; y >= floor(bounds.south() / gridSpacing) * gridSpacing; y -= gridSpacing) {
+
+            mapbox::geojson::line_string gridLine;
+            gridLine.emplace_back(bounds.west(), y);
+            gridLine.emplace_back(bounds.east(), y);
+
+            features.emplace_back(gridLine);
+        }
+
+        for (double x = floor(bounds.west() / gridSpacing) * gridSpacing; x <= ceil(bounds.east() / gridSpacing) * gridSpacing; x += gridSpacing) {
+            mapbox::geojson::line_string gridLine;
+            gridLine.emplace_back(x, bounds.south());
+            gridLine.emplace_back(x, bounds.north());
+            
+            features.emplace_back(gridLine);
+        }
+        auto source = static_cast<CustomGeometrySource *>(map.getStyle().getSource("custom"));
+        if (source) {
+            source->setTileData(tileID, features);
+        }
+    };
+
+    map.getStyle().addSource(std::make_unique<CustomGeometrySource>("custom", options));
+
+    auto fillLayer = std::make_unique<FillLayer>("landcover", "mapbox");
+    fillLayer->setSourceLayer("landcover");
+    fillLayer->setFillColor(Color{ 1.0, 1.0, 0.0, 1.0 });
+    map.getStyle().addLayer(std::move(fillLayer));
+
+    auto layer = std::make_unique<LineLayer>("grid", "custom");
+    layer->setLineColor(Color{ 1.0, 1.0, 1.0, 1.0 });
+    map.getStyle().addLayer(std::move(layer));
+
+    test::checkImage("test/fixtures/custom_geometry_source/grid", frontend.render(map), 0.0006, 0.1);
+}
diff --git a/test/fixtures/custom_geometry_source/grid/expected.png b/test/fixtures/custom_geometry_source/grid/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..628a3b11fb92b6ef0b3901089d65f01766660c49
GIT binary patch
literal 8302
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

literal 0
HcmV?d00001

diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp
index bee1b867b..6a2122161 100644
--- a/test/style/source.test.cpp
+++ b/test/style/source.test.cpp
@@ -9,6 +9,7 @@
 #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>
 
@@ -548,3 +549,39 @@ TEST(Source, ImageSourceImageUpdate) {
 
     test.run();
 }
+
+TEST(Source, CustomGeometrySourceSetTileData) {
+    SourceTest test;
+
+    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/tile/custom_geometry_tile.test.cpp b/test/tile/custom_geometry_tile.test.cpp
new file mode 100644
index 000000000..21a3dd795
--- /dev/null
+++ b/test/tile/custom_geometry_tile.test.cpp
@@ -0,0 +1,130 @@
+#include <mbgl/test/util.hpp>
+#include <mbgl/test/fake_file_source.hpp>
+#include <mbgl/test/stub_tile_observer.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/tile/custom_geometry_tile.hpp>
+#include <mbgl/style/custom_tile_loader.hpp>
+
+#include <mbgl/util/default_thread_pool.hpp>
+#include <mbgl/util/run_loop.hpp>
+#include <mbgl/map/transform.hpp>
+#include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/annotation/annotation_manager.hpp>
+#include <mbgl/renderer/image_manager.hpp>
+#include <mbgl/text/glyph_manager.hpp>
+
+#include <memory>
+
+using namespace mbgl;
+using namespace mbgl::style;
+
+class CustomTileTest {
+public:
+    FakeFileSource fileSource;
+    TransformState transformState;
+    util::RunLoop loop;
+    ThreadPool threadPool { 1 };
+    style::Style style { loop, fileSource, 1 };
+    AnnotationManager annotationManager { style };
+    ImageManager imageManager;
+    GlyphManager glyphManager { fileSource };
+
+    TileParameters tileParameters {
+        1.0,
+        MapDebugOptions(),
+        transformState,
+        threadPool,
+        fileSource,
+        MapMode::Continuous,
+        annotationManager,
+        imageManager,
+        glyphManager,
+        0
+    };
+};
+
+TEST(CustomGeometryTile, InvokeFetchTile) {
+    CustomTileTest test;
+
+    CircleLayer layer("circle", "source");
+
+    mapbox::geometry::feature_collection<double> features;
+    features.push_back(mapbox::geometry::feature<double> {
+        mapbox::geometry::point<double>(0, 0)
+    });
+    CustomTileLoader loader([&](const CanonicalTileID& tileId) {
+        EXPECT_EQ(tileId, CanonicalTileID(0,0,0));
+        test.loop.stop();
+    }, [&](const CanonicalTileID&) {
+
+    });
+    auto mb =std::make_shared<Mailbox>(*Scheduler::GetCurrent());
+    ActorRef<CustomTileLoader> loaderActor(loader, mb);
+    
+    CustomGeometryTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, CustomGeometrySource::TileOptions(),
+    loaderActor);
+
+    tile.setNecessity(TileNecessity::Required);
+
+    test.loop.run();
+}
+
+TEST(CustomGeometryTile, InvokeCancelTile) {
+    CustomTileTest test;
+
+    CircleLayer layer("circle", "source");
+
+    mapbox::geometry::feature_collection<double> features;
+    features.push_back(mapbox::geometry::feature<double> {
+        mapbox::geometry::point<double>(0, 0)
+    });
+
+    CustomTileLoader loader([&](const CanonicalTileID&) { }, [&](const CanonicalTileID& tileId) {
+        EXPECT_EQ(tileId, CanonicalTileID(0,0,0));
+        test.loop.stop();
+    });
+    auto mb =std::make_shared<Mailbox>(*Scheduler::GetCurrent());
+    ActorRef<CustomTileLoader> loaderActor(loader, mb);
+    
+    CustomGeometryTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, CustomGeometrySource::TileOptions(),
+    loaderActor);
+
+    tile.setNecessity(TileNecessity::Required);
+    tile.setNecessity(TileNecessity::Optional);
+    test.loop.run();
+}
+
+TEST(CustomGeometryTile, InvokeTileChanged) {
+    CustomTileTest test;
+
+    CircleLayer layer("circle", "source");
+
+    mapbox::geometry::feature_collection<double> features;
+    features.push_back(mapbox::geometry::feature<double> {
+        mapbox::geometry::point<double>(0, 0)
+    });
+
+    CustomTileLoader loader(nullptr, nullptr);
+    auto mb =std::make_shared<Mailbox>(*Scheduler::GetCurrent());
+    ActorRef<CustomTileLoader> loaderActor(loader, mb);
+    
+    CustomGeometryTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, CustomGeometrySource::TileOptions(),
+    loaderActor);
+
+    StubTileObserver observer;
+    observer.tileChanged = [&] (const Tile&) {
+        // Once present, the bucket should never "disappear", which would cause
+        // flickering.
+        ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
+    };
+
+    tile.setLayers({{ layer.baseImpl }});
+    tile.setObserver(&observer);
+    tile.setTileData(features);
+
+    while (!tile.isComplete()) {
+        test.loop.runOnce();
+    }
+}