test: local non-static constexpr variables

test/entt/container/dense_map.cpp

@@ -100,7 +100,7 @@ TEST(DenseMap, Functionalities) {
 }
 
 TEST(DenseMap, Constructors) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<int, int> map;
 
     ASSERT_EQ(map.bucket_count(), minimum_bucket_count);
@@ -395,7 +395,7 @@ TEST(DenseMap, Insert) {
 }
 
 TEST(DenseMap, InsertRehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     ASSERT_EQ(map.size(), 0u);
@@ -429,7 +429,7 @@ TEST(DenseMap, InsertRehash) {
 }
 
 TEST(DenseMap, InsertSameBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     for(std::size_t next{}; next < minimum_bucket_count; ++next) {
@@ -598,7 +598,7 @@ TEST(DenseMap, Emplace) {
 }
 
 TEST(DenseMap, EmplaceRehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     ASSERT_EQ(map.size(), 0u);
@@ -633,7 +633,7 @@ TEST(DenseMap, EmplaceRehash) {
 }
 
 TEST(DenseMap, EmplaceSameBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     for(std::size_t next{}; next < minimum_bucket_count; ++next) {
@@ -681,7 +681,7 @@ TEST(DenseMap, TryEmplace) {
 }
 
 TEST(DenseMap, TryEmplaceRehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     ASSERT_EQ(map.size(), 0u);
@@ -715,7 +715,7 @@ TEST(DenseMap, TryEmplaceRehash) {
 }
 
 TEST(DenseMap, TryEmplaceSameBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     for(std::size_t next{}; next < minimum_bucket_count; ++next) {
@@ -749,7 +749,7 @@ TEST(DenseMap, TryEmplaceMovableType) {
 }
 
 TEST(DenseMap, Erase) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     for(std::size_t next{}, last = minimum_bucket_count + 1u; next < last; ++next) {
@@ -799,7 +799,7 @@ TEST(DenseMap, Erase) {
 }
 
 TEST(DenseMap, EraseWithMovableKeyValue) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::string, std::size_t> map;
 
     map.emplace("0", 0u);
@@ -817,7 +817,7 @@ TEST(DenseMap, EraseWithMovableKeyValue) {
 }
 
 TEST(DenseMap, EraseFromBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
 
     ASSERT_EQ(map.bucket_count(), minimum_bucket_count);
@@ -995,7 +995,7 @@ TEST(DenseMap, LocalIterator) {
     static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, std::size_t &>>>);
     static_assert(std::is_same_v<iterator::reference, std::pair<const std::size_t &, std::size_t &>>);
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
     map.emplace(3u, 42u);
     map.emplace(3u + minimum_bucket_count, 99u);
@@ -1023,7 +1023,7 @@ TEST(DenseMap, ConstLocalIterator) {
     static_assert(std::is_same_v<iterator::pointer, entt::input_iterator_pointer<std::pair<const std::size_t &, const std::size_t &>>>);
     static_assert(std::is_same_v<iterator::reference, std::pair<const std::size_t &, const std::size_t &>>);
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
     map.emplace(3u, 42u);
     map.emplace(3u + minimum_bucket_count, 99u);
@@ -1064,7 +1064,7 @@ TEST(DenseMap, LocalIteratorConversion) {
 }
 
 TEST(DenseMap, Rehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, entt::identity> map;
     map[32u] = 99u;
 
@@ -1147,7 +1147,7 @@ TEST(DenseMap, Rehash) {
 }
 
 TEST(DenseMap, Reserve) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<int, int> map;
 
     ASSERT_EQ(map.bucket_count(), minimum_bucket_count);
@@ -1167,7 +1167,7 @@ TEST(DenseMap, ThrowingAllocator) {
     using packed_allocator = test::throwing_allocator<entt::internal::dense_map_node<std::size_t, std::size_t>>;
     using packed_exception = typename packed_allocator::exception_type;
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_map<std::size_t, std::size_t, std::hash<std::size_t>, std::equal_to<std::size_t>, allocator> map{};
 
     packed_allocator::trigger_on_allocate = true;

test/entt/container/dense_set.cpp

@@ -98,7 +98,7 @@ TEST(DenseSet, Functionalities) {
 }
 
 TEST(DenseSet, Constructors) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<int> set;
 
     ASSERT_EQ(set.bucket_count(), minimum_bucket_count);
@@ -357,7 +357,7 @@ TEST(DenseSet, Insert) {
 }
 
 TEST(DenseSet, InsertRehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     ASSERT_EQ(set.size(), 0u);
@@ -388,7 +388,7 @@ TEST(DenseSet, InsertRehash) {
 }
 
 TEST(DenseSet, InsertSameBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     for(std::size_t next{}; next < minimum_bucket_count; ++next) {
@@ -451,7 +451,7 @@ TEST(DenseSet, Emplace) {
 }
 
 TEST(DenseSet, EmplaceRehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     ASSERT_EQ(set.size(), 0u);
@@ -483,7 +483,7 @@ TEST(DenseSet, EmplaceRehash) {
 }
 
 TEST(DenseSet, EmplaceSameBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     for(std::size_t next{}; next < minimum_bucket_count; ++next) {
@@ -503,7 +503,7 @@ TEST(DenseSet, EmplaceSameBucket) {
 }
 
 TEST(DenseSet, Erase) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     for(std::size_t next{}, last = minimum_bucket_count + 1u; next < last; ++next) {
@@ -553,7 +553,7 @@ TEST(DenseSet, Erase) {
 }
 
 TEST(DenseSet, EraseWithMovableKeyValue) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::string> set;
 
     set.emplace("0");
@@ -570,7 +570,7 @@ TEST(DenseSet, EraseWithMovableKeyValue) {
 }
 
 TEST(DenseSet, EraseFromBucket) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
 
     ASSERT_EQ(set.bucket_count(), minimum_bucket_count);
@@ -721,7 +721,7 @@ TEST(DenseSet, LocalIterator) {
     static_assert(std::is_same_v<iterator::pointer, const std::size_t *>);
     static_assert(std::is_same_v<iterator::reference, const std::size_t &>);
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
     set.emplace(3u);
     set.emplace(3u + minimum_bucket_count);
@@ -749,7 +749,7 @@ TEST(DenseSet, ConstLocalIterator) {
     static_assert(std::is_same_v<iterator::pointer, const std::size_t *>);
     static_assert(std::is_same_v<iterator::reference, const std::size_t &>);
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
     set.emplace(3u);
     set.emplace(3u + minimum_bucket_count);
@@ -790,7 +790,7 @@ TEST(DenseSet, LocalIteratorConversion) {
 }
 
 TEST(DenseSet, Rehash) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, entt::identity> set;
     set.emplace(32u);
 
@@ -865,7 +865,7 @@ TEST(DenseSet, Rehash) {
 }
 
 TEST(DenseSet, Reserve) {
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<int> set;
 
     ASSERT_EQ(set.bucket_count(), minimum_bucket_count);
@@ -885,7 +885,7 @@ TEST(DenseSet, ThrowingAllocator) {
     using packed_allocator = test::throwing_allocator<std::pair<std::size_t, std::size_t>>;
     using packed_exception = typename packed_allocator::exception_type;
 
-    static constexpr std::size_t minimum_bucket_count = 8u;
+    constexpr std::size_t minimum_bucket_count = 8u;
     entt::dense_set<std::size_t, std::hash<std::size_t>, std::equal_to<std::size_t>, allocator> set{};
 
     packed_allocator::trigger_on_allocate = true;

test/entt/core/any.cpp

@@ -1411,7 +1411,7 @@ TEST_F(Any, SBOVsZeroedSBOSize) {
 }
 
 TEST_F(Any, SboAlignment) {
-    static constexpr auto alignment = alignof(over_aligned);
+    constexpr auto alignment = alignof(over_aligned);
     entt::basic_any<alignment, alignment> sbo[2] = {over_aligned{}, over_aligned{}};
     const auto *data = sbo[0].data();
 
@@ -1427,7 +1427,7 @@ TEST_F(Any, SboAlignment) {
 }
 
 TEST_F(Any, NoSboAlignment) {
-    static constexpr auto alignment = alignof(over_aligned);
+    constexpr auto alignment = alignof(over_aligned);
     entt::basic_any<alignment> nosbo[2] = {over_aligned{}, over_aligned{}};
     const auto *data = nosbo[0].data();
 

test/entt/entity/storage.cpp

@@ -1678,9 +1678,9 @@ ENTT_DEBUG_TEST(StorageDeathTest, PinnedComponent) {
 }
 
 TEST(Storage, UpdateFromDestructor) {
-    static constexpr auto size = 10u;
-
     auto test = [](const auto target) {
+        constexpr auto size = 10u;
+
         entt::storage<update_from_destructor> pool;
 
         for(std::size_t next{}; next < size; ++next) {
@@ -1703,8 +1703,8 @@ TEST(Storage, UpdateFromDestructor) {
         }
     };
 
-    test(entt::entity(size - 1u));
-    test(entt::entity(size - 2u));
+    test(entt::entity{9u});
+    test(entt::entity{8u});
     test(entt::entity{0u});
 }
 

test/entt/poly/poly.cpp

@@ -385,7 +385,7 @@ TYPED_TEST(Poly, SBOVsZeroedSBOSize) {
 }
 
 TYPED_TEST(Poly, SboAlignment) {
-    static constexpr auto alignment = alignof(over_aligned);
+    constexpr auto alignment = alignof(over_aligned);
     typename TestFixture::template type<alignment, alignment> sbo[2]{over_aligned{}, over_aligned{}};
     const auto *data = sbo[0].data();
 
@@ -401,7 +401,7 @@ TYPED_TEST(Poly, SboAlignment) {
 }
 
 TYPED_TEST(Poly, NoSboAlignment) {
-    static constexpr auto alignment = alignof(over_aligned);
+    constexpr auto alignment = alignof(over_aligned);
     typename TestFixture::template type<alignment> nosbo[2]{over_aligned{}, over_aligned{}};
     const auto *data = nosbo[0].data();
 

test/entt/resource/resource_cache.cpp

@@ -318,7 +318,7 @@ TEST(ResourceCache, Load) {
 }
 
 TEST(ResourceCache, Erase) {
-    static constexpr std::size_t resource_count = 8u;
+    constexpr std::size_t resource_count = 8u;
     entt::resource_cache<std::size_t> cache;
 
     for(std::size_t next{}, last = resource_count + 1u; next < last; ++next) {