test: suppress a few warnings (resource)

test/entt/resource/resource.cpp

@@ -90,12 +90,12 @@ TEST(Resource, ConstNonConstAndAllInBetween) {
     ASSERT_TRUE(copy);
     ASSERT_EQ(copy, resource);
     ASSERT_NE(copy, entt::resource<derived>{});
-    ASSERT_EQ(copy.handle().use_count(), 3u);
+    ASSERT_EQ(copy.handle().use_count(), 3);
 
     ASSERT_TRUE(move);
     ASSERT_EQ(move, resource);
     ASSERT_NE(move, entt::resource<derived>{});
-    ASSERT_EQ(move.handle().use_count(), 3u);
+    ASSERT_EQ(move.handle().use_count(), 3);
 
     copy = resource;
     move = std::move(resource);
@@ -105,7 +105,7 @@ TEST(Resource, ConstNonConstAndAllInBetween) {
 
     ASSERT_TRUE(copy);
     ASSERT_TRUE(move);
-    ASSERT_EQ(copy.handle().use_count(), 2u);
+    ASSERT_EQ(copy.handle().use_count(), 2);
 }
 
 TEST(Resource, DynamicResourceHandleCast) {
@@ -113,20 +113,20 @@ TEST(Resource, DynamicResourceHandleCast) {
     entt::resource<const base> other = resource;
 
     ASSERT_TRUE(other);
-    ASSERT_EQ(resource.handle().use_count(), 2u);
+    ASSERT_EQ(resource.handle().use_count(), 2);
     ASSERT_EQ(resource, other);
 
     entt::resource<const derived> cast = dynamic_resource_cast<const derived>(other);
 
     ASSERT_TRUE(cast);
-    ASSERT_EQ(resource.handle().use_count(), 3u);
+    ASSERT_EQ(resource.handle().use_count(), 3);
     ASSERT_EQ(resource, cast);
 
     other = entt::resource<base>{std::make_shared<base>()};
     cast = dynamic_resource_cast<const derived>(other);
 
     ASSERT_FALSE(cast);
-    ASSERT_EQ(resource.handle().use_count(), 1u);
+    ASSERT_EQ(resource.handle().use_count(), 1);
 }
 
 TEST(Resource, Comparison) {

test/entt/resource/resource_cache.cpp

@@ -322,13 +322,13 @@ TEST(ResourceCache, Erase) {
     entt::resource_cache<std::size_t> cache;
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {
-        cache.load(next, next);
+        cache.load(static_cast<entt::id_type>(next), next);
     }
 
     ASSERT_EQ(cache.size(), resource_count + 1u);
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {
-        ASSERT_TRUE(cache.contains(next));
+        ASSERT_TRUE(cache.contains(static_cast<entt::id_type>(next)));
     }
 
     auto it = cache.erase(++cache.begin());
@@ -346,16 +346,16 @@ TEST(ResourceCache, Erase) {
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {
         if(next == 1u || next == 8u || next == 6u) {
-            ASSERT_FALSE(cache.contains(next));
+            ASSERT_FALSE(cache.contains(static_cast<entt::id_type>(next)));
         } else {
-            ASSERT_TRUE(cache.contains(next));
+            ASSERT_TRUE(cache.contains(static_cast<entt::id_type>(next)));
         }
     }
 
     cache.erase(cache.begin(), cache.end());
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {
-        ASSERT_FALSE(cache.contains(next));
+        ASSERT_FALSE(cache.contains(static_cast<entt::id_type>(next)));
     }
 
     ASSERT_EQ(cache.size(), 0u);