[core] fix pedantic warning messages

3 files changed, 63 insertions, 63 deletions

diff --git a/test/storage/headers.cpp b/test/storage/headers.cpp
index b879c43b12..b7dcfc025d 100644
--- a/test/storage/headers.cpp
+++ b/test/storage/headers.cpp
@@ -12,12 +12,12 @@ TEST(HTTPHeader, Parsing) {
 
     cc = http::CacheControl::parse(R"#(max-age =34)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(34, *cc.maxAge);
+    EXPECT_EQ(34u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(,max-age=1)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(1, *cc.maxAge);
+    EXPECT_EQ(1u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(max-age=-1)#");
@@ -30,12 +30,12 @@ TEST(HTTPHeader, Parsing) {
 
     cc = http::CacheControl::parse(R"#(max-age="34,max-age="22,max-age=28)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(28, *cc.maxAge);
+    EXPECT_EQ(28u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(max-age=3,max-age="34)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(3, *cc.maxAge);
+    EXPECT_EQ(3u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(max-age="\",max-age=4,")#");
@@ -44,26 +44,26 @@ TEST(HTTPHeader, Parsing) {
 
     cc = http::CacheControl::parse(R"#(private, max-age=0, no-cache)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(0, *cc.maxAge);
+    EXPECT_EQ(0u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(max-age=0, no-cache, no-store)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(0, *cc.maxAge);
+    EXPECT_EQ(0u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(,   private   , max-bar=3 , no-cache,  "\,",,foo=",",,max-age=32)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(32, *cc.maxAge);
+    EXPECT_EQ(32u, *cc.maxAge);
     EXPECT_FALSE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(max-age=3600, must-revalidate)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(3600, *cc.maxAge);
+    EXPECT_EQ(3600u, *cc.maxAge);
     EXPECT_TRUE(cc.mustRevalidate);
 
     cc = http::CacheControl::parse(R"#(no-cache="Expires,Via",max-age=3600, must-revalidate)#");
     ASSERT_TRUE(bool(cc.maxAge));
-    EXPECT_EQ(3600, *cc.maxAge);
+    EXPECT_EQ(3600u, *cc.maxAge);
     EXPECT_TRUE(cc.mustRevalidate);
 }
diff --git a/test/storage/offline_database.cpp b/test/storage/offline_database.cpp
index 0f95e927de..327dd924b2 100644
--- a/test/storage/offline_database.cpp
+++ b/test/storage/offline_database.cpp
@@ -113,7 +113,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(SchemaVersion)) {
 
     auto observer = Log::removeObserver();
     auto flo = dynamic_cast<FixtureLogObserver*>(observer.get());
-    EXPECT_EQ(1ul, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" }));
+    EXPECT_EQ(1u, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" }));
 }
 
 TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Invalid)) {
@@ -129,7 +129,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Invalid)) {
 
     auto observer = Log::removeObserver();
     auto flo = dynamic_cast<FixtureLogObserver*>(observer.get());
-    EXPECT_EQ(1ul, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" }));
+    EXPECT_EQ(1u, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" }));
 }
 
 TEST(OfflineDatabase, PutDoesNotStoreConnectionErrors) {
@@ -169,7 +169,7 @@ TEST(OfflineDatabase, PutResource) {
     response.data = std::make_shared<std::string>("first");
     auto insertPutResult = db.put(resource, response);
     EXPECT_TRUE(insertPutResult.first);
-    EXPECT_EQ(5, insertPutResult.second);
+    EXPECT_EQ(5u, insertPutResult.second);
 
     auto insertGetResult = db.get(resource);
     EXPECT_EQ(nullptr, insertGetResult->error.get());
@@ -178,7 +178,7 @@ TEST(OfflineDatabase, PutResource) {
     response.data = std::make_shared<std::string>("second");
     auto updatePutResult = db.put(resource, response);
     EXPECT_FALSE(updatePutResult.first);
-    EXPECT_EQ(6, updatePutResult.second);
+    EXPECT_EQ(6u, updatePutResult.second);
 
     auto updateGetResult = db.get(resource);
     EXPECT_EQ(nullptr, updateGetResult->error.get());
@@ -203,7 +203,7 @@ TEST(OfflineDatabase, PutTile) {
     response.data = std::make_shared<std::string>("first");
     auto insertPutResult = db.put(resource, response);
     EXPECT_TRUE(insertPutResult.first);
-    EXPECT_EQ(5, insertPutResult.second);
+    EXPECT_EQ(5u, insertPutResult.second);
 
     auto insertGetResult = db.get(resource);
     EXPECT_EQ(nullptr, insertGetResult->error.get());
@@ -212,7 +212,7 @@ TEST(OfflineDatabase, PutTile) {
     response.data = std::make_shared<std::string>("second");
     auto updatePutResult = db.put(resource, response);
     EXPECT_FALSE(updatePutResult.first);
-    EXPECT_EQ(6, updatePutResult.second);
+    EXPECT_EQ(6u, updatePutResult.second);
 
     auto updateGetResult = db.get(resource);
     EXPECT_EQ(nullptr, updateGetResult->error.get());
@@ -284,7 +284,7 @@ TEST(OfflineDatabase, ListRegions) {
     OfflineRegion region = db.createRegion(definition, metadata);
     std::vector<OfflineRegion> regions = db.listRegions();
 
-    ASSERT_EQ(1, regions.size());
+    ASSERT_EQ(1u, regions.size());
     EXPECT_EQ(region.getID(), regions.at(0).getID());
     EXPECT_EQ(definition.styleURL, regions.at(0).getDefinition().styleURL);
     EXPECT_EQ(definition.bounds, regions.at(0).getDefinition().bounds);
@@ -327,7 +327,7 @@ TEST(OfflineDatabase, DeleteRegion) {
 
     db.deleteRegion(std::move(region));
 
-    ASSERT_EQ(0, db.listRegions().size());
+    ASSERT_EQ(0u, db.listRegions().size());
 }
 
 TEST(OfflineDatabase, CreateRegionInfiniteMaxZoom) {
@@ -391,15 +391,15 @@ TEST(OfflineDatabase, PutReturnsSize) {
 
     Response compressible;
     compressible.data = std::make_shared<std::string>(1024, 0);
-    EXPECT_EQ(17, db.put(Resource::style("http://example.com/compressible"), compressible).second);
+    EXPECT_EQ(17u, db.put(Resource::style("http://example.com/compressible"), compressible).second);
 
     Response incompressible;
     incompressible.data = randomString(1024);
-    EXPECT_EQ(1024, db.put(Resource::style("http://example.com/incompressible"), incompressible).second);
+    EXPECT_EQ(1024u, db.put(Resource::style("http://example.com/incompressible"), incompressible).second);
 
     Response noContent;
     noContent.noContent = true;
-    EXPECT_EQ(0, db.put(Resource::style("http://example.com/noContent"), noContent).second);
+    EXPECT_EQ(0u, db.put(Resource::style("http://example.com/noContent"), noContent).second);
 }
 
 TEST(OfflineDatabase, PutEvictsLeastRecentlyUsedResources) {
@@ -458,10 +458,10 @@ TEST(OfflineDatabase, GetRegionCompletedStatus) {
     OfflineRegion region = db.createRegion(definition, metadata);
 
     OfflineRegionStatus status1 = db.getRegionCompletedStatus(region.getID());
-    EXPECT_EQ(0, status1.completedResourceCount);
-    EXPECT_EQ(0, status1.completedResourceSize);
-    EXPECT_EQ(0, status1.completedTileCount);
-    EXPECT_EQ(0, status1.completedTileSize);
+    EXPECT_EQ(0u, status1.completedResourceCount);
+    EXPECT_EQ(0u, status1.completedResourceSize);
+    EXPECT_EQ(0u, status1.completedTileCount);
+    EXPECT_EQ(0u, status1.completedTileSize);
 
     Response response;
     response.data = std::make_shared<std::string>("data");
@@ -469,17 +469,17 @@ TEST(OfflineDatabase, GetRegionCompletedStatus) {
     uint64_t styleSize = db.putRegionResource(region.getID(), Resource::style("http://example.com/"), response);
 
     OfflineRegionStatus status2 = db.getRegionCompletedStatus(region.getID());
-    EXPECT_EQ(1, status2.completedResourceCount);
+    EXPECT_EQ(1u, status2.completedResourceCount);
     EXPECT_EQ(styleSize, status2.completedResourceSize);
-    EXPECT_EQ(0, status2.completedTileCount);
-    EXPECT_EQ(0, status2.completedTileSize);
+    EXPECT_EQ(0u, status2.completedTileCount);
+    EXPECT_EQ(0u, status2.completedTileSize);
 
     uint64_t tileSize = db.putRegionResource(region.getID(), Resource::tile("http://example.com/", 1.0, 0, 0, 0), response);
 
     OfflineRegionStatus status3 = db.getRegionCompletedStatus(region.getID());
-    EXPECT_EQ(2, status3.completedResourceCount);
+    EXPECT_EQ(2u, status3.completedResourceCount);
     EXPECT_EQ(styleSize + tileSize, status3.completedResourceSize);
-    EXPECT_EQ(1, status3.completedTileCount);
+    EXPECT_EQ(1u, status3.completedTileCount);
     EXPECT_EQ(tileSize, status3.completedTileSize);
 }
 
@@ -501,43 +501,43 @@ TEST(OfflineDatabase, OfflineMapboxTileCount) {
     response.data = std::make_shared<std::string>("data");
 
     // Count is initially zero.
-    EXPECT_EQ(0, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(0u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after putting a non-tile resource.
     db.putRegionResource(region1.getID(), Resource::style("http://example.com/"), response);
-    EXPECT_EQ(0, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(0u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after putting a non-Mapbox tile.
     db.putRegionResource(region1.getID(), nonMapboxTile, response);
-    EXPECT_EQ(0, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(0u, db.getOfflineMapboxTileCount());
 
     // Count increases after putting a Mapbox tile not used by another region.
     db.putRegionResource(region1.getID(), mapboxTile1, response);
-    EXPECT_EQ(1, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(1u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after putting a Mapbox tile used by another region.
     db.putRegionResource(region2.getID(), mapboxTile1, response);
-    EXPECT_EQ(1, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(1u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after putting a Mapbox tile used by the same region.
     db.putRegionResource(region2.getID(), mapboxTile1, response);
-    EXPECT_EQ(1, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(1u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after deleting a region when the tile is still used by another region.
     db.deleteRegion(std::move(region2));
-    EXPECT_EQ(1, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(1u, db.getOfflineMapboxTileCount());
 
     // Count stays the same after the putting a non-offline Mapbox tile.
     db.put(mapboxTile2, response);
-    EXPECT_EQ(1, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(1u, db.getOfflineMapboxTileCount());
 
     // Count increases after putting a pre-existing, but non-offline Mapbox tile.
     db.putRegionResource(region1.getID(), mapboxTile2, response);
-    EXPECT_EQ(2, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(2u, db.getOfflineMapboxTileCount());
 
     // Count decreases after deleting a region when the tiles are not used by other regions.
     db.deleteRegion(std::move(region1));
-    EXPECT_EQ(0, db.getOfflineMapboxTileCount());
+    EXPECT_EQ(0u, db.getOfflineMapboxTileCount());
 }
 
 static int databasePageCount(const std::string& path) {
diff --git a/test/storage/offline_download.cpp b/test/storage/offline_download.cpp
index 7ac9b94e81..07218edaff 100644
--- a/test/storage/offline_download.cpp
+++ b/test/storage/offline_download.cpp
@@ -77,12 +77,12 @@ TEST(OfflineDownload, NoSubresources) {
             if (!expectsInactiveStatus) {
                 expectsInactiveStatus = true;
                 EXPECT_EQ(OfflineRegionDownloadState::Active, status.downloadState);
-                EXPECT_EQ(1, status.completedResourceCount);
+                EXPECT_EQ(1u, status.completedResourceCount);
                 EXPECT_EQ(test.size, status.completedResourceSize);
                 EXPECT_TRUE(status.requiredResourceCountIsPrecise);
             } else {
                 EXPECT_EQ(OfflineRegionDownloadState::Inactive, status.downloadState);
-                EXPECT_EQ(1, status.completedResourceCount);
+                EXPECT_EQ(1u, status.completedResourceCount);
                 EXPECT_EQ(test.size, status.completedResourceSize);
                 EXPECT_TRUE(status.requiredResourceCountIsPrecise);
                 test.loop.stop();
@@ -123,7 +123,7 @@ TEST(OfflineDownload, InlineSource) {
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (status.complete()) {
-            EXPECT_EQ(2, status.completedResourceCount);
+            EXPECT_EQ(2u, status.completedResourceCount);
             EXPECT_EQ(test.size, status.completedResourceSize);
             EXPECT_TRUE(status.requiredResourceCountIsPrecise);
             test.loop.stop();
@@ -158,7 +158,7 @@ TEST(OfflineDownload, GeoJSONSource) {
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (status.complete()) {
-            EXPECT_EQ(2, status.completedResourceCount);
+            EXPECT_EQ(2u, status.completedResourceCount);
             EXPECT_EQ(test.size, status.completedResourceSize);
             EXPECT_TRUE(status.requiredResourceCountIsPrecise);
             test.loop.stop();
@@ -217,7 +217,7 @@ TEST(OfflineDownload, Activate) {
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (status.complete()) {
-            EXPECT_EQ(261, status.completedResourceCount); // 256 glyphs, 1 tile, 1 style, source, sprite image, and sprite json
+            EXPECT_EQ(261u, status.completedResourceCount); // 256 glyphs, 1 tile, 1 style, source, sprite image, and sprite json
             EXPECT_EQ(test.size, status.completedResourceSize);
 
             download.setState(OfflineRegionDownloadState::Inactive);
@@ -248,9 +248,9 @@ TEST(OfflineDownload, GetStatusNoResources) {
     OfflineRegionStatus status = download.getStatus();
 
     EXPECT_EQ(OfflineRegionDownloadState::Inactive, status.downloadState);
-    EXPECT_EQ(0, status.completedResourceCount);
-    EXPECT_EQ(0, status.completedResourceSize);
-    EXPECT_EQ(1, status.requiredResourceCount);
+    EXPECT_EQ(0u, status.completedResourceCount);
+    EXPECT_EQ(0u, status.completedResourceSize);
+    EXPECT_EQ(1u, status.requiredResourceCount);
     EXPECT_FALSE(status.requiredResourceCountIsPrecise);
     EXPECT_FALSE(status.complete());
 }
@@ -270,9 +270,9 @@ TEST(OfflineDownload, GetStatusStyleComplete) {
     OfflineRegionStatus status = download.getStatus();
 
     EXPECT_EQ(OfflineRegionDownloadState::Inactive, status.downloadState);
-    EXPECT_EQ(1, status.completedResourceCount);
+    EXPECT_EQ(1u, status.completedResourceCount);
     EXPECT_EQ(test.size, status.completedResourceSize);
-    EXPECT_EQ(260, status.requiredResourceCount);
+    EXPECT_EQ(260u, status.requiredResourceCount);
     EXPECT_FALSE(status.requiredResourceCountIsPrecise);
     EXPECT_FALSE(status.complete());
 }
@@ -296,9 +296,9 @@ TEST(OfflineDownload, GetStatusStyleAndSourceComplete) {
     OfflineRegionStatus status = download.getStatus();
 
     EXPECT_EQ(OfflineRegionDownloadState::Inactive, status.downloadState);
-    EXPECT_EQ(2, status.completedResourceCount);
+    EXPECT_EQ(2u, status.completedResourceCount);
     EXPECT_EQ(test.size, status.completedResourceSize);
-    EXPECT_EQ(261, status.requiredResourceCount);
+    EXPECT_EQ(261u, status.requiredResourceCount);
     EXPECT_TRUE(status.requiredResourceCountIsPrecise);
     EXPECT_FALSE(status.complete());
 }
@@ -353,7 +353,7 @@ TEST(OfflineDownload, RequestErrorsAreRetried) {
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (status.complete()) {
-            EXPECT_EQ(1, status.completedResourceCount);
+            EXPECT_EQ(1u, status.completedResourceCount);
             test.loop.stop();
         }
     };
@@ -391,7 +391,7 @@ TEST(OfflineDownload, TileCountLimitExceededNoTileResponse) {
     };
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
-        if (!mapboxTileCountLimitExceededCalled) {            
+        if (!mapboxTileCountLimitExceededCalled) {
             EXPECT_FALSE(status.complete());
             EXPECT_EQ(OfflineRegionDownloadState::Active, status.downloadState);
         } else {
@@ -422,7 +422,7 @@ TEST(OfflineDownload, TileCountLimitExceededWithTileResponse) {
         EXPECT_EQ("http://127.0.0.1:3000/style.json", resource.url);
         return test.response("mapbox_source.style.json");
     };
-    
+
     test.fileSource.tileResponse = [&] (const Resource& resource) {
         const Resource::TileData& tile = *resource.tileData;
         EXPECT_EQ("mapbox://{z}-{x}-{y}.vector.pbf", tile.urlTemplate);
@@ -442,7 +442,7 @@ TEST(OfflineDownload, TileCountLimitExceededWithTileResponse) {
         mapboxTileCountLimitExceededCalled = true;
     };
 
-    observer->statusChangedFn = [&] (OfflineRegionStatus status) {        
+    observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (!mapboxTileCountLimitExceededCalled) {
             EXPECT_EQ(OfflineRegionDownloadState::Active, status.downloadState);
         } else {
@@ -481,7 +481,7 @@ TEST(OfflineDownload, WithPreviouslyExistingTile) {
 
     observer->statusChangedFn = [&] (OfflineRegionStatus status) {
         if (status.complete()) {
-            EXPECT_EQ(2, status.completedResourceCount);
+            EXPECT_EQ(2u, status.completedResourceCount);
             EXPECT_EQ(test.size, status.completedResourceSize);
             EXPECT_TRUE(status.requiredResourceCountIsPrecise);
             test.loop.stop();
@@ -543,22 +543,22 @@ TEST(OfflineDownload, ReactivatePreviouslyCompletedDownload) {
 
     test.loop.run();
 
-    ASSERT_EQ(4, statusesAfterReactivate.size());
+    ASSERT_EQ(4u, statusesAfterReactivate.size());
 
     EXPECT_EQ(OfflineRegionDownloadState::Active, statusesAfterReactivate[0].downloadState);
     EXPECT_FALSE(statusesAfterReactivate[0].requiredResourceCountIsPrecise);
-    EXPECT_EQ(1, statusesAfterReactivate[0].requiredResourceCount);
-    EXPECT_EQ(0, statusesAfterReactivate[0].completedResourceCount);
+    EXPECT_EQ(1u, statusesAfterReactivate[0].requiredResourceCount);
+    EXPECT_EQ(0u, statusesAfterReactivate[0].completedResourceCount);
 
     EXPECT_EQ(OfflineRegionDownloadState::Active, statusesAfterReactivate[1].downloadState);
     EXPECT_TRUE(statusesAfterReactivate[1].requiredResourceCountIsPrecise);
-    EXPECT_EQ(2, statusesAfterReactivate[1].requiredResourceCount);
-    EXPECT_EQ(1, statusesAfterReactivate[1].completedResourceCount);
+    EXPECT_EQ(2u, statusesAfterReactivate[1].requiredResourceCount);
+    EXPECT_EQ(1u, statusesAfterReactivate[1].completedResourceCount);
 
     EXPECT_EQ(OfflineRegionDownloadState::Active, statusesAfterReactivate[2].downloadState);
     EXPECT_TRUE(statusesAfterReactivate[2].requiredResourceCountIsPrecise);
-    EXPECT_EQ(2, statusesAfterReactivate[2].requiredResourceCount);
-    EXPECT_EQ(2, statusesAfterReactivate[2].completedResourceCount);
+    EXPECT_EQ(2u, statusesAfterReactivate[2].requiredResourceCount);
+    EXPECT_EQ(2u, statusesAfterReactivate[2].completedResourceCount);
 }
 
 TEST(OfflineDownload, Deactivate) {