[all] Make LatLng coordinates read-only

5 files changed, 149 insertions, 149 deletions

diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp
index b31b4e6ccb..b732741efd 100644
--- a/test/map/map.test.cpp
+++ b/test/map/map.test.cpp
@@ -65,8 +65,8 @@ 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) {
@@ -86,8 +86,8 @@ TEST(Map, CameraToLatLngBounds) {
     // 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);
+    ASSERT_NEAR(camera.center->latitude(), virtualCamera.center->latitude(), 1e-7);
+    ASSERT_NEAR(camera.center->longitude(), virtualCamera.center->longitude(), 1e-7);
 }
 
 TEST(Map, Offline) {
diff --git a/test/map/transform.test.cpp b/test/map/transform.test.cpp
index b5c92abdcb..40f94e4f7c 100644
--- a/test/map/transform.test.cpp
+++ b/test/map/transform.test.cpp
@@ -8,39 +8,39 @@ 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());
 }
 
@@ -48,23 +48,23 @@ TEST(Transform, InvalidScale) {
 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());
 }
@@ -110,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);
@@ -140,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) {
@@ -169,13 +169,13 @@ 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) {
@@ -187,13 +187,13 @@ TEST(Transform, ConstrainWidthAndHeight) {
 
     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) {
@@ -203,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());
 
@@ -212,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({
@@ -317,10 +317,10 @@ TEST(Transform, 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) {
@@ -329,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) {
@@ -341,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) {
@@ -376,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) {
@@ -403,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 };
@@ -413,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);
     };
 
@@ -440,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);
     };
 
@@ -471,8 +471,8 @@ TEST(Transform, DefaultTransform) {
 
     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);
+        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);
diff --git a/test/tile/tile_coordinate.test.cpp b/test/tile/tile_coordinate.test.cpp
index d1bef85cb5..8b1048fe16 100644
--- a/test/tile/tile_coordinate.test.cpp
+++ b/test/tile/tile_coordinate.test.cpp
@@ -64,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/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/projection.test.cpp b/test/util/projection.test.cpp
index 260d12edfe..b0fa0bd060 100644
--- a/test/util/projection.test.cpp
+++ b/test/util/projection.test.cpp
@@ -53,11 +53,11 @@ TEST(Projection, ProjectedMeters) {
 
     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);
 }