tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] renderer interface

Browse Source
This commit is contained in:
Ivo van Dongen
2017-06-13 10:50:16 +03:00
committed by Ivo van Dongen
parent 39a732d7ae
commit 3832f8d0d8
44 changed files with 1016 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

344
test/map/map.test.cpp
View File

@@ -12,6 +12,7 @@
#include <mbgl/storage/network_status.hpp>
#include <mbgl/storage/default_file_source.hpp>
#include <mbgl/storage/online_file_source.hpp>
#include <mbgl/renderer/renderer.hpp>
#include <mbgl/util/image.hpp>
#include <mbgl/util/io.hpp>
#include <mbgl/util/run_loop.hpp>
@@ -19,26 +20,13 @@
#include <mbgl/style/style.hpp>
#include <mbgl/style/image.hpp>
#include <mbgl/style/layers/background_layer.hpp>
#include <mbgl/test/stub_renderer_frontend.hpp>
#include <mbgl/util/color.hpp>
using namespace mbgl;
using namespace mbgl::style;
using namespace std::literals::string_literals;
class MockBackend : public HeadlessBackend {
public:
MockBackend()
: HeadlessBackend(test::sharedDisplay() ) {
}
std::function<void()> callback;
void invalidate() override {
if (callback) {
callback();
}
}
};
class StubMapObserver : public MapObserver {
public:
void onWillStartLoadingMap() final {
@@ -71,66 +59,83 @@ public:
std::function<void()> didFinishLoadingStyleCallback;
};
struct MapTest {
template <class FileSource = StubFileSource>
class MapTest {
public:
util::RunLoop runLoop;
MockBackend backend;
StubMapObserver observer;
HeadlessBackend backend;
BackendScope scope { backend };
OffscreenView view { backend.getContext() };
StubFileSource fileSource;
FileSource fileSource;
ThreadPool threadPool { 4 };
StubMapObserver observer;
StubRendererFrontend rendererFrontend;
Map map;
MapTest(float pixelRatio = 1, MapMode mode = MapMode::Still)
: rendererFrontend(
std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view)
, map(rendererFrontend, observer, view.getSize(), pixelRatio, fileSource, threadPool, mode) {
}
template <typename T = FileSource>
MapTest(const std::string& cachePath, const std::string& assetRoot,
float pixelRatio = 1, MapMode mode = MapMode::Still,
typename std::enable_if<std::is_same<T, DefaultFileSource>::value>::type* = 0)
: fileSource { cachePath, assetRoot }
, rendererFrontend(
std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool),
view)
, map(rendererFrontend, observer, view.getSize(), pixelRatio, fileSource, threadPool, mode) {
}
};
TEST(Map, LatLngBehavior) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
MapTest<> test;
map.setLatLngZoom({ 1, 1 }, 0);
auto latLng1 = map.getLatLng();
test.map.setLatLngZoom({ 1, 1 }, 0);
auto latLng1 = test.map.getLatLng();
map.setLatLng({ 1, 1 });
auto latLng2 = map.getLatLng();
test.map.setLatLng({ 1, 1 });
auto latLng2 = test.map.getLatLng();
ASSERT_DOUBLE_EQ(latLng1.latitude(), latLng2.latitude());
ASSERT_DOUBLE_EQ(latLng1.longitude(), latLng2.longitude());
}
TEST(Map, LatLngBoundsToCamera) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
MapTest<> test;
map.setLatLngZoom({ 40.712730, -74.005953 }, 16.0);
test.map.setLatLngZoom({ 40.712730, -74.005953 }, 16.0);
LatLngBounds bounds = LatLngBounds::hull({15.68169,73.499857}, {53.560711, 134.77281});
CameraOptions virtualCamera = map.cameraForLatLngBounds(bounds, {});
CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {});
ASSERT_TRUE(bounds.contains(*virtualCamera.center));
}
TEST(Map, CameraToLatLngBounds) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
MapTest<> test;
map.setLatLngZoom({ 45, 90 }, 16);
test.map.setLatLngZoom({ 45, 90 }, 16);
LatLngBounds bounds = LatLngBounds::hull(
map.latLngForPixel({}),
map.latLngForPixel({ double(map.getSize().width), double(map.getSize().height) }));
test.map.latLngForPixel({}),
test.map.latLngForPixel({ double(test.map.getSize().width), double(test.map.getSize().height) }));
CameraOptions camera = map.getCameraOptions({});
CameraOptions camera = test.map.getCameraOptions({});
ASSERT_EQ(bounds, map.latLngBoundsForCamera(camera));
ASSERT_EQ(bounds, test.map.latLngBoundsForCamera(camera));
// Map::cameraForLatLngBounds only sets zoom and center.
CameraOptions virtualCamera = map.cameraForLatLngBounds(bounds, {});
CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {});
ASSERT_NEAR(*camera.zoom, *virtualCamera.zoom, 1e-7);
ASSERT_NEAR(camera.center->latitude(), virtualCamera.center->latitude(), 1e-7);
ASSERT_NEAR(camera.center->longitude(), virtualCamera.center->longitude(), 1e-7);
}
TEST(Map, Offline) {
MapTest test;
DefaultFileSource fileSource(":memory:", ".");
MapTest<DefaultFileSource> test {":memory:", "."};
auto expiredItem = [] (const std::string& path) {
Response response;
@@ -140,19 +145,18 @@ TEST(Map, Offline) {
};
const std::string prefix = "http://127.0.0.1:3000/";
fileSource.put(Resource::style(prefix + "style.json"), expiredItem("style.json"));
fileSource.put(Resource::source(prefix + "streets.json"), expiredItem("streets.json"));
fileSource.put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json"));
fileSource.put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png"));
fileSource.put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf"));
fileSource.put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf"));
test.fileSource.put(Resource::style(prefix + "style.json"), expiredItem("style.json"));
test.fileSource.put(Resource::source(prefix + "streets.json"), expiredItem("streets.json"));
test.fileSource.put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json"));
test.fileSource.put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png"));
test.fileSource.put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf"));
test.fileSource.put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf"));
NetworkStatus::Set(NetworkStatus::Status::Offline);
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL(prefix + "style.json");
test.map.getStyle().loadURL(prefix + "style.json");
test::checkImage("test/fixtures/map/offline",
test::render(map, test.view),
test::render(test.map, test.view),
0.0015,
0.1);
@@ -160,19 +164,16 @@ TEST(Map, Offline) {
}
TEST(Map, SetStyleInvalidJSON) {
MapTest test;
Log::setObserver(std::make_unique<FixtureLogObserver>());
bool fail = false;
test.observer.didFailLoadingMapCallback = [&]() {
fail = true;
};
{
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool,
MapMode::Still);
map.getStyle().loadJSON("invalid");
MapTest<> test;
test.observer.didFailLoadingMapCallback = [&]() {
fail = true;
};
test.map.getStyle().loadJSON("invalid");
}
EXPECT_TRUE(fail);
@@ -186,7 +187,7 @@ TEST(Map, SetStyleInvalidJSON) {
}
TEST(Map, SetStyleInvalidURL) {
MapTest test;
MapTest<> test;
test.fileSource.styleResponse = [] (const Resource&) {
Response response;
@@ -200,36 +201,32 @@ TEST(Map, SetStyleInvalidURL) {
test.runLoop.stop();
};
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://bar");
test.map.getStyle().loadURL("mapbox://bar");
test.runLoop.run();
}
TEST(Map, DoubleStyleLoad) {
MapTest test;
MapTest<> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadJSON("");
map.getStyle().loadJSON("");
test.map.getStyle().loadJSON("");
test.map.getStyle().loadJSON("");
}
TEST(Map, StyleFresh) {
// The map should not revalidate fresh styles.
MapTest test;
FakeFileSource fileSource;
MapTest<FakeFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, fileSource.requests.size());
test.map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, test.fileSource.requests.size());
Response response;
response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
response.expires = Timestamp::max();
fileSource.respond(Resource::Style, response);
EXPECT_EQ(0u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(0u, test.fileSource.requests.size());
}
TEST(Map, StyleExpired) {
@@ -237,26 +234,24 @@ TEST(Map, StyleExpired) {
using namespace std::chrono_literals;
MapTest test;
FakeFileSource fileSource;
MapTest<FakeFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, fileSource.requests.size());
test.map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, test.fileSource.requests.size());
Response response;
response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
response.expires = util::now() - 1h;
fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, test.fileSource.requests.size());
map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg"));
EXPECT_EQ(1u, fileSource.requests.size());
test.map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg"));
EXPECT_EQ(1u, test.fileSource.requests.size());
fileSource.respond(Resource::Style, response);
EXPECT_EQ(0u, fileSource.requests.size());
EXPECT_NE(nullptr, map.getStyle().getLayer("bg"));
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(0u, test.fileSource.requests.size());
EXPECT_NE(nullptr, test.map.getStyle().getLayer("bg"));
}
TEST(Map, StyleExpiredWithAnnotations) {
@@ -264,25 +259,23 @@ TEST(Map, StyleExpiredWithAnnotations) {
using namespace std::chrono_literals;
MapTest test;
FakeFileSource fileSource;
MapTest<FakeFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, fileSource.requests.size());
test.map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, test.fileSource.requests.size());
Response response;
response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
response.expires = util::now() - 1h;
fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, test.fileSource.requests.size());
map.addAnnotation(LineAnnotation { LineString<double> {{ { 0, 0 }, { 10, 10 } }} });
EXPECT_EQ(1u, fileSource.requests.size());
test.map.addAnnotation(LineAnnotation { LineString<double> {{ { 0, 0 }, { 10, 10 } }} });
EXPECT_EQ(1u, test.fileSource.requests.size());
fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, test.fileSource.requests.size());
}
TEST(Map, StyleExpiredWithRender) {
@@ -290,98 +283,85 @@ TEST(Map, StyleExpiredWithRender) {
using namespace std::chrono_literals;
MapTest test;
FakeFileSource fileSource;
MapTest<FakeFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, fileSource.requests.size());
test.map.getStyle().loadURL("mapbox://styles/test");
EXPECT_EQ(1u, test.fileSource.requests.size());
Response response;
response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
response.expires = util::now() - 1h;
fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, test.fileSource.requests.size());
map.render(test.view);
EXPECT_EQ(1u, fileSource.requests.size());
test::render(test.map, test.view);
EXPECT_EQ(1u, test.fileSource.requests.size());
fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, fileSource.requests.size());
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(1u, test.fileSource.requests.size());
}
TEST(Map, StyleEarlyMutation) {
// An early mutation should not prevent the initial style load.
MapTest test;
FakeFileSource fileSource;
MapTest<FakeFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("mapbox://styles/test");
map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg"));
test.map.getStyle().loadURL("mapbox://styles/test");
test.map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg"));
Response response;
response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/water.json"));
fileSource.respond(Resource::Style, response);
test.fileSource.respond(Resource::Style, response);
EXPECT_EQ(0u, fileSource.requests.size());
EXPECT_NE(nullptr, map.getStyle().getLayer("water"));
EXPECT_EQ(0u, test.fileSource.requests.size());
EXPECT_NE(nullptr, test.map.getStyle().getLayer("water"));
}
TEST(Map, MapLoadingSignal) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
MapTest<> test;
bool emitted = false;
test.observer.onWillStartLoadingMapCallback = [&]() {
emitted = true;
};
map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
EXPECT_TRUE(emitted);
}
TEST(Map, MapLoadedSignal) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Continuous);
MapTest<> test { 1, MapMode::Continuous };
test.observer.onDidFinishLoadingMapCallback = [&]() {
test.runLoop.stop();
};
test.backend.callback = [&]() {
map.render(test.view);
};
map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.runLoop.run();
}
TEST(Map, StyleLoadedSignal) {
MapTest test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
MapTest<> test;
// The map should emit a signal on style loaded
bool emitted = false;
test.observer.didFinishLoadingStyleCallback = [&]() {
emitted = true;
};
map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
EXPECT_TRUE(emitted);
// But not when the style couldn't be parsed
emitted = false;
map.getStyle().loadJSON("invalid");
test.map.getStyle().loadJSON("invalid");
EXPECT_FALSE(emitted);
}
// Test for https://github.com/mapbox/mapbox-gl-native/issues/7902
TEST(Map, TEST_REQUIRES_SERVER(StyleNetworkErrorRetry)) {
MapTest test;
OnlineFileSource fileSource;
MapTest<OnlineFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-500");
test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-500");
test.observer.didFinishLoadingStyleCallback = [&]() {
test.runLoop.stop();
@@ -391,11 +371,9 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNetworkErrorRetry)) {
}
TEST(Map, TEST_REQUIRES_SERVER(StyleNotFound)) {
MapTest test;
OnlineFileSource fileSource;
MapTest<OnlineFileSource> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404");
test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404");
using namespace std::chrono_literals;
util::Timer timer;
@@ -414,52 +392,46 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNotFound)) {
test.runLoop.run();
// Should also not retry if the response has cache headers.
map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404-cache");
test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404-cache");
test.runLoop.run();
}
TEST(Map, AddLayer) {
MapTest test;
MapTest<> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
auto layer = std::make_unique<BackgroundLayer>("background");
layer->setBackgroundColor({ { 1, 0, 0, 1 } });
map.getStyle().addLayer(std::move(layer));
test.map.getStyle().addLayer(std::move(layer));
test::checkImage("test/fixtures/map/add_layer", test::render(map, test.view));
test::checkImage("test/fixtures/map/add_layer", test::render(test.map, test.view));
}
TEST(Map, WithoutVAOExtension) {
MapTest test;
MapTest<DefaultFileSource> test { ":memory:", "test/fixtures/api/assets" };
test.backend.getContext().disableVAOExtension = true;
DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
test::checkImage("test/fixtures/map/no_vao", test::render(map, test.view), 0.002);
test::checkImage("test/fixtures/map/no_vao", test::render(test.map, test.view), 0.002);
}
TEST(Map, RemoveLayer) {
MapTest test;
MapTest<> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json"));
auto layer = std::make_unique<BackgroundLayer>("background");
layer->setBackgroundColor({{ 1, 0, 0, 1 }});
map.getStyle().addLayer(std::move(layer));
map.getStyle().removeLayer("background");
test.map.getStyle().addLayer(std::move(layer));
test.map.getStyle().removeLayer("background");
test::checkImage("test/fixtures/map/remove_layer", test::render(map, test.view));
test::checkImage("test/fixtures/map/remove_layer", test::render(test.map, test.view));
}
TEST(Map, DisabledSources) {
MapTest test;
MapTest<> test;
// Always load the same image tile for raster layers.
test.fileSource.response = [] (const Resource& res) -> optional<Response> {
@@ -472,15 +444,14 @@ TEST(Map, DisabledSources) {
return {};
};
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.setZoom(1);
test.map.setZoom(1);
// This stylesheet has two raster layers, one that starts at zoom 1, the other at zoom 0.
// We first render a map at zoom level 1, which should show both layers (both are "visible" due
// to an opacity of 0.5). Then, we are zooming back out to a zoom level of 0.5 and rerender.
// The "raster1" layer should not be visible anymore since it has minzoom 1, while "raster2"
// should still be there. Both layers have a distinct color through "raster-hue-rotate".
map.getStyle().loadJSON(R"STYLE(
test.map.getStyle().loadJSON(R"STYLE(
{
"version": 8,
"name": "Test",
@@ -514,16 +485,15 @@ TEST(Map, DisabledSources) {
}
)STYLE");
test::checkImage("test/fixtures/map/disabled_layers/first", test::render(map, test.view));
map.setZoom(0.5);
test::checkImage("test/fixtures/map/disabled_layers/second", test::render(map, test.view));
test::checkImage("test/fixtures/map/disabled_layers/first", test::render(test.map, test.view));
test.map.setZoom(0.5);
test::checkImage("test/fixtures/map/disabled_layers/second", test::render(test.map, test.view));
}
TEST(Map, DontLoadUnneededTiles) {
MapTest test;
MapTest<> test;
Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still);
map.getStyle().loadJSON(R"STYLE({
test.map.getStyle().loadJSON(R"STYLE({
"sources": {
"a": { "type": "vector", "tiles": [ "a/{z}/{x}/{y}" ] }
},
@@ -561,20 +531,20 @@ TEST(Map, DontLoadUnneededTiles) {
// Note: using z += 0.1 in the loop doesn't produce accurate floating point numbers.
const double z = double(zoom) / 10;
tiles.clear();
map.setZoom(z);
test::render(map, test.view);
test.map.setZoom(z);
test::render(test.map, test.view);
EXPECT_EQ(referenceTiles[z], tiles) << "zoom level " << z;
}
}
TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
util::RunLoop runLoop;
MockBackend backend;
BackendScope scope { backend };
HeadlessBackend backend { test::sharedDisplay() };
BackendScope scope(backend);
OffscreenView view { backend.getContext() };
ThreadPool threadPool { 4 };
DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Continuous);
float pixelRatio { 1 };
using namespace std::chrono_literals;
@@ -585,24 +555,32 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
});
util::Timer timer;
util::AsyncTask render{[&] {
if (map.isFullyLoaded()) {
// Abort the test after 1 second after the map loading fully. Note that a "fully loaded
// map" doesn't mean that we won't render anymore: we could still render fade in/fade
// out or other animations.
// If we are continuing to render indefinitely, the emergency shutoff above will trigger
// and the test will fail since the regular time will be constantly reset.
timer.start(1s, 0s, [&] {
util::RunLoop::Get()->stop();
});
}
BackendScope scope2(backend);
map.render(view);
}};
std::function<bool()> isLoaded;
backend.callback = [&] {
render.send();
StubRendererFrontend rendererFrontend {
std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool),
[&](StubRendererFrontend& bridge) {
if (isLoaded()) {
// Abort the test after 1 second after the map loading fully. Note that a "fully loaded
// map" doesn't mean that we won't render anymore: we could still render fade in/fade
// out or other animations.
// If we are continuing to render indefinitely, the emergency shutoff above will trigger
// and the test will fail since the regular time will be constantly reset.
timer.start(1s, 0s, [&] {
util::RunLoop::Get()->stop();
});
}
bridge.render(view);
}
};
Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource,
threadPool, MapMode::Continuous);
isLoaded = [&] {
return map.isFullyLoaded();
};
map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));