[test] Update Map.PrefetchTiles

cmake/test-files.cmake

@@ -104,6 +104,7 @@ set(MBGL_TEST_FILES
     test/src/mbgl/test/stub_file_source.hpp
     test/src/mbgl/test/stub_geometry_tile_feature.hpp
     test/src/mbgl/test/stub_layer_observer.hpp
+    test/src/mbgl/test/stub_map_observer.hpp
     test/src/mbgl/test/stub_render_source_observer.hpp
     test/src/mbgl/test/stub_style_observer.hpp
     test/src/mbgl/test/stub_tile_observer.hpp

test/map/map.test.cpp

@@ -1,5 +1,6 @@
 #include <mbgl/test/util.hpp>
 #include <mbgl/test/stub_file_source.hpp>
+#include <mbgl/test/stub_map_observer.hpp>
 #include <mbgl/test/fake_file_source.hpp>
 #include <mbgl/test/fixture_log_observer.hpp>
 
@@ -23,45 +24,6 @@ using namespace mbgl;
 using namespace mbgl::style;
 using namespace std::literals::string_literals;
 
-class StubMapObserver : public MapObserver {
-public:
-    void onWillStartLoadingMap() final {
-        if (onWillStartLoadingMapCallback) {
-            onWillStartLoadingMapCallback();
-        }
-    }
-
-    void onDidFinishLoadingMap() final {
-        if (onDidFinishLoadingMapCallback) {
-            onDidFinishLoadingMapCallback();
-        }
-    }
-
-    void onDidFailLoadingMap(std::exception_ptr) final {
-        if (didFailLoadingMapCallback) {
-            didFailLoadingMapCallback();
-        }
-    }
-
-    void onDidFinishLoadingStyle() final {
-        if (didFinishLoadingStyleCallback) {
-            didFinishLoadingStyleCallback();
-        }
-    }
-
-    void onDidFinishRenderingFrame(RenderMode mode) final {
-        if (didFinishRenderingFrame) {
-            didFinishRenderingFrame(mode);
-        }
-    }
-
-    std::function<void()> onWillStartLoadingMapCallback;
-    std::function<void()> onDidFinishLoadingMapCallback;
-    std::function<void()> didFailLoadingMapCallback;
-    std::function<void()> didFinishLoadingStyleCallback;
-    std::function<void(RenderMode)> didFinishRenderingFrame;
-};
-
 template <class FileSource = StubFileSource>
 class MapTest {
 public:
@@ -371,7 +333,7 @@ TEST(Map, MapLoadingSignal) {
     MapTest<> test;
 
     bool emitted = false;
-    test.observer.onWillStartLoadingMapCallback = [&]() {
+    test.observer.willStartLoadingMapCallback = [&]() {
         emitted = true;
     };
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
@@ -381,7 +343,7 @@ TEST(Map, MapLoadingSignal) {
 TEST(Map, MapLoadedSignal) {
     MapTest<> test { 1, MapMode::Continuous };
 
-    test.observer.onDidFinishLoadingMapCallback = [&]() {
+    test.observer.didFinishLoadingMapCallback = [&]() {
         test.runLoop.stop();
     };
 
@@ -607,7 +569,7 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
     HeadlessFrontend frontend(pixelRatio, fileSource, threadPool);
 
     StubMapObserver observer;
-    observer.didFinishRenderingFrame = [&] (MapObserver::RenderMode) {
+    observer.didFinishRenderingFrameCallback = [&] (MapObserver::RenderMode) {
         // Start a timer that ends the test one second from now. If we are continuing to render
         // indefinitely, the timer will be constantly restarted and never trigger. Instead, the
         // emergency shutoff above will trigger, failing the test.

test/map/prefetch.test.cpp

@@ -1,5 +1,6 @@
 #include <mbgl/test/util.hpp>
 #include <mbgl/test/stub_file_source.hpp>
+#include <mbgl/test/stub_map_observer.hpp>
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
@@ -17,34 +18,38 @@
 using namespace mbgl;
 using namespace mbgl::style;
 using namespace std::literals::string_literals;
+using namespace std::chrono_literals;
 
 TEST(Map, PrefetchTiles) {
     util::RunLoop runLoop;
     ThreadPool threadPool(4);
     StubFileSource fileSource;
+
+    util::Timer emergencyShutoff;
+    emergencyShutoff.start(10s, 0s, [&] {
+        runLoop.stop();
+        FAIL() << "Did not stop rendering";
+    });
+
+    StubMapObserver observer;
+    observer.didFinishLoadingMapCallback = [&] () {
+        runLoop.stop();
+    };
+
     HeadlessFrontend frontend { { 512, 512 }, 1, fileSource, threadPool };
-    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), 1, fileSource, threadPool, MapMode::Static);
+    Map map(frontend, observer, frontend.getSize(), 1, fileSource, threadPool, MapMode::Continuous);
 
     std::vector<int> tiles;
 
     fileSource.response = [&] (const Resource& res) -> optional<Response> {
-        Response response;
+        static std::string tile = util::read_file("test/fixtures/map/prefetch/tile.png");
 
         auto zoom = std::stoi(res.url);
         tiles.push_back(zoom);
 
-        // Return a red tile for prefetched tiles or green to the actual tile.
-        // The end rendering result should be all green because the map is only
-        // considered fully rendered when only ideal tiles are shown.
-        if (zoom == int(map.getZoom()) + 1) {
-            response.data = std::make_shared<std::string>(
-                util::read_file("test/fixtures/map/prefetch/tile_green.png"));
-        } else {
-            response.data = std::make_shared<std::string>(
-                util::read_file("test/fixtures/map/prefetch/tile_red.png"));
-        }
-
-        return { std::move(response) };
+        Response response;
+        response.data = std::make_shared<std::string>(tile);
+        return response;
     };
 
     auto checkTilesForZoom = [&](int zoom, const std::vector<int>& expected) {
@@ -53,14 +58,11 @@ TEST(Map, PrefetchTiles) {
         // Force tile reloading.
         map.getStyle().loadJSON(util::read_file("test/fixtures/map/prefetch/empty.json"));
         map.getStyle().loadJSON(util::read_file("test/fixtures/map/prefetch/style.json"));
-
         map.setLatLngZoom({ 40.726989, -73.992857 }, zoom); // Manhattan
+        runLoop.run();
 
-        // Should always render the ideal tiles (i.e. a green map)
-        test::checkImage("test/fixtures/map/prefetch", frontend.render(map));
-
+        ASSERT_EQ(tiles.size(), expected.size());
         ASSERT_TRUE(std::is_permutation(tiles.begin(), tiles.end(), expected.begin()));
-        ASSERT_FALSE(tiles.empty());
     };
 
     // Check defaults, should be 4.

test/src/mbgl/test/stub_map_observer.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <mbgl/map/map_observer.hpp>
+
+#include <functional>
+
+namespace mbgl {
+
+class StubMapObserver : public MapObserver {
+public:
+    void onWillStartLoadingMap() final {
+        if (willStartLoadingMapCallback) {
+            willStartLoadingMapCallback();
+        }
+    }
+
+    void onDidFinishLoadingMap() final {
+        if (didFinishLoadingMapCallback) {
+            didFinishLoadingMapCallback();
+        }
+    }
+
+    void onDidFailLoadingMap(std::exception_ptr) final {
+        if (didFailLoadingMapCallback) {
+            didFailLoadingMapCallback();
+        }
+    }
+
+    void onDidFinishLoadingStyle() final {
+        if (didFinishLoadingStyleCallback) {
+            didFinishLoadingStyleCallback();
+        }
+    }
+
+    void onDidFinishRenderingFrame(RenderMode mode) final {
+        if (didFinishRenderingFrameCallback) {
+            didFinishRenderingFrameCallback(mode);
+        }
+    }
+
+    std::function<void()> willStartLoadingMapCallback;
+    std::function<void()> didFinishLoadingMapCallback;
+    std::function<void()> didFailLoadingMapCallback;
+    std::function<void()> didFinishLoadingStyleCallback;
+    std::function<void(RenderMode)> didFinishRenderingFrameCallback;
+};
+
+
+} // namespace mbgl