diff options
Diffstat (limited to 'test')
30 files changed, 579 insertions, 446 deletions
diff --git a/test/api/annotations.test.cpp b/test/api/annotations.test.cpp index 87d64d53de..4bcaa03897 100644 --- a/test/api/annotations.test.cpp +++ b/test/api/annotations.test.cpp @@ -5,6 +5,7 @@ #include <mbgl/annotation/annotation.hpp> #include <mbgl/sprite/sprite_image.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/io.hpp> @@ -24,6 +25,7 @@ class AnnotationTest { public: util::RunLoop loop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext() }; StubFileSource fileSource; ThreadPool threadPool { 4 }; diff --git a/test/api/api_misuse.test.cpp b/test/api/api_misuse.test.cpp index 1a61872f79..af703fddfb 100644 --- a/test/api/api_misuse.test.cpp +++ b/test/api/api_misuse.test.cpp @@ -3,6 +3,7 @@ #include <mbgl/test/fixture_log_observer.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/storage/online_file_source.hpp> @@ -22,6 +23,7 @@ TEST(API, RenderWithoutCallback) { util::RunLoop loop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 128, 512 } }; StubFileSource fileSource; ThreadPool threadPool(4); @@ -47,6 +49,7 @@ TEST(API, RenderWithoutStyle) { util::RunLoop loop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 128, 512 } }; StubFileSource fileSource; ThreadPool threadPool(4); diff --git a/test/api/custom_layer.test.cpp b/test/api/custom_layer.test.cpp index dd56197463..658c5333c3 100644 --- a/test/api/custom_layer.test.cpp +++ b/test/api/custom_layer.test.cpp @@ -2,6 +2,7 @@ #include <mbgl/gl/gl.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> @@ -86,6 +87,7 @@ TEST(CustomLayer, Basic) { util::RunLoop loop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext() }; #ifdef MBGL_ASSET_ZIP diff --git a/test/api/query.test.cpp b/test/api/query.test.cpp index 45e6b19268..532cc14d28 100644 --- a/test/api/query.test.cpp +++ b/test/api/query.test.cpp @@ -1,4 +1,5 @@ #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> @@ -29,6 +30,7 @@ public: util::RunLoop loop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext() }; StubFileSource fileSource; ThreadPool threadPool { 4 }; diff --git a/test/api/render_missing.test.cpp b/test/api/render_missing.test.cpp index c1bf7e5702..8637462cbe 100644 --- a/test/api/render_missing.test.cpp +++ b/test/api/render_missing.test.cpp @@ -2,6 +2,7 @@ #include <mbgl/test/fixture_log_observer.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> @@ -26,6 +27,7 @@ TEST(API, TEST_REQUIRES_SERVER(RenderMissingTile)) { const auto style = util::read_file("test/fixtures/api/water_missing_tiles.json"); HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 256, 512 } }; #ifdef MBGL_ASSET_ZIP // Regenerate with `cd test/fixtures/api/ && zip -r assets.zip assets/` diff --git a/test/api/repeated_render.test.cpp b/test/api/repeated_render.test.cpp index 800813075f..6648a7752e 100644 --- a/test/api/repeated_render.test.cpp +++ b/test/api/repeated_render.test.cpp @@ -2,6 +2,7 @@ #include <mbgl/test/fixture_log_observer.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> @@ -22,6 +23,7 @@ TEST(API, RepeatedRender) { const auto style = util::read_file("test/fixtures/api/water.json"); HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 256, 512 } }; #ifdef MBGL_ASSET_ZIP // Regenerate with `cd test/fixtures/api/ && zip -r assets.zip assets/` diff --git a/test/fixtures/style_parser/colors.info.json b/test/fixtures/style_parser/colors.info.json index 9c25a2f488..82f93d299b 100644 --- a/test/fixtures/style_parser/colors.info.json +++ b/test/fixtures/style_parser/colors.info.json @@ -1,6 +1,7 @@ { "default": { "log": [ + [2, "WARNING", "ParseStyle", "value must be a valid color"] ] } } diff --git a/test/fixtures/style_parser/colors.style.json b/test/fixtures/style_parser/colors.style.json index 8996548885..7bec578df1 100644 --- a/test/fixtures/style_parser/colors.style.json +++ b/test/fixtures/style_parser/colors.style.json @@ -1,10 +1,5 @@ { "version": 8, - "constants": { - "@land": "r44,239,225)", - "@snow": "f4f8foNGbjf#", - "@crop": "#eerLznieed4" - }, "sources": { "mapbox": { "type": "vector", @@ -16,7 +11,7 @@ "id": "background", "type": "background", "paint": { - "background-color": "@land" + "background-color": "rgb(44,239,225)" } }, { "id": "landcover_snow", @@ -25,7 +20,7 @@ "source-layer": "landcover", "filter": ["==", "class", "snow"], "paint": { - "fill-color": "@snow" + "fill-color": "f4f8foNGbjf#" } }, { "id": "landcover_crop", @@ -34,7 +29,7 @@ "source-layer": "landcover", "filter": ["==", "class", "crop"], "paint": { - "fill-color": "@crop" + "fill-color": "#eerLznieed4" } }] } diff --git a/test/fixtures/style_parser/stop-zoom-value.style.json b/test/fixtures/style_parser/stop-zoom-value.style.json index 520db9a904..b96736535b 100644 --- a/test/fixtures/style_parser/stop-zoom-value.style.json +++ b/test/fixtures/style_parser/stop-zoom-value.style.json @@ -36,7 +36,7 @@ "source-layer": "landcover", "filter": ["==", "class", "wood"], "paint": { - "fill-color": "@wood", + "fill-color": "#001100", "fill-opacity": { "stops": [[12, 1], [13, 0.8], [16, 0.2]] } diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp index feda234af2..5b66a0987f 100644 --- a/test/gl/bucket.test.cpp +++ b/test/gl/bucket.test.cpp @@ -27,11 +27,11 @@ TEST(Buckets, LineBucket) { } TEST(Buckets, SymbolBucket) { - style::SymbolLayoutProperties::Evaluated layout; + style::SymbolLayoutProperties::PossiblyEvaluated layout; bool sdfIcons = false; bool iconsNeedLinear = false; - SymbolBucket bucket { layout, {}, 0, sdfIcons, iconsNeedLinear }; + SymbolBucket bucket { layout, {}, 16.0f, 1.0f, 0, sdfIcons, iconsNeedLinear }; ASSERT_FALSE(bucket.hasIconData()); ASSERT_FALSE(bucket.hasTextData()); ASSERT_FALSE(bucket.hasCollisionBoxData()); diff --git a/test/gl/object.test.cpp b/test/gl/object.test.cpp index 85ae457081..b5a055f4ca 100644 --- a/test/gl/object.test.cpp +++ b/test/gl/object.test.cpp @@ -26,20 +26,6 @@ struct MockGLObject { const bool MockGLObject::Default = false; -TEST(GLObject, PreserveState) { - getFlag = false; - setFlag = false; - - auto object = std::make_unique<gl::PreserveState<MockGLObject>>(); - EXPECT_TRUE(getFlag); - EXPECT_FALSE(setFlag); - - getFlag = false; - object.reset(); - EXPECT_FALSE(getFlag); - EXPECT_TRUE(setFlag); -} - TEST(GLObject, Value) { setFlag = false; @@ -62,8 +48,8 @@ TEST(GLObject, Value) { TEST(GLObject, Store) { HeadlessBackend backend { test::sharedDisplay() }; - OffscreenView view(backend.getContext()); BackendScope scope { backend }; + OffscreenView view(backend.getContext()); gl::Context context; EXPECT_TRUE(context.empty()); diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp index 618c2e6a74..b732741efd 100644 --- a/test/map/map.test.cpp +++ b/test/map/map.test.cpp @@ -24,9 +24,30 @@ using namespace mbgl; using namespace mbgl::style; using namespace std::literals::string_literals; +class BackendTest : public HeadlessBackend { +public: + BackendTest() : HeadlessBackend(test::sharedDisplay()) {} + + void onDidFailLoadingMap(std::exception_ptr) final { + if (didFailLoadingMapCallback) { + didFailLoadingMapCallback(); + } + } + + void onDidFinishLoadingStyle() final { + if (didFinishLoadingStyleCallback) { + didFinishLoadingStyleCallback(); + } + } + + std::function<void()> didFailLoadingMapCallback; + std::function<void()> didFinishLoadingStyleCallback; +}; + struct MapTest { util::RunLoop runLoop; - HeadlessBackend backend { test::sharedDisplay() }; + BackendTest backend; + BackendScope scope { backend }; OffscreenView view { backend.getContext() }; StubFileSource fileSource; ThreadPool threadPool { 4 }; @@ -44,8 +65,29 @@ TEST(Map, LatLngBehavior) { map.setLatLng({ 1, 1 }); auto latLng2 = map.getLatLng(); - ASSERT_DOUBLE_EQ(latLng1.latitude, latLng2.latitude); - ASSERT_DOUBLE_EQ(latLng1.longitude, latLng2.longitude); + ASSERT_DOUBLE_EQ(latLng1.latitude(), latLng2.latitude()); + ASSERT_DOUBLE_EQ(latLng1.longitude(), latLng2.longitude()); +} + +TEST(Map, CameraToLatLngBounds) { + MapTest test; + Map map(test.backend, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + + map.setLatLngZoom({ 45, 90 }, 16); + + LatLngBounds bounds = LatLngBounds::hull( + map.latLngForPixel({}), + map.latLngForPixel({ double(map.getSize().width), double(map.getSize().height) })); + + CameraOptions camera = map.getCameraOptions({}); + + ASSERT_EQ(bounds, map.latLngBoundsForCamera(camera)); + + // Map::cameraForLatLngBounds only sets zoom and center. + CameraOptions virtualCamera = 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) { @@ -85,11 +127,9 @@ TEST(Map, SetStyleInvalidJSON) { Log::setObserver(std::make_unique<FixtureLogObserver>()); bool fail = false; - test.backend.setMapChangeCallback([&](MapChange change) { - if (change == mbgl::MapChangeDidFailLoadingMap) { - fail = true; - } - }); + test.backend.didFailLoadingMapCallback = [&]() { + fail = true; + }; { Map map(test.backend, test.view.getSize(), 1, test.fileSource, test.threadPool, @@ -118,11 +158,9 @@ TEST(Map, SetStyleInvalidURL) { return response; }; - test.backend.setMapChangeCallback([&](MapChange change) { - if (change == mbgl::MapChangeDidFailLoadingMap) { - test.runLoop.stop(); - } - }); + test.backend.didFailLoadingMapCallback = [&]() { + test.runLoop.stop(); + }; Map map(test.backend, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); map.setStyleURL("mapbox://bar"); @@ -233,11 +271,9 @@ TEST(Map, StyleLoadedSignal) { // The map should emit a signal on style loaded bool emitted = false; - test.backend.setMapChangeCallback([&](MapChange change) { - if (change == mbgl::MapChangeDidFinishLoadingStyle) { - emitted = true; - } - }); + test.backend.didFinishLoadingStyleCallback = [&]() { + emitted = true; + }; map.setStyleJSON(util::read_file("test/fixtures/api/empty.json")); EXPECT_TRUE(emitted); @@ -255,11 +291,9 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNetworkErrorRetry)) { Map map(test.backend, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); map.setStyleURL("http://127.0.0.1:3000/style-fail-once-500"); - test.backend.setMapChangeCallback([&](MapChange change) { - if (change == mbgl::MapChangeDidFinishLoadingStyle) { - test.runLoop.stop(); - } - }); + test.backend.didFinishLoadingStyleCallback = [&]() { + test.runLoop.stop(); + }; test.runLoop.run(); } @@ -275,17 +309,15 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNotFound)) { util::Timer timer; // Not found errors should not trigger a retry like other errors. - test.backend.setMapChangeCallback([&](MapChange change) { - if (change == mbgl::MapChangeDidFinishLoadingStyle) { - FAIL() << "Should not retry on not found!"; - } + test.backend.didFinishLoadingStyleCallback = [&]() { + FAIL() << "Should not retry on not found!"; + }; - if (change == mbgl::MapChangeDidFailLoadingMap) { - timer.start(Milliseconds(1100), 0s, [&] { - test.runLoop.stop(); - }); - } - }); + test.backend.didFailLoadingMapCallback = [&]() { + timer.start(Milliseconds(1100), 0s, [&] { + test.runLoop.stop(); + }); + }; test.runLoop.run(); @@ -542,6 +574,7 @@ public: TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) { util::RunLoop runLoop; MockBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view { backend.getContext() }; ThreadPool threadPool { 4 }; @@ -575,7 +608,7 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) { }); } - BackendScope scope(backend); + BackendScope scope2(backend); map.render(view); }}; diff --git a/test/map/transform.test.cpp b/test/map/transform.test.cpp index 9125b6ef1d..69e3eb7c64 100644 --- a/test/map/transform.test.cpp +++ b/test/map/transform.test.cpp @@ -8,97 +8,63 @@ using namespace mbgl; TEST(Transform, InvalidScale) { Transform transform; - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(1, transform.getScale()); transform.setScale(2 << 0); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); + 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(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(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(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(0, transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(2, transform.getScale()); } -TEST(Transform, InvalidLatLng) { - Transform transform; - - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); - ASSERT_DOUBLE_EQ(1, transform.getScale()); - - transform.setScale(2 << 0); - 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) { Transform transform; - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(1, transform.getScale()); transform.setScale(2 << 0); transform.setAngle(2); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); + 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(0, transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(2, transform.getScale()); ASSERT_DOUBLE_EQ(2, transform.getAngle()); } @@ -144,16 +110,16 @@ TEST(Transform, PerspectiveProjection) { // expected values are from mapbox-gl-js loc = transform.getLatLng(); - ASSERT_NEAR(-77, loc.longitude, 0.0001); - ASSERT_NEAR(38, loc.latitude, 0.0001); + ASSERT_NEAR(-77, loc.longitude(), 0.0001); + ASSERT_NEAR(38, loc.latitude(), 0.0001); loc = transform.getState().screenCoordinateToLatLng({ 0, 1000 }); - ASSERT_NEAR(-77.59198961199148, loc.longitude, 0.0002); - ASSERT_NEAR(38.74661326302018, loc.latitude, 0.0001); + ASSERT_NEAR(-77.59198961199148, loc.longitude(), 0.0002); + ASSERT_NEAR(38.74661326302018, loc.latitude(), 0.0001); loc = transform.getState().screenCoordinateToLatLng({ 1000, 0 }); - ASSERT_NEAR(-76.75823239205641, loc.longitude, 0.0001); - ASSERT_NEAR(37.692872969426375, loc.latitude, 0.0001); + ASSERT_NEAR(-76.75823239205641, loc.longitude(), 0.0001); + ASSERT_NEAR(37.692872969426375, loc.latitude(), 0.0001); ScreenCoordinate point = transform.getState().latLngToScreenCoordinate({38.74661326302018, -77.59198961199148}); ASSERT_NEAR(point.x, 0, 0.01); @@ -174,24 +140,24 @@ TEST(Transform, UnwrappedLatLng) { const TransformState& state = transform.getState(); LatLng fromGetLatLng = state.getLatLng(); - ASSERT_DOUBLE_EQ(fromGetLatLng.latitude, 38); - ASSERT_DOUBLE_EQ(fromGetLatLng.longitude, -77); + ASSERT_DOUBLE_EQ(fromGetLatLng.latitude(), 38); + ASSERT_DOUBLE_EQ(fromGetLatLng.longitude(), -77); LatLng fromScreenCoordinate = state.screenCoordinateToLatLng({ 500, 500 }); - ASSERT_NEAR(fromScreenCoordinate.latitude, 37.999999999999829, 0.0001); // 1.71E-13 - ASSERT_NEAR(fromScreenCoordinate.longitude, -76.999999999999773, 0.0001); // 2.27E-13 + ASSERT_NEAR(fromScreenCoordinate.latitude(), 37.999999999999829, 0.0001); // 1.71E-13 + ASSERT_NEAR(fromScreenCoordinate.longitude(), -76.999999999999773, 0.0001); // 2.27E-13 LatLng wrappedForwards = state.screenCoordinateToLatLng(state.latLngToScreenCoordinate({ 38, 283 })); - ASSERT_NEAR(wrappedForwards.latitude, 37.999999999999716, 0.0001); // 2.84E-13 - ASSERT_NEAR(wrappedForwards.longitude, 282.99999999988751, 0.0001); // 1.1249E-11 + ASSERT_NEAR(wrappedForwards.latitude(), 37.999999999999716, 0.0001); // 2.84E-13 + ASSERT_NEAR(wrappedForwards.longitude(), 282.99999999988751, 0.0001); // 1.1249E-11 wrappedForwards.wrap(); - ASSERT_NEAR(wrappedForwards.longitude, -77.000000000112493, 0.001); // 1.1249E-11 + ASSERT_NEAR(wrappedForwards.longitude(), -77.000000000112493, 0.001); // 1.1249E-11 LatLng wrappedBackwards = state.screenCoordinateToLatLng(state.latLngToScreenCoordinate({ 38, -437 })); - ASSERT_NEAR(wrappedBackwards.latitude, wrappedForwards.latitude, 0.001); - ASSERT_NEAR(wrappedBackwards.longitude, -436.99999999988728, 0.001); // 1.1272E-11 + ASSERT_NEAR(wrappedBackwards.latitude(), wrappedForwards.latitude(), 0.001); + ASSERT_NEAR(wrappedBackwards.longitude(), -436.99999999988728, 0.001); // 1.1272E-11 wrappedBackwards.wrap(); - ASSERT_NEAR(wrappedBackwards.longitude, -76.99999999988728, 0.001); // 1.1272E-11 + ASSERT_NEAR(wrappedBackwards.longitude(), -76.99999999988728, 0.001); // 1.1272E-11 } TEST(Transform, ConstrainHeightOnly) { @@ -203,31 +169,31 @@ TEST(Transform, ConstrainHeightOnly) { transform.setLatLng(LatLngBounds::world().southwest()); loc = transform.getLatLng(); - ASSERT_NEAR(-util::LATITUDE_MAX, loc.latitude, 0.001); - ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude), 0.001); + ASSERT_NEAR(-util::LATITUDE_MAX, loc.latitude(), 0.001); + ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude()), 0.001); transform.setLatLng(LatLngBounds::world().northeast()); loc = transform.getLatLng(); - ASSERT_NEAR(util::LATITUDE_MAX, loc.latitude, 0.001); - ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude), 0.001); + ASSERT_NEAR(util::LATITUDE_MAX, loc.latitude(), 0.001); + ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude()), 0.001); } TEST(Transform, ConstrainWidthAndHeight) { LatLng loc; - Transform transform(nullptr, ConstrainMode::WidthAndHeight); + Transform transform(MapObserver::nullObserver(), ConstrainMode::WidthAndHeight); transform.resize({ 1000, 1000 }); transform.setScale(std::pow(2, util::MAX_ZOOM)); transform.setLatLng(LatLngBounds::world().southwest()); loc = transform.getLatLng(); - ASSERT_NEAR(-util::LATITUDE_MAX, loc.latitude, 0.001); - ASSERT_NEAR(-util::LONGITUDE_MAX, loc.longitude, 0.001); + ASSERT_NEAR(-util::LATITUDE_MAX, loc.latitude(), 0.001); + ASSERT_NEAR(-util::LONGITUDE_MAX, loc.longitude(), 0.001); transform.setLatLng(LatLngBounds::world().northeast()); loc = transform.getLatLng(); - ASSERT_NEAR(util::LATITUDE_MAX, loc.latitude, 0.001); - ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude), 0.001); + ASSERT_NEAR(util::LATITUDE_MAX, loc.latitude(), 0.001); + ASSERT_NEAR(util::LONGITUDE_MAX, std::abs(loc.longitude()), 0.001); } TEST(Transform, Anchor) { @@ -237,8 +203,8 @@ TEST(Transform, Anchor) { const LatLng latLng { 10, -100 }; transform.setLatLngZoom(latLng, 10); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(10, transform.getZoom()); ASSERT_DOUBLE_EQ(0, transform.getAngle()); @@ -246,102 +212,102 @@ TEST(Transform, Anchor) { const ScreenCoordinate anchorPoint = { 150, 150 }; const LatLng anchorLatLng = transform.getState().screenCoordinateToLatLng(anchorPoint); - ASSERT_NE(latLng.latitude, anchorLatLng.latitude); - ASSERT_NE(latLng.longitude, anchorLatLng.longitude); + ASSERT_NE(latLng.latitude(), anchorLatLng.latitude()); + ASSERT_NE(latLng.longitude(), anchorLatLng.longitude()); transform.setLatLngZoom(latLng, 2); transform.scaleBy(1); ASSERT_DOUBLE_EQ(4, transform.getScale()); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.scaleBy(1.5, invalidAnchorPoint); ASSERT_DOUBLE_EQ(6, transform.getScale()); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.scaleBy(2, anchorPoint); ASSERT_DOUBLE_EQ(12, transform.getScale()); - ASSERT_NE(latLng.latitude, transform.getLatLng().latitude); - ASSERT_NE(latLng.longitude, transform.getLatLng().longitude); + ASSERT_NE(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_NE(latLng.longitude(), transform.getLatLng().longitude()); transform.setLatLngZoom(latLng, 10); transform.setScale(2 << 2); ASSERT_DOUBLE_EQ(2 << 2, transform.getScale()); - ASSERT_NEAR(latLng.latitude, transform.getLatLng().latitude, 0.000001); - ASSERT_NEAR(latLng.longitude, transform.getLatLng().longitude, 0.000001); + ASSERT_NEAR(latLng.latitude(), transform.getLatLng().latitude(), 0.000001); + ASSERT_NEAR(latLng.longitude(), transform.getLatLng().longitude(), 0.000001); transform.setScale(2 << 4, invalidAnchorPoint); ASSERT_DOUBLE_EQ(2 << 4, transform.getScale()); - ASSERT_NEAR(latLng.latitude, transform.getLatLng().latitude, 0.000001); - ASSERT_NEAR(latLng.longitude, transform.getLatLng().longitude, 0.000001); + ASSERT_NEAR(latLng.latitude(), transform.getLatLng().latitude(), 0.000001); + ASSERT_NEAR(latLng.longitude(), transform.getLatLng().longitude(), 0.000001); transform.setScale(2 << 6, anchorPoint); ASSERT_DOUBLE_EQ(2 << 6, transform.getScale()); - ASSERT_NE(latLng.latitude, transform.getLatLng().latitude); - ASSERT_NE(latLng.longitude, transform.getLatLng().longitude); + ASSERT_NE(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_NE(latLng.longitude(), transform.getLatLng().longitude()); transform.setLatLngZoom(latLng, 10); transform.setZoom(2); ASSERT_DOUBLE_EQ(2, transform.getZoom()); - ASSERT_NEAR(latLng.latitude, transform.getLatLng().latitude, 0.000001); - ASSERT_NEAR(latLng.longitude, transform.getLatLng().longitude, 0.000001); + ASSERT_NEAR(latLng.latitude(), transform.getLatLng().latitude(), 0.000001); + ASSERT_NEAR(latLng.longitude(), transform.getLatLng().longitude(), 0.000001); transform.setZoom(4, invalidAnchorPoint); ASSERT_DOUBLE_EQ(4, transform.getZoom()); - ASSERT_NEAR(latLng.latitude, transform.getLatLng().latitude, 0.000001); - ASSERT_NEAR(latLng.longitude, transform.getLatLng().longitude, 0.000001); + ASSERT_NEAR(latLng.latitude(), transform.getLatLng().latitude(), 0.000001); + ASSERT_NEAR(latLng.longitude(), transform.getLatLng().longitude(), 0.000001); transform.setZoom(8, anchorPoint); ASSERT_DOUBLE_EQ(8, transform.getZoom()); - ASSERT_NE(latLng.latitude, transform.getLatLng().latitude); - ASSERT_NE(latLng.longitude, transform.getLatLng().longitude); + ASSERT_NE(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_NE(latLng.longitude(), transform.getLatLng().longitude()); transform.setLatLngZoom(latLng, 10); transform.setAngle(M_PI_4); ASSERT_NEAR(M_PI_4, transform.getAngle(), 0.000001); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.setAngle(0, invalidAnchorPoint); ASSERT_DOUBLE_EQ(0, transform.getAngle()); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.setAngle(45 * util::DEG2RAD, anchorPoint); ASSERT_NEAR(45 / util::RAD2DEG, transform.getAngle(), 0.000001); - ASSERT_NEAR(anchorLatLng.latitude, transform.getLatLng().latitude, 1); - ASSERT_NEAR(anchorLatLng.longitude, transform.getLatLng().longitude, 1); + ASSERT_NEAR(anchorLatLng.latitude(), transform.getLatLng().latitude(), 1); + ASSERT_NEAR(anchorLatLng.longitude(), transform.getLatLng().longitude(), 1); transform.setLatLngZoom(latLng, 10); transform.setPitch(10 * util::DEG2RAD); ASSERT_DOUBLE_EQ(10 / util::RAD2DEG, transform.getPitch()); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.setPitch(15 * util::DEG2RAD, invalidAnchorPoint); ASSERT_DOUBLE_EQ(15 / util::RAD2DEG, transform.getPitch()); - ASSERT_DOUBLE_EQ(latLng.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude()); transform.setPitch(20 * util::DEG2RAD, anchorPoint); ASSERT_DOUBLE_EQ(20 / util::RAD2DEG, transform.getPitch()); - ASSERT_NEAR(anchorLatLng.latitude, transform.getLatLng().latitude, 1); - ASSERT_NEAR(anchorLatLng.longitude, transform.getLatLng().longitude, 1); + ASSERT_NEAR(anchorLatLng.latitude(), transform.getLatLng().latitude(), 1); + ASSERT_NEAR(anchorLatLng.longitude(), transform.getLatLng().longitude(), 1); } TEST(Transform, Padding) { Transform transform; transform.resize({ 1000, 1000 }); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude()); transform.setLatLngZoom({ 10, -100 }, 10); const LatLng trueCenter = transform.getLatLng(); - ASSERT_DOUBLE_EQ(10, trueCenter.latitude); - ASSERT_DOUBLE_EQ(-100, trueCenter.longitude); + ASSERT_DOUBLE_EQ(10, trueCenter.latitude()); + ASSERT_DOUBLE_EQ(-100, trueCenter.longitude()); ASSERT_DOUBLE_EQ(10, transform.getZoom()); const LatLng manualShiftedCenter = transform.getState().screenCoordinateToLatLng({ @@ -349,22 +315,12 @@ TEST(Transform, Padding) { 1000.0 / 4.0, }); - EdgeInsets padding; - - padding.top = 0; - ASSERT_FALSE(bool(padding)); - - padding.top = NAN; - ASSERT_FALSE(bool(padding)); - - padding.top = 1000.0 / 2.0; - ASSERT_TRUE(bool(padding)); - + EdgeInsets padding(1000.0 / 2.0, 0, 0, 0); const LatLng shiftedCenter = transform.getLatLng(padding); - ASSERT_NE(trueCenter.latitude, shiftedCenter.latitude); - ASSERT_NEAR(trueCenter.longitude, shiftedCenter.longitude, 1e-9); - ASSERT_DOUBLE_EQ(manualShiftedCenter.latitude, shiftedCenter.latitude); - ASSERT_DOUBLE_EQ(manualShiftedCenter.longitude, shiftedCenter.longitude); + ASSERT_NE(trueCenter.latitude(), shiftedCenter.latitude()); + ASSERT_NEAR(trueCenter.longitude(), shiftedCenter.longitude(), 1e-9); + ASSERT_DOUBLE_EQ(manualShiftedCenter.latitude(), shiftedCenter.latitude()); + ASSERT_DOUBLE_EQ(manualShiftedCenter.longitude(), shiftedCenter.longitude()); } TEST(Transform, MoveBy) { @@ -373,8 +329,8 @@ TEST(Transform, MoveBy) { transform.setLatLngZoom({ 0, 0 }, 10); LatLng trueCenter = transform.getLatLng(); - ASSERT_DOUBLE_EQ(0, trueCenter.latitude); - ASSERT_DOUBLE_EQ(0, trueCenter.longitude); + ASSERT_DOUBLE_EQ(0, trueCenter.latitude()); + ASSERT_DOUBLE_EQ(0, trueCenter.longitude()); ASSERT_DOUBLE_EQ(10, transform.getZoom()); for (uint8_t x = 0; x < 20; ++x) { @@ -385,13 +341,13 @@ TEST(Transform, MoveBy) { transform.moveBy({ odd ? 100. : -100., forward ? 100. : -100 }); trueCenter = transform.getLatLng(); - ASSERT_NEAR(coordinate.latitude, trueCenter.latitude, 0.0001); - ASSERT_NEAR(coordinate.longitude, trueCenter.longitude, 0.0001); + ASSERT_NEAR(coordinate.latitude(), trueCenter.latitude(), 0.0001); + ASSERT_NEAR(coordinate.longitude(), trueCenter.longitude(), 0.0001); } // We have ~1.1 precision loss for each coordinate for 20 rounds of moveBy. - ASSERT_NEAR(0, trueCenter.latitude, 1.1); - ASSERT_NEAR(0, trueCenter.longitude, 1.1); + ASSERT_NEAR(0, trueCenter.latitude(), 1.1); + ASSERT_NEAR(0, trueCenter.longitude(), 1.1); } TEST(Transform, Antimeridian) { @@ -420,21 +376,21 @@ TEST(Transform, Antimeridian) { ASSERT_NEAR(500, pixelWaikiri.x, 1e-2); ASSERT_NEAR(500, pixelWaikiri.y, 1e-2); - transform.setLatLng({ coordinateWaikiri.latitude, 180.0213 }); + transform.setLatLng({ coordinateWaikiri.latitude(), 180.0213 }); ScreenCoordinate pixelWaikiriForwards = transform.latLngToScreenCoordinate(coordinateWaikiri); ASSERT_NEAR(437.95953728819512, pixelWaikiriForwards.x, 1e-2); ASSERT_DOUBLE_EQ(pixelWaikiri.y, pixelWaikiriForwards.y); LatLng coordinateFromPixel = transform.screenCoordinateToLatLng(pixelWaikiriForwards); - ASSERT_NEAR(coordinateWaikiri.latitude, coordinateFromPixel.latitude, 0.000001); - ASSERT_NEAR(coordinateWaikiri.longitude, coordinateFromPixel.longitude, 0.000001); + ASSERT_NEAR(coordinateWaikiri.latitude(), coordinateFromPixel.latitude(), 0.000001); + ASSERT_NEAR(coordinateWaikiri.longitude(), coordinateFromPixel.longitude(), 0.000001); - transform.setLatLng({ coordinateWaikiri.latitude, -179.9787 }); + transform.setLatLng({ coordinateWaikiri.latitude(), -179.9787 }); ScreenCoordinate pixelWaikiriBackwards = transform.latLngToScreenCoordinate(coordinateWaikiri); ASSERT_DOUBLE_EQ(pixelWaikiriForwards.x, pixelWaikiriBackwards.x); ASSERT_DOUBLE_EQ(pixelWaikiriForwards.y, pixelWaikiriBackwards.y); coordinateFromPixel = transform.screenCoordinateToLatLng(pixelWaikiriBackwards); - ASSERT_NEAR(coordinateWaikiri.latitude, coordinateFromPixel.latitude, 0.000001); - ASSERT_NEAR(coordinateWaikiri.longitude, coordinateFromPixel.longitude, 0.000001); + ASSERT_NEAR(coordinateWaikiri.latitude(), coordinateFromPixel.latitude(), 0.000001); + ASSERT_NEAR(coordinateWaikiri.longitude(), coordinateFromPixel.longitude(), 0.000001); } TEST(Transform, Camera) { @@ -447,8 +403,8 @@ TEST(Transform, Camera) { cameraOptions1.center = latLng1; transform.jumpTo(cameraOptions1); - ASSERT_DOUBLE_EQ(latLng1.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng1.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng1.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng1.longitude(), transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(20, transform.getZoom()); const LatLng latLng2 { -45, -135 }; @@ -457,19 +413,19 @@ TEST(Transform, Camera) { cameraOptions2.center = latLng2; transform.jumpTo(cameraOptions2); - ASSERT_DOUBLE_EQ(latLng2.latitude, transform.getLatLng().latitude); - ASSERT_DOUBLE_EQ(latLng2.longitude, transform.getLatLng().longitude); + ASSERT_DOUBLE_EQ(latLng2.latitude(), transform.getLatLng().latitude()); + ASSERT_DOUBLE_EQ(latLng2.longitude(), transform.getLatLng().longitude()); ASSERT_DOUBLE_EQ(10, transform.getZoom()); AnimationOptions easeOptions(Seconds(1)); easeOptions.transitionFrameFn = [&](double t) { ASSERT_TRUE(t >= 0 && t <= 1); - ASSERT_GE(latLng1.latitude, transform.getLatLng().latitude); - ASSERT_LE(latLng1.longitude, transform.getLatLng().longitude); + ASSERT_GE(latLng1.latitude(), transform.getLatLng().latitude()); + ASSERT_LE(latLng1.longitude(), transform.getLatLng().longitude()); }; easeOptions.transitionFinishFn = [&]() { - ASSERT_NEAR(latLng1.latitude, transform.getLatLng().latitude, 0.000001); - ASSERT_NEAR(latLng1.longitude, transform.getLatLng().longitude, 0.000001); + ASSERT_NEAR(latLng1.latitude(), transform.getLatLng().latitude(), 0.000001); + ASSERT_NEAR(latLng1.longitude(), transform.getLatLng().longitude(), 0.000001); ASSERT_NEAR(20, transform.getZoom(), 0.000001); }; @@ -484,14 +440,14 @@ TEST(Transform, Camera) { AnimationOptions flyOptions(Seconds(1)); flyOptions.transitionFrameFn = [&](double t) { ASSERT_TRUE(t >= 0 && t <= 1); - ASSERT_LE(latLng2.latitude, transform.getLatLng().latitude); - ASSERT_GE(latLng2.longitude, transform.getLatLng().longitude); + ASSERT_LE(latLng2.latitude(), transform.getLatLng().latitude()); + ASSERT_GE(latLng2.longitude(), transform.getLatLng().longitude()); }; flyOptions.transitionFinishFn = [&]() { // XXX Fix precision loss in flyTo: // https://github.com/mapbox/mapbox-gl-native/issues/4298 - ASSERT_NEAR(latLng2.latitude, transform.getLatLng().latitude, 0.001); - ASSERT_NEAR(latLng2.longitude, transform.getLatLng().longitude, 0.001); + ASSERT_NEAR(latLng2.latitude(), transform.getLatLng().latitude(), 0.001); + ASSERT_NEAR(latLng2.longitude(), transform.getLatLng().longitude(), 0.001); ASSERT_NEAR(10, transform.getZoom(), 0.00001); }; @@ -505,41 +461,133 @@ TEST(Transform, Camera) { } TEST(Transform, DefaultTransform) { - Transform transform; + struct TransformObserver : public mbgl::MapObserver { + void onCameraWillChange(MapObserver::CameraChangeMode) final { + cameraWillChangeCallback(); + }; + + void onCameraDidChange(MapObserver::CameraChangeMode) final { + cameraDidChangeCallback(); + }; + + std::function<void()> cameraWillChangeCallback; + std::function<void()> cameraDidChangeCallback; + }; + + uint32_t cameraWillChangeCount = 0; + uint32_t cameraDidChangeCount = 0; + + TransformObserver observer; + observer.cameraWillChangeCallback = [&cameraWillChangeCount]() { cameraWillChangeCount++; }; + observer.cameraDidChangeCallback = [&cameraDidChangeCount]() { cameraDidChangeCount++; }; + + Transform transform(observer); const TransformState& state = transform.getState(); + ASSERT_FALSE(state.valid()); LatLng nullIsland, latLng = {}; ScreenCoordinate center, point = {}; const uint32_t min = 0; const uint32_t max = 65535; - auto testConversions = [&](const LatLng& coord, const ScreenCoordinate& screenCoord) { - latLng = state.screenCoordinateToLatLng(center); - ASSERT_NEAR(latLng.latitude, coord.latitude, 0.000001); - ASSERT_NEAR(latLng.longitude, coord.longitude, 0.000001); - point = state.latLngToScreenCoordinate(nullIsland); - ASSERT_DOUBLE_EQ(point.x, screenCoord.x); - ASSERT_DOUBLE_EQ(point.y, screenCoord.y); - }; - - testConversions(nullIsland, center); + // Cannot assign invalid sizes. + std::vector<Size> invalidSizes = { {}, { min, max }, { max, min } }; + for (const Size& size : invalidSizes) { + ASSERT_TRUE(size.isEmpty()); + bool pass = false; + try { + transform.resize(size); + } catch (...) { + pass = true; + } + ASSERT_TRUE(pass) << "Expected to throw"; + } - // Cannot assign the current size. - ASSERT_FALSE(transform.resize({})); + Size validSize { max, max }; + ASSERT_FALSE(validSize.isEmpty()); - ASSERT_TRUE(transform.resize({ min, max })); - testConversions(nullIsland, center); + try { + transform.resize(validSize); + ASSERT_EQ(cameraWillChangeCount, 1u); + ASSERT_EQ(cameraDidChangeCount, 1u); + } catch (...) { + ASSERT_TRUE(false) << "Should not throw"; + } - ASSERT_TRUE(transform.resize({ max, min })); - testConversions(nullIsland, center); + ASSERT_TRUE(state.valid()); - ASSERT_TRUE(transform.resize({ min, min })); - testConversions(nullIsland, center); + // Double resize + try { + transform.resize(validSize); + ASSERT_EQ(cameraWillChangeCount, 1u); + ASSERT_EQ(cameraDidChangeCount, 1u); + } catch (...) { + ASSERT_TRUE(false) << "Should not throw"; + } center = { max / 2., max / 2. }; + latLng = state.screenCoordinateToLatLng(center); + ASSERT_NEAR(latLng.latitude(), nullIsland.latitude(), 1e-5); + ASSERT_NEAR(latLng.longitude(), nullIsland.longitude(), 1e-5); - // Double resize - ASSERT_TRUE(transform.resize({ max, max })); - ASSERT_FALSE(transform.resize({ max, max })); - testConversions(nullIsland, center); + point = state.latLngToScreenCoordinate(nullIsland); + ASSERT_DOUBLE_EQ(point.x, center.x); + ASSERT_DOUBLE_EQ(point.y, center.y); +} + +TEST(Transform, LatLngBounds) { + const LatLng nullIsland {}; + const LatLng sanFrancisco { 37.7749, -122.4194 }; + + Transform transform; + transform.resize({ 1000, 1000 }); + transform.setLatLngZoom({ 0, 0 }, transform.getState().getMaxZoom()); + + // Default bounds. + ASSERT_EQ(transform.getState().getLatLngBounds(), LatLngBounds::world()); + ASSERT_EQ(transform.getLatLng(), nullIsland); + + // Invalid bounds. + transform.setLatLngBounds(LatLngBounds::empty()); + ASSERT_EQ(transform.getState().getLatLngBounds(), LatLngBounds::world()); + + transform.setLatLng(sanFrancisco); + ASSERT_EQ(transform.getLatLng(), sanFrancisco); + + // Single location. + transform.setLatLngBounds(LatLngBounds::singleton(sanFrancisco)); + ASSERT_EQ(transform.getLatLng(), sanFrancisco); + + transform.setLatLngBounds(LatLngBounds::hull({ -90.0, -180.0 }, { 0.0, 180.0 })); + transform.setLatLng(sanFrancisco); + ASSERT_EQ(transform.getLatLng().latitude(), 0.0); + ASSERT_EQ(transform.getLatLng().longitude(), sanFrancisco.longitude()); + + transform.setLatLngBounds(LatLngBounds::hull({ -90.0, 0.0 }, { 90.0, 180.0 })); + transform.setLatLng(sanFrancisco); + ASSERT_EQ(transform.getLatLng().latitude(), sanFrancisco.latitude()); + ASSERT_EQ(transform.getLatLng().longitude(), 0.0); + + transform.setLatLngBounds(LatLngBounds::hull({ -90.0, 0.0 }, { 0.0, 180.0 })); + transform.setLatLng(sanFrancisco); + ASSERT_EQ(transform.getLatLng().latitude(), 0.0); + ASSERT_EQ(transform.getLatLng().longitude(), 0.0); +} + +TEST(Transform, PitchBounds) { + Transform transform; + transform.resize({ 1000, 1000 }); + transform.setLatLngZoom({ 0, 0 }, transform.getState().getMaxZoom()); + + ASSERT_DOUBLE_EQ(transform.getState().getPitch() * util::RAD2DEG, 0.0); + ASSERT_DOUBLE_EQ(transform.getState().getMinPitch() * util::RAD2DEG, 0.0); + ASSERT_DOUBLE_EQ(transform.getState().getMaxPitch() * util::RAD2DEG, 60.0); + + transform.setMinPitch(45.0 * util::DEG2RAD); + transform.setPitch(0.0 * util::DEG2RAD); + ASSERT_NEAR(transform.getState().getPitch() * util::RAD2DEG, 45.0, 1e-5); + + transform.setMaxPitch(55.0 * util::DEG2RAD); + transform.setPitch(60.0 * util::DEG2RAD); + ASSERT_NEAR(transform.getState().getPitch() * util::RAD2DEG, 55.0, 1e-5); } diff --git a/test/sprite/sprite_atlas.test.cpp b/test/sprite/sprite_atlas.test.cpp index 2c425a95d2..2335165715 100644 --- a/test/sprite/sprite_atlas.test.cpp +++ b/test/sprite/sprite_atlas.test.cpp @@ -29,15 +29,17 @@ TEST(SpriteAtlas, Basic) { EXPECT_EQ(112u, atlas.getSize().height); auto metro = *atlas.getIcon("metro"); + float imagePixelRatio = metro.relativePixelRatio * atlas.getPixelRatio(); EXPECT_EQ(0, metro.pos.x); EXPECT_EQ(0, metro.pos.y); EXPECT_EQ(20, metro.pos.w); EXPECT_EQ(20, metro.pos.h); - EXPECT_EQ(18, metro.spriteImage->getWidth()); - EXPECT_EQ(18, metro.spriteImage->getHeight()); - EXPECT_EQ(18u, metro.spriteImage->image.size.width); - EXPECT_EQ(18u, metro.spriteImage->image.size.height); - EXPECT_EQ(1.0f, metro.spriteImage->pixelRatio); + EXPECT_EQ(18, metro.width); + EXPECT_EQ(18, metro.height); + EXPECT_EQ(18u, metro.width * imagePixelRatio); + EXPECT_EQ(18u, metro.height * imagePixelRatio); + EXPECT_EQ(1.0f, imagePixelRatio); + EXPECT_EQ(63u, atlas.getAtlasImage().size.width); EXPECT_EQ(112u, atlas.getAtlasImage().size.height); @@ -82,15 +84,16 @@ TEST(SpriteAtlas, Size) { EXPECT_EQ(112u, atlas.getSize().height); auto metro = *atlas.getIcon("metro"); + float imagePixelRatio = metro.relativePixelRatio * atlas.getPixelRatio(); EXPECT_EQ(0, metro.pos.x); EXPECT_EQ(0, metro.pos.y); EXPECT_EQ(16, metro.pos.w); EXPECT_EQ(16, metro.pos.h); - EXPECT_EQ(18, metro.spriteImage->getWidth()); - EXPECT_EQ(18, metro.spriteImage->getHeight()); - EXPECT_EQ(18u, metro.spriteImage->image.size.width); - EXPECT_EQ(18u, metro.spriteImage->image.size.height); - EXPECT_EQ(1.0f, metro.spriteImage->pixelRatio); + EXPECT_EQ(18, metro.width); + EXPECT_EQ(18, metro.height); + EXPECT_EQ(18u, metro.width * imagePixelRatio); + EXPECT_EQ(18u, metro.height * imagePixelRatio); + EXPECT_EQ(1.0f, imagePixelRatio); // Now the image was created lazily. EXPECT_EQ(89u, atlas.getAtlasImage().size.width); @@ -108,15 +111,16 @@ TEST(SpriteAtlas, Updates) { atlas.setSprite("one", std::make_shared<SpriteImage>(PremultipliedImage({ 16, 12 }), 1)); auto one = *atlas.getIcon("one"); + float imagePixelRatio = one.relativePixelRatio * atlas.getPixelRatio(); EXPECT_EQ(0, one.pos.x); EXPECT_EQ(0, one.pos.y); EXPECT_EQ(20, one.pos.w); EXPECT_EQ(16, one.pos.h); - EXPECT_EQ(16, one.spriteImage->getWidth()); - EXPECT_EQ(12, one.spriteImage->getHeight()); - EXPECT_EQ(16u, one.spriteImage->image.size.width); - EXPECT_EQ(12u, one.spriteImage->image.size.height); - EXPECT_EQ(1.0f, one.spriteImage->pixelRatio); + EXPECT_EQ(16, one.width); + EXPECT_EQ(12, one.height); + EXPECT_EQ(16u, one.width * imagePixelRatio); + EXPECT_EQ(12u, one.height * imagePixelRatio); + EXPECT_EQ(1.0f, imagePixelRatio); // Now the image was created lazily. EXPECT_EQ(32u, atlas.getAtlasImage().size.width); diff --git a/test/src/mbgl/test/stub_style_observer.hpp b/test/src/mbgl/test/stub_style_observer.hpp index 95280565ff..9312cfa550 100644 --- a/test/src/mbgl/test/stub_style_observer.hpp +++ b/test/src/mbgl/test/stub_style_observer.hpp @@ -30,8 +30,8 @@ public: if (sourceLoaded) sourceLoaded(source); } - void onSourceAttributionChanged(Source& source, const std::string& attribution) override { - if (sourceAttributionChanged) sourceAttributionChanged(source, attribution); + void onSourceChanged(Source& source) override { + if (sourceChanged) sourceChanged(source); } void onSourceError(Source& source, std::exception_ptr error) override { @@ -60,7 +60,7 @@ public: std::function<void ()> spriteLoaded; std::function<void (std::exception_ptr)> spriteError; std::function<void (Source&)> sourceLoaded; - std::function<void (Source&, std::string)> sourceAttributionChanged; + std::function<void (Source&)> sourceChanged; std::function<void (Source&, std::exception_ptr)> sourceError; std::function<void (Source&)> sourceDescriptionChanged; std::function<void (Source&, const OverscaledTileID&)> tileChanged; diff --git a/test/style/conversion/function.test.cpp b/test/style/conversion/function.test.cpp index 5a3ec93917..08637d40cb 100644 --- a/test/style/conversion/function.test.cpp +++ b/test/style/conversion/function.test.cpp @@ -10,45 +10,47 @@ 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<CameraFunction<float>>(doc); -} - TEST(StyleConversion, Function) { + Error error; + + auto parseFunction = [&](const std::string& src) { + JSDocument doc; + doc.Parse<0>(src); + return convert<CameraFunction<float>, JSValue>(doc, error); + }; + auto fn1 = parseFunction("{\"stops\":[]}"); ASSERT_FALSE(fn1); - ASSERT_EQ("function must have at least one stop", fn1.error().message); + ASSERT_EQ("function must have at least one stop", error.message); auto fn2 = parseFunction("{\"stops\":[1]}"); ASSERT_FALSE(fn2); - ASSERT_EQ("function stop must be an array", fn2.error().message); + ASSERT_EQ("function stop must be an array", error.message); auto fn3 = parseFunction("{\"stops\":[[]]}"); ASSERT_FALSE(fn3); - ASSERT_EQ("function stop must have two elements", fn3.error().message); + ASSERT_EQ("function stop must have two elements", 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); + ASSERT_EQ("function stop must have two elements", error.message); auto fn6 = parseFunction("{\"stops\":[[0,\"x\"]]}"); ASSERT_FALSE(fn6); - ASSERT_EQ("value must be a number", fn6.error().message); + ASSERT_EQ("value must be a number", error.message); auto fn7 = parseFunction("{}"); ASSERT_FALSE(fn7); - ASSERT_EQ("function value must specify stops", fn7.error().message); + ASSERT_EQ("function value must specify stops", error.message); auto fn8 = parseFunction("[]"); ASSERT_FALSE(fn8); - ASSERT_EQ("function must be an object", fn8.error().message); + ASSERT_EQ("function must be an object", error.message); auto fn9 = parseFunction("{\"stops\":[[0,0]],\"base\":false}"); ASSERT_FALSE(fn9); - ASSERT_EQ("function base must be a number", fn9.error().message); + ASSERT_EQ("function base must be a number", error.message); } diff --git a/test/style/conversion/geojson_options.test.cpp b/test/style/conversion/geojson_options.test.cpp index ddf261ea52..e6bd984f36 100644 --- a/test/style/conversion/geojson_options.test.cpp +++ b/test/style/conversion/geojson_options.test.cpp @@ -12,21 +12,24 @@ using namespace mbgl::style::conversion; TEST(GeoJSONOptions, Basic) { ValueMap map; Value raw(map); - Result<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw); + Error error; + mbgl::optional<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw, error); ASSERT_TRUE((bool) converted); } TEST(GeoJSONOptions, ErrorHandling) { ValueMap map {{"maxzoom", std::string{"should not be a string"}}}; Value raw(map); - Result<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw); + Error error; + mbgl::optional<GeoJSONOptions> converted = convert<GeoJSONOptions>(raw, error); ASSERT_FALSE((bool) converted); } TEST(GeoJSONOptions, RetainsDefaults) { ValueMap map; Value raw(map); - GeoJSONOptions converted = *convert<GeoJSONOptions>(raw); + Error error; + GeoJSONOptions converted = *convert<GeoJSONOptions>(raw, error); GeoJSONOptions defaults; // GeoJSON-VT @@ -54,7 +57,8 @@ TEST(GeoJSONOptions, FullConversion) { {"clusterMaxZoom", 5.0f} }; Value raw(map); - GeoJSONOptions converted = *convert<GeoJSONOptions>(raw); + Error error; + GeoJSONOptions converted = *convert<GeoJSONOptions>(raw, error); // GeoJSON-VT ASSERT_EQ(converted.maxzoom, 1); diff --git a/test/style/conversion/layer.test.cpp b/test/style/conversion/layer.test.cpp index b27c1841ee..cfe2662fb8 100644 --- a/test/style/conversion/layer.test.cpp +++ b/test/style/conversion/layer.test.cpp @@ -11,10 +11,11 @@ using namespace mbgl::style; using namespace mbgl::style::conversion; using namespace std::literals::chrono_literals; -auto parseLayer(const std::string& src) { +std::unique_ptr<Layer> parseLayer(const std::string& src) { JSDocument doc; doc.Parse<0>(src); - return convert<std::unique_ptr<Layer>, JSValue>(doc); + Error error; + return std::move(*convert<std::unique_ptr<Layer>, JSValue>(doc, error)); } TEST(StyleConversion, LayerTransition) { @@ -34,13 +35,13 @@ TEST(StyleConversion, LayerTransition) { } })JSON"); - ASSERT_EQ(400ms, *(*layer)->as<BackgroundLayer>()->impl->paint.cascading + ASSERT_EQ(400ms, *layer->as<BackgroundLayer>()->impl->paint.cascading .get<BackgroundColor>().getTransition({}).duration); - ASSERT_EQ(500ms, *(*layer)->as<BackgroundLayer>()->impl->paint.cascading + ASSERT_EQ(500ms, *layer->as<BackgroundLayer>()->impl->paint.cascading .get<BackgroundColor>().getTransition({}).delay); - ASSERT_EQ(100ms, *(*layer)->as<BackgroundLayer>()->impl->paint.cascading + ASSERT_EQ(100ms, *layer->as<BackgroundLayer>()->impl->paint.cascading .get<BackgroundColor>().getTransition({"class"}).duration); - ASSERT_FALSE(bool((*layer)->as<BackgroundLayer>()->impl->paint.cascading + ASSERT_FALSE(bool(layer->as<BackgroundLayer>()->impl->paint.cascading .get<BackgroundColor>().getTransition({"class"}).delay)); } diff --git a/test/style/filter.test.cpp b/test/style/filter.test.cpp index 33b64978f5..c70792d8ef 100644 --- a/test/style/filter.test.cpp +++ b/test/style/filter.test.cpp @@ -16,7 +16,10 @@ using namespace mbgl::style; Filter parse(const char * expression) { rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc; doc.Parse<0>(expression); - return *conversion::convert<Filter>(doc); + conversion::Error error; + optional<Filter> filter = conversion::convert<Filter, JSValue>(doc, error); + EXPECT_TRUE(bool(filter)); + return *filter; } Feature feature(const PropertyMap& properties, const Geometry<double>& geometry = Point<double>()) { diff --git a/test/style/function/composite_function.test.cpp b/test/style/function/composite_function.test.cpp new file mode 100644 index 0000000000..e0804d4b27 --- /dev/null +++ b/test/style/function/composite_function.test.cpp @@ -0,0 +1,46 @@ +#include <mbgl/test/util.hpp> +#include <mbgl/test/stub_geometry_tile_feature.hpp> + +#include <mbgl/style/function/composite_function.hpp> + +using namespace mbgl; +using namespace mbgl::style; + +using namespace std::string_literals; + +static StubGeometryTileFeature oneInteger { + PropertyMap {{ "property", uint64_t(1) }} +}; + +TEST(CompositeFunction, ZoomInterpolation) { + EXPECT_EQ(40.0f, CompositeFunction<float>("property", CompositeExponentialStops<float>({ + {0.0f, {{uint64_t(1), 24.0f}}}, + {1.5f, {{uint64_t(1), 36.0f}}}, + {3.0f, {{uint64_t(1), 48.0f}}} + }), 0.0f) + .evaluate(2.0f, oneInteger, -1.0f)) << "Should interpolate between stops"; + + EXPECT_EQ(33.0, CompositeFunction<float>("property", CompositeExponentialStops<float>({ + {5.0f, {{uint64_t(1), 33.0f}}}, + {10.0f, {{uint64_t(1), 66.0f}}} + }), 0.0f) + .evaluate(0.0f, oneInteger, -1.0f)) << "Use first stop output for input values from -inf to first stop"; + + EXPECT_EQ(66.0, CompositeFunction<float>("property", CompositeExponentialStops<float>({ + {0.0f, {{uint64_t(1), 33.0f}}}, + {10.0f, {{uint64_t(1), 66.0f}}} + }), 0.0f) + .evaluate(20.0f, oneInteger, -1.0f)) << "Use last stop output for input values from last stop to +inf"; + + EXPECT_EQ(66.0f, CompositeFunction<float>("property", CompositeExponentialStops<float>({ + {0.0f, {{uint64_t(1), 33.0f}}}, + {10.0f, {{uint64_t(1), 66.0f}}} + }), 0.0f) + .evaluate(10.0f, oneInteger, -1.0f)) << "Should interpolate TO the last stop."; + + EXPECT_EQ(33.0f, CompositeFunction<float>("property", CompositeExponentialStops<float>({ + {0.0f, {{uint64_t(1), 33.0f}}}, + {10.0f, {{uint64_t(1), 66.0f}}} + }), 0.0f) + .evaluate(0.0f, oneInteger, -1.0f)) << "Should interpolate TO the first stop"; +} diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp index fb7737e417..f637f1ccde 100644 --- a/test/style/source.test.cpp +++ b/test/style/source.test.cpp @@ -13,15 +13,20 @@ #include <mbgl/util/tileset.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/util/logging.hpp> +#include <mbgl/util/optional.hpp> +#include <mbgl/util/range.hpp> #include <mbgl/map/transform.hpp> #include <mbgl/style/style.hpp> #include <mbgl/style/update_parameters.hpp> #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/annotation/annotation_manager.hpp> +#include <mbgl/annotation/annotation_source.hpp> #include <mapbox/geojsonvt.hpp> +#include <cstdint> + using namespace mbgl; class SourceTest { @@ -65,6 +70,32 @@ public: } }; +TEST(Source, DefaultZoomRange) { + VectorSource vectorSource("vectorSource", "url"); + EXPECT_FALSE(vectorSource.getZoomRange()); + vectorSource.baseImpl->loaded = true; + EXPECT_EQ(vectorSource.getZoomRange()->min, 0u); + EXPECT_EQ(vectorSource.getZoomRange()->max, 22u); + + GeoJSONSource geojsonSource("source"); + EXPECT_FALSE(geojsonSource.getZoomRange()); + geojsonSource.baseImpl->loaded = true; + EXPECT_EQ(geojsonSource.getZoomRange()->min, 0u); + EXPECT_EQ(geojsonSource.getZoomRange()->max, 18u); + + Tileset tileset; + RasterSource rasterSource("source", tileset, 512); + EXPECT_FALSE(rasterSource.getZoomRange()); + rasterSource.baseImpl->loaded = true; + EXPECT_EQ(rasterSource.getZoomRange()->min, 0u); + EXPECT_EQ(rasterSource.getZoomRange()->max, 22u); + EXPECT_EQ(*rasterSource.getZoomRange(), tileset.zoomRange); + + AnnotationSource annotationSource; + EXPECT_EQ(annotationSource.getZoomRange()->min, 0u); + EXPECT_EQ(annotationSource.getZoomRange()->max, 22u); +} + TEST(Source, LoadingFail) { SourceTest test; @@ -364,8 +395,8 @@ TEST(Source, RasterTileAttribution) { return response; }; - test.observer.sourceAttributionChanged = [&] (Source&, std::string attribution) { - EXPECT_EQ(mapboxOSM, attribution); + test.observer.sourceChanged = [&] (Source& source) { + EXPECT_EQ(mapboxOSM, source.getAttribution()); EXPECT_FALSE(mapboxOSM.find("©️ OpenStreetMap") == std::string::npos); test.end(); }; diff --git a/test/text/glyph_atlas.test.cpp b/test/text/glyph_atlas.test.cpp index 3679cabc1b..f38c18c28c 100644 --- a/test/text/glyph_atlas.test.cpp +++ b/test/text/glyph_atlas.test.cpp @@ -11,12 +11,14 @@ using namespace mbgl; -class GlyphAtlasTest { +class GlyphAtlasTest : public GlyphRequestor { public: util::RunLoop loop; StubFileSource fileSource; StubStyleObserver observer; GlyphAtlas glyphAtlas{ { 32, 32 }, fileSource }; + GlyphPositionMap glyphPositions; + GlyphRangeSet loadedRanges; void run(const std::string& url, const FontStack& fontStack, const GlyphRangeSet& glyphRanges) { // Squelch logging. @@ -24,14 +26,31 @@ public: glyphAtlas.setObserver(&observer); glyphAtlas.setURL(url); + GlyphDependencies glyphDependencies; + for (const auto& range : glyphRanges) { + glyphDependencies[fontStack].insert(range.first); + } + glyphAtlas.getGlyphs(*this, glyphDependencies); glyphAtlas.hasGlyphRanges(fontStack, glyphRanges); loop.run(); } + void addGlyphs(GlyphRequestor& requestor, const GlyphDependencies& glyphDependencies) { + glyphAtlas.addGlyphs(requestor, glyphDependencies); + } + + bool hasGlyphRanges(const FontStack& fontStack, const GlyphRangeSet& ranges) const { + return glyphAtlas.hasGlyphRanges(fontStack, ranges); + } void end() { loop.stop(); } + + virtual void onGlyphsAvailable(GlyphPositionMap positions, GlyphRangeSet _loadedRanges) { + glyphPositions = std::move(positions); + loadedRanges = std::move(_loadedRanges); + } }; TEST(GlyphAtlas, LoadingSuccess) { @@ -50,11 +69,11 @@ TEST(GlyphAtlas, LoadingSuccess) { }; test.observer.glyphsLoaded = [&] (const FontStack&, const GlyphRange&) { - if (!test.glyphAtlas.hasGlyphRanges({{"Test Stack"}}, {{0, 255}, {256, 511}})) + if (!test.hasGlyphRanges({{"Test Stack"}}, {{0, 255}, {256, 511}})) return; - auto glyphSet = test.glyphAtlas.getGlyphSet({{"Test Stack"}}); - ASSERT_FALSE(glyphSet->getSDFs().empty()); + auto& glyphSet = test.glyphAtlas.getGlyphSet({{"Test Stack"}}); + ASSERT_FALSE(glyphSet.getSDFs().empty()); test.end(); }; @@ -83,8 +102,8 @@ TEST(GlyphAtlas, LoadingFail) { EXPECT_TRUE(error != nullptr); EXPECT_EQ(util::toString(error), "Failed by the test case"); - ASSERT_TRUE(test.glyphAtlas.getGlyphSet({{"Test Stack"}})->getSDFs().empty()); - ASSERT_FALSE(test.glyphAtlas.hasGlyphRanges({{"Test Stack"}}, {{0, 255}})); + ASSERT_TRUE(test.glyphAtlas.getGlyphSet({{"Test Stack"}}).getSDFs().empty()); + ASSERT_FALSE(test.hasGlyphRanges({{"Test Stack"}}, {{0, 255}})); test.end(); }; @@ -111,8 +130,8 @@ TEST(GlyphAtlas, LoadingCorrupted) { EXPECT_TRUE(error != nullptr); EXPECT_EQ(util::toString(error), "unknown pbf field type exception"); - ASSERT_TRUE(test.glyphAtlas.getGlyphSet({{"Test Stack"}})->getSDFs().empty()); - ASSERT_FALSE(test.glyphAtlas.hasGlyphRanges({{"Test Stack"}}, {{0, 255}})); + ASSERT_TRUE(test.glyphAtlas.getGlyphSet({{"Test Stack"}}).getSDFs().empty()); + ASSERT_FALSE(test.hasGlyphRanges({{"Test Stack"}}, {{0, 255}})); test.end(); }; @@ -145,19 +164,20 @@ TEST(GlyphAtlas, InvalidSDFGlyph) { const FontStack fontStack{ "Mock Font" }; GlyphAtlasTest test; - GlyphPositions positions; - auto glyphSet = test.glyphAtlas.getGlyphSet(fontStack); - glyphSet->insert(66, SDFGlyph{ 66 /* ASCII 'B' */, + auto& glyphSet = test.glyphAtlas.getGlyphSet(fontStack); + glyphSet.insert(SDFGlyph{ 66 /* ASCII 'B' */, AlphaImage({7, 7}), /* correct */ { 1 /* width */, 1 /* height */, 0 /* left */, 0 /* top */, 0 /* advance */ } }); - glyphSet->insert(67, SDFGlyph{ 67 /* ASCII 'C' */, + glyphSet.insert(SDFGlyph{ 67 /* ASCII 'C' */, AlphaImage({518, 8}), /* correct */ { 512 /* width */, 2 /* height */, 0 /* left */, 0 /* top */, 0 /* advance */ } }); - test.glyphAtlas.addGlyphs(1, std::u16string{u"ABC"}, fontStack, glyphSet, positions); + GlyphDependencies glyphDependencies = {{fontStack, {'A','B','C'}}}; + test.addGlyphs(test, glyphDependencies); + GlyphPositions positions = test.glyphPositions[fontStack]; ASSERT_EQ(2u, positions.size()); diff --git a/test/text/glyph_pbf.test.cpp b/test/text/glyph_pbf.test.cpp index be3ca3359b..c222ec1dd9 100644 --- a/test/text/glyph_pbf.test.cpp +++ b/test/text/glyph_pbf.test.cpp @@ -1,73 +1,23 @@ #include <mbgl/test/util.hpp> -#include <mbgl/text/glyph_set.hpp> -#include <mbgl/text/glyph_atlas_observer.hpp> -#include <mbgl/text/glyph_atlas.hpp> #include <mbgl/text/glyph_pbf.hpp> -#include <mbgl/storage/default_file_source.hpp> -#include <mbgl/util/run_loop.hpp> -#include <mbgl/util/string.hpp> - -#include <future> +#include <mbgl/util/io.hpp> using namespace mbgl; -using namespace std::string_literals; - -class MockGlyphAtlasObserver : public GlyphAtlasObserver { -public: - std::function<void(const FontStack&, const GlyphRange&)> glyphsLoaded; - std::function<void(const FontStack&, const GlyphRange&, std::exception_ptr)> glyphsError; - - void onGlyphsLoaded(const FontStack& fontStack, const GlyphRange& glyphRange) override { - if (glyphsLoaded) { - glyphsLoaded(fontStack, glyphRange); - } - } - void onGlyphsError(const FontStack& fontStack, const GlyphRange& glyphRange, std::exception_ptr error) override { - if (glyphsError) { - glyphsError(fontStack, glyphRange, error); - } - } -}; - TEST(GlyphPBF, Parsing) { - util::RunLoop loop; - DefaultFileSource fileSource{ ":memory:", "." }; - GlyphAtlas glyphAtlas{ { 1024, 1024 }, fileSource }; - FontStack fontStack{ "fake_glyphs" }; - GlyphRange glyphRange{ 0, 255 }; - - glyphAtlas.setURL("asset://test/fixtures/resources/{fontstack}-{range}.pbf"); - - MockGlyphAtlasObserver glyphAtlasObserver; - glyphAtlasObserver.glyphsLoaded = [&](const FontStack&, const GlyphRange&) { - loop.stop(); - - const auto& sdfs = glyphAtlas.getGlyphSet(fontStack)->getSDFs(); - - // The fake glyphs don't contain a glyph that has the ID 0; it only contains glyphs with - // undefined IDs, but the parser should remove them. - - EXPECT_TRUE(sdfs.size() == 1); - EXPECT_TRUE(sdfs.find(69) != sdfs.end()); - auto& sdf = sdfs.at(69); - AlphaImage expected({7, 7}); - expected.fill('x'); - EXPECT_EQ(expected, sdf.bitmap); - EXPECT_EQ(1u, sdf.metrics.width); - EXPECT_EQ(1u, sdf.metrics.height); - EXPECT_EQ(20, sdf.metrics.left); - EXPECT_EQ(2, sdf.metrics.top); - EXPECT_EQ(8u, sdf.metrics.advance); - }; - - glyphAtlasObserver.glyphsError = [&](const FontStack&, const GlyphRange&, std::exception_ptr error) { - loop.stop(); - FAIL() << util::toString(error); - }; - - GlyphPBF pbf(&glyphAtlas, fontStack, glyphRange, &glyphAtlasObserver, fileSource); - - loop.run(); + // The fake glyphs contain a number of invalid glyphs, which should be skipped by the parser. + auto sdfs = parseGlyphPBF(GlyphRange { 0, 255 }, util::read_file("test/fixtures/resources/fake_glyphs-0-255.pbf")); + EXPECT_TRUE(sdfs.size() == 1); + + auto& sdf = sdfs[0]; + EXPECT_EQ(69u, sdf.id); + AlphaImage expected({7, 7}); + expected.fill('x'); + EXPECT_EQ(expected, sdf.bitmap); + EXPECT_EQ(1u, sdf.metrics.width); + EXPECT_EQ(1u, sdf.metrics.height); + EXPECT_EQ(20, sdf.metrics.left); + EXPECT_EQ(2, sdf.metrics.top); + EXPECT_EQ(8u, sdf.metrics.advance); } diff --git a/test/text/quads.test.cpp b/test/text/quads.test.cpp index 42bc0f2048..18fbedc2dd 100644 --- a/test/text/quads.test.cpp +++ b/test/text/quads.test.cpp @@ -23,7 +23,7 @@ TEST(getIconQuads, normal) { Shaping shapedText; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 16.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.anchorPoint.x, 2); ASSERT_EQ(quad.anchorPoint.y, 3); @@ -61,7 +61,7 @@ TEST(getIconQuads, style) { { SymbolLayoutProperties::Evaluated layout; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.anchorPoint.x, 0); ASSERT_EQ(quad.anchorPoint.y, 0); @@ -84,7 +84,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 24.0f; layout.get<IconTextFit>() = IconTextFitType::Width; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 24.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -60); ASSERT_EQ(quad.tl.y, 0); @@ -102,7 +102,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 12.0f; layout.get<IconTextFit>() = IconTextFitType::Width; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -30); ASSERT_EQ(quad.tl.y, -5); @@ -124,7 +124,7 @@ TEST(getIconQuads, style) { layout.get<IconTextFitPadding>()[2] = 5.0f; layout.get<IconTextFitPadding>()[3] = 10.0f; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -40); ASSERT_EQ(quad.tl.y, -10); @@ -142,7 +142,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 24.0f; layout.get<IconTextFit>() = IconTextFitType::Height; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 24.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -30); ASSERT_EQ(quad.tl.y, -10); @@ -160,7 +160,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 12.0f; layout.get<IconTextFit>() = IconTextFitType::Height; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -20); ASSERT_EQ(quad.tl.y, -5); @@ -182,7 +182,7 @@ TEST(getIconQuads, style) { layout.get<IconTextFitPadding>()[2] = 5.0f; layout.get<IconTextFitPadding>()[3] = 10.0f; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -30); ASSERT_EQ(quad.tl.y, -10); @@ -200,7 +200,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 24.0f; layout.get<IconTextFit>() = IconTextFitType::Both; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 24.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -60); ASSERT_EQ(quad.tl.y, -10); @@ -218,7 +218,7 @@ TEST(getIconQuads, style) { layout.get<TextSize>() = 12.0f; layout.get<IconTextFit>() = IconTextFitType::Both; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -30); ASSERT_EQ(quad.tl.y, -5); @@ -240,7 +240,7 @@ TEST(getIconQuads, style) { layout.get<IconTextFitPadding>()[2] = 5.0f; layout.get<IconTextFitPadding>()[3] = 10.0f; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -40); ASSERT_EQ(quad.tl.y, -10); @@ -262,7 +262,7 @@ TEST(getIconQuads, style) { layout.get<IconTextFitPadding>()[2] = 10.0f; layout.get<IconTextFitPadding>()[3] = 15.0f; SymbolQuad quad = - getIconQuad(anchor, shapedIcon, line, layout, SymbolPlacementType::Point, shapedText); + getIconQuad(anchor, shapedIcon, line, layout, 12.0f, SymbolPlacementType::Point, shapedText); ASSERT_EQ(quad.tl.x, -45); ASSERT_EQ(quad.tl.y, -5); diff --git a/test/tile/tile_coordinate.test.cpp b/test/tile/tile_coordinate.test.cpp index 4d58bf8c51..8b1048fe16 100644 --- a/test/tile/tile_coordinate.test.cpp +++ b/test/tile/tile_coordinate.test.cpp @@ -1,6 +1,5 @@ #include <mbgl/test/util.hpp> -#include <mbgl/map/change.hpp> #include <mbgl/map/transform.hpp> #include <mbgl/map/transform_state.hpp> #include <mbgl/tile/tile.hpp> @@ -13,17 +12,35 @@ using namespace mbgl; TEST(TileCoordinate, FromLatLng) { + size_t changeCount = 0; - std::vector<MapChange> changes = { - MapChangeRegionWillChange, - MapChangeRegionDidChange, + struct TransformObserver : public mbgl::MapObserver { + void onCameraWillChange(MapObserver::CameraChangeMode mode) final { + if (mode == MapObserver::CameraChangeMode::Immediate && cameraWillChangeImmediateCallback) { + cameraWillChangeImmediateCallback(); + } + } + + void onCameraDidChange(MapObserver::CameraChangeMode mode) final { + if (mode == MapObserver::CameraChangeMode::Immediate && cameraDidChangeImmediateCallback) { + cameraDidChangeImmediateCallback(); + } + } + + std::function<void()> cameraWillChangeImmediateCallback; + std::function<void()> cameraDidChangeImmediateCallback; }; - auto onMapChange = [&](MapChange change) { - ASSERT_EQ(change, changes[changeCount]); + + TransformObserver observer; + observer.cameraWillChangeImmediateCallback = [&]() { + ASSERT_EQ(changeCount, 0u); ++changeCount; }; + observer.cameraDidChangeImmediateCallback = [&]() { + ASSERT_EQ(changeCount, 1u); + }; - Transform transform(onMapChange); + Transform transform(observer); const double max = util::tileSize; transform.resize({ static_cast<uint32_t>(max), static_cast<uint32_t>(max) }); @@ -47,8 +64,8 @@ TEST(TileCoordinate, FromLatLng) { const double zoom = integerZoom; const double maxTilesPerAxis = std::pow(2.0, zoom); const Point<double> tilePoint = { - latLng.longitude == 0 ? 0.5 : latLng.longitude == -util::LONGITUDE_MAX ? 0 : 1.0, - latLng.latitude == 0 ? 0.5 : latLng.latitude == -util::LATITUDE_MAX ? 1.0 : 0, + latLng.longitude() == 0 ? 0.5 : latLng.longitude() == -util::LONGITUDE_MAX ? 0 : 1.0, + latLng.latitude() == 0 ? 0.5 : latLng.latitude() == -util::LATITUDE_MAX ? 1.0 : 0, }; const auto fromLatLng = TileCoordinate::fromLatLng(zoom, latLng); diff --git a/test/tile/vector_tile.test.cpp b/test/tile/vector_tile.test.cpp index f9bdafa5d2..a388e8937e 100644 --- a/test/tile/vector_tile.test.cpp +++ b/test/tile/vector_tile.test.cpp @@ -61,11 +61,11 @@ TEST(VectorTile, Issue7615) { style::SymbolLayer symbolLayer("symbol", "source"); auto symbolBucket = std::make_shared<SymbolBucket>( - style::SymbolLayoutProperties::Evaluated(), - std::unordered_map< + style::SymbolLayoutProperties::PossiblyEvaluated(), + std::map< std::string, std::pair<style::IconPaintProperties::Evaluated, style::TextPaintProperties::Evaluated>>(), - 0.0f, false, false); + 16.0f, 1.0f, 0.0f, false, false); // Simulate placement of a symbol layer. tile.onPlacement(GeometryTile::PlacementResult { diff --git a/test/util/geo.test.cpp b/test/util/geo.test.cpp index 95e75a0e1b..3f625f21fa 100644 --- a/test/util/geo.test.cpp +++ b/test/util/geo.test.cpp @@ -57,80 +57,80 @@ TEST(LatLngBounds, Empty) { TEST(LatLngBounds, Center) { auto result = LatLngBounds::hull({1, 2}, {3, 4}).center(); - ASSERT_DOUBLE_EQ(2, result.latitude); - ASSERT_DOUBLE_EQ(3, result.longitude); + ASSERT_DOUBLE_EQ(2, result.latitude()); + ASSERT_DOUBLE_EQ(3, result.longitude()); } TEST(LatLngBounds, Southwest) { auto result = LatLngBounds::hull({1, 2}, {3, 4}).southwest(); - ASSERT_DOUBLE_EQ(1, result.latitude); - ASSERT_DOUBLE_EQ(2, result.longitude); + ASSERT_DOUBLE_EQ(1, result.latitude()); + ASSERT_DOUBLE_EQ(2, result.longitude()); } TEST(LatLngBounds, Northeast) { auto result = LatLngBounds::hull({1, 2}, {3, 4}).northeast(); - ASSERT_DOUBLE_EQ(3, result.latitude); - ASSERT_DOUBLE_EQ(4, result.longitude); + ASSERT_DOUBLE_EQ(3, result.latitude()); + ASSERT_DOUBLE_EQ(4, result.longitude()); } TEST(LatLngBounds, Southeast) { auto result = LatLngBounds::hull({1, 2}, {3, 4}).southeast(); - ASSERT_DOUBLE_EQ(1, result.latitude); - ASSERT_DOUBLE_EQ(4, result.longitude); + ASSERT_DOUBLE_EQ(1, result.latitude()); + ASSERT_DOUBLE_EQ(4, result.longitude()); } TEST(LatLngBounds, Northwest) { auto result = LatLngBounds::hull({1, 2}, {3, 4}).northwest(); - ASSERT_DOUBLE_EQ(3, result.latitude); - ASSERT_DOUBLE_EQ(2, result.longitude); + ASSERT_DOUBLE_EQ(3, result.latitude()); + ASSERT_DOUBLE_EQ(2, result.longitude()); } TEST(LatLng, FromTileID) { for (int i = 0; i < 20; i++) { const LatLng ll{ CanonicalTileID(i, 0, 0) }; - ASSERT_DOUBLE_EQ(-util::LONGITUDE_MAX, ll.longitude); - ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude); + ASSERT_DOUBLE_EQ(-util::LONGITUDE_MAX, ll.longitude()); + ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude()); } { const LatLng ll{ UnwrappedTileID(0, 1, 0) }; - ASSERT_DOUBLE_EQ(util::LONGITUDE_MAX, ll.longitude); - ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude); + ASSERT_DOUBLE_EQ(util::LONGITUDE_MAX, ll.longitude()); + ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude()); } { const LatLng ll{ UnwrappedTileID(0, -1, 0) }; - ASSERT_DOUBLE_EQ(-540, ll.longitude); - ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude); + ASSERT_DOUBLE_EQ(-540, ll.longitude()); + ASSERT_DOUBLE_EQ(util::LATITUDE_MAX, ll.latitude()); } } TEST(LatLng, Boundaries) { LatLng coordinate; - ASSERT_DOUBLE_EQ(0, coordinate.latitude); - ASSERT_DOUBLE_EQ(0, coordinate.longitude); + ASSERT_DOUBLE_EQ(0, coordinate.latitude()); + ASSERT_DOUBLE_EQ(0, coordinate.longitude()); - coordinate.longitude = -180.1; - ASSERT_DOUBLE_EQ(-180.1, coordinate.longitude); + coordinate = LatLng(0, -180.1); + ASSERT_DOUBLE_EQ(-180.1, coordinate.longitude()); coordinate.wrap(); - ASSERT_DOUBLE_EQ(179.90000000000001, coordinate.longitude); // 1E-14 + ASSERT_DOUBLE_EQ(179.90000000000001, coordinate.longitude()); // 1E-14 - coordinate.longitude = 180.9; + coordinate = LatLng(0, 180.9); coordinate.wrap(); - ASSERT_DOUBLE_EQ(-179.09999999999999, coordinate.longitude); + ASSERT_DOUBLE_EQ(-179.09999999999999, coordinate.longitude()); - coordinate.longitude = -360.5; + coordinate = LatLng(0, -360.5); coordinate.wrap(); - ASSERT_DOUBLE_EQ(-0.5, coordinate.longitude); + ASSERT_DOUBLE_EQ(-0.5, coordinate.longitude()); - coordinate.longitude = 360.5; + coordinate = LatLng(0, 360.5); coordinate.wrap(); - ASSERT_DOUBLE_EQ(0.5, coordinate.longitude); + ASSERT_DOUBLE_EQ(0.5, coordinate.longitude()); - coordinate.longitude = 360000.5; + coordinate = LatLng(0, 360000.5); coordinate.wrap(); - ASSERT_DOUBLE_EQ(0.5, coordinate.longitude); + ASSERT_DOUBLE_EQ(0.5, coordinate.longitude()); } TEST(LatLngBounds, FromTileID) { diff --git a/test/util/memory.test.cpp b/test/util/memory.test.cpp index 79a3c43dbd..065d024bef 100644 --- a/test/util/memory.test.cpp +++ b/test/util/memory.test.cpp @@ -3,6 +3,7 @@ #include <mbgl/test/util.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> @@ -35,6 +36,7 @@ public: util::RunLoop runLoop; HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope { backend }; OffscreenView view{ backend.getContext(), { 512, 512 } }; StubFileSource fileSource; ThreadPool threadPool { 4 }; diff --git a/test/util/projection.test.cpp b/test/util/projection.test.cpp index 5efba380b3..b0fa0bd060 100644 --- a/test/util/projection.test.cpp +++ b/test/util/projection.test.cpp @@ -36,33 +36,28 @@ TEST(Projection, MetersPerPixelAtLatitude) { } TEST(Projection, ProjectedMeters) { - const auto southWest = LatLng { -util::LATITUDE_MAX, -util::LONGITUDE_MAX }; - const auto northEast = LatLng { util::LATITUDE_MAX, util::LONGITUDE_MAX }; - auto latLng = LatLng {}; auto projectedMeters = Projection::projectedMetersForLatLng(latLng); EXPECT_EQ(projectedMeters.northing, projectedMeters.easting); EXPECT_EQ(latLng, Projection::latLngForProjectedMeters(projectedMeters)); - latLng = LatLng { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest() }; - projectedMeters = Projection::projectedMetersForLatLng(latLng); - EXPECT_EQ(projectedMeters, Projection::projectedMetersForLatLng(southWest)); + const auto southWest = LatLng { -util::LATITUDE_MAX, -util::LONGITUDE_MAX }; + projectedMeters = Projection::projectedMetersForLatLng(southWest); EXPECT_DOUBLE_EQ(projectedMeters.northing, -20037508.342789274); EXPECT_DOUBLE_EQ(projectedMeters.easting, -20037508.342789244); - latLng = LatLng { std::numeric_limits<double>::max(), std::numeric_limits<double>::max() }; - projectedMeters = Projection::projectedMetersForLatLng(latLng); - EXPECT_EQ(projectedMeters, Projection::projectedMetersForLatLng(northEast)); - EXPECT_DOUBLE_EQ(projectedMeters.northing, -Projection::projectedMetersForLatLng(southWest).northing); - EXPECT_DOUBLE_EQ(projectedMeters.easting, -Projection::projectedMetersForLatLng(southWest).easting); + const auto northEast = LatLng { util::LATITUDE_MAX, util::LONGITUDE_MAX }; + projectedMeters = Projection::projectedMetersForLatLng(northEast); + EXPECT_DOUBLE_EQ(projectedMeters.northing, 20037508.342789274); + EXPECT_DOUBLE_EQ(projectedMeters.easting, 20037508.342789244); projectedMeters = ProjectedMeters { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest() }; latLng = Projection::latLngForProjectedMeters(projectedMeters); - EXPECT_EQ(latLng.latitude, -util::LATITUDE_MAX); - EXPECT_EQ(latLng.longitude, -util::LONGITUDE_MAX); + EXPECT_EQ(latLng.latitude(), -util::LATITUDE_MAX); + EXPECT_EQ(latLng.longitude(), -util::LONGITUDE_MAX); projectedMeters = ProjectedMeters { std::numeric_limits<double>::max(), std::numeric_limits<double>::max() }; latLng = Projection::latLngForProjectedMeters(projectedMeters); - EXPECT_EQ(latLng.latitude, util::LATITUDE_MAX); - EXPECT_EQ(latLng.longitude, util::LONGITUDE_MAX); + EXPECT_EQ(latLng.latitude(), util::LATITUDE_MAX); + EXPECT_EQ(latLng.longitude(), util::LONGITUDE_MAX); } diff --git a/test/util/url.test.cpp b/test/util/url.test.cpp index ca24a5949a..55d8af2811 100644 --- a/test/util/url.test.cpp +++ b/test/util/url.test.cpp @@ -6,24 +6,6 @@ using namespace mbgl::util; -TEST(URL, isURL) { - EXPECT_TRUE(isURL("mapbox://foo")); - EXPECT_TRUE(isURL("mapbox://")); - EXPECT_TRUE(isURL("mapbox-test-scheme://foo")); - EXPECT_TRUE(isURL("mapbox+style://foo")); - EXPECT_TRUE(isURL("mapbox-2.0://foo")); - EXPECT_TRUE(isURL("mapbox99://foo")); - - EXPECT_FALSE(isURL("mapbox:/")); - EXPECT_FALSE(isURL(" mapbox://")); - EXPECT_FALSE(isURL("://")); - EXPECT_FALSE(isURL("mapbox")); - EXPECT_FALSE(isURL("mapbox:foo")); - EXPECT_FALSE(isURL("mapbox:/foo")); - EXPECT_FALSE(isURL("test/mapbox://foo")); - EXPECT_FALSE(isURL("123://foo")); -} - TEST(URL, Scheme) { EXPECT_EQ(URL::Segment({ 0, 4 }), URL("http://example.com/test?query=foo").scheme); EXPECT_EQ(URL::Segment({ 0, 4 }), URL("http://127.0.0.1:8080/test?query=foo").scheme); |