test: suppress annoying warnings by gcc

test/entt/core/hashed_string.cpp

@@ -5,17 +5,13 @@
 #include <entt/core/hashed_string.hpp>
 
 struct BasicHashedString: ::testing::Test {
-    static constexpr auto expected() noexcept {
-        if constexpr(std::is_same_v<entt::id_type, std::uint32_t>) {
-            constexpr auto foobar_hash = 0xbf9cf968;
-            return foobar_hash;
-        } else if constexpr(std::is_same_v<entt::id_type, std::uint64_t>) {
-            constexpr auto foobar_hash = 0x85944171f73967e8;
-            return foobar_hash;
-        }
-    }
+    template<typename = entt::id_type>
+    static constexpr auto expected = 0xbf9cf968;
 };
 
+template<>
+constexpr auto BasicHashedString::expected<std::uint64_t> = 0x85944171f73967e8;
+
 using HashedString = BasicHashedString;
 using HashedWString = BasicHashedString;
 
@@ -46,8 +42,8 @@ TEST_F(HashedString, Functionalities) {
 
     const entt::hashed_string hs{"foobar"};
 
-    ASSERT_EQ(static_cast<hash_type>(hs), expected());
-    ASSERT_EQ(hs.value(), expected());
+    ASSERT_EQ(static_cast<hash_type>(hs), expected<>);
+    ASSERT_EQ(hs.value(), expected<>);
 
     ASSERT_EQ(foo_hs, "foo"_hs);
     ASSERT_NE(bar_hs, "foo"_hs);
@@ -77,13 +73,13 @@ TEST_F(HashedString, Correctness) {
     const char *foobar = "foobar";
     const std::string_view view{"foobar__", 6};
 
-    ASSERT_EQ(entt::hashed_string{foobar}, expected());
-    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected());
-    ASSERT_EQ(entt::hashed_string{"foobar"}, expected());
+    ASSERT_EQ(entt::hashed_string{foobar}, expected<>);
+    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected<>);
+    ASSERT_EQ(entt::hashed_string{"foobar"}, expected<>);
 
-    ASSERT_EQ(entt::hashed_string::value(foobar), expected());
-    ASSERT_EQ(entt::hashed_string::value(view.data(), view.size()), expected());
-    ASSERT_EQ(entt::hashed_string::value("foobar"), expected());
+    ASSERT_EQ(entt::hashed_string::value(foobar), expected<>);
+    ASSERT_EQ(entt::hashed_string::value(view.data(), view.size()), expected<>);
+    ASSERT_EQ(entt::hashed_string::value("foobar"), expected<>);
 
     ASSERT_EQ(entt::hashed_string{foobar}.size(), 6u);
     ASSERT_EQ((entt::hashed_string{view.data(), view.size()}).size(), 6u);
@@ -110,16 +106,16 @@ TEST_F(HashedString, Constexprness) {
     constexpr std::string_view view{"foobar__", 6};
 
     ASSERT_EQ(entt::hashed_string{"quux"}, "quux"_hs);
-    ASSERT_EQ(entt::hashed_string{"foobar"}, expected());
+    ASSERT_EQ(entt::hashed_string{"foobar"}, expected<>);
 
     ASSERT_EQ(entt::hashed_string::value("quux"), "quux"_hs);
-    ASSERT_EQ(entt::hashed_string::value("foobar"), expected());
+    ASSERT_EQ(entt::hashed_string::value("foobar"), expected<>);
 
     ASSERT_EQ((entt::hashed_string{"quux", 4}), "quux"_hs);
-    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected());
+    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected<>);
 
     ASSERT_EQ((entt::hashed_string::value("quux", 4)), "quux"_hs);
-    ASSERT_EQ((entt::hashed_string::value(view.data(), view.size())), expected());
+    ASSERT_EQ((entt::hashed_string::value(view.data(), view.size())), expected<>);
 
     ASSERT_LT(entt::hashed_string{"bar"}, "foo"_hs);
     ASSERT_LE(entt::hashed_string{"bar"}, "bar"_hs);
@@ -150,8 +146,8 @@ TEST_F(HashedWString, Functionalities) {
 
     const entt::hashed_wstring hws{L"foobar"};
 
-    ASSERT_EQ(static_cast<hash_type>(hws), expected());
-    ASSERT_EQ(hws.value(), expected());
+    ASSERT_EQ(static_cast<hash_type>(hws), expected<>);
+    ASSERT_EQ(hws.value(), expected<>);
 
     ASSERT_EQ(foo_hws, L"foo"_hws);
     ASSERT_NE(bar_hws, L"foo"_hws);
@@ -171,13 +167,13 @@ TEST_F(HashedWString, Correctness) {
     const wchar_t *foobar = L"foobar";
     const std::wstring_view view{L"foobar__", 6};
 
-    ASSERT_EQ(entt::hashed_wstring{foobar}, expected());
-    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected());
-    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected());
+    ASSERT_EQ(entt::hashed_wstring{foobar}, expected<>);
+    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected<>);
+    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected<>);
 
-    ASSERT_EQ(entt::hashed_wstring::value(foobar), expected());
-    ASSERT_EQ(entt::hashed_wstring::value(view.data(), view.size()), expected());
-    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected());
+    ASSERT_EQ(entt::hashed_wstring::value(foobar), expected<>);
+    ASSERT_EQ(entt::hashed_wstring::value(view.data(), view.size()), expected<>);
+    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected<>);
 
     ASSERT_EQ(entt::hashed_wstring{foobar}.size(), 6u);
     ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}).size(), 6u);
@@ -204,16 +200,16 @@ TEST_F(HashedWString, Constexprness) {
     constexpr std::wstring_view view{L"foobar__", 6};
 
     ASSERT_EQ(entt::hashed_wstring{L"quux"}, L"quux"_hws);
-    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected());
+    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected<>);
 
     ASSERT_EQ(entt::hashed_wstring::value(L"quux"), L"quux"_hws);
-    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected());
+    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected<>);
 
     ASSERT_EQ((entt::hashed_wstring{L"quux", 4}), L"quux"_hws);
-    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected());
+    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected<>);
 
     ASSERT_EQ((entt::hashed_wstring::value(L"quux", 4)), L"quux"_hws);
-    ASSERT_EQ((entt::hashed_wstring::value(view.data(), view.size())), expected());
+    ASSERT_EQ((entt::hashed_wstring::value(view.data(), view.size())), expected<>);
 
     ASSERT_LT(entt::hashed_wstring{L"bar"}, L"foo"_hws);
     ASSERT_LE(entt::hashed_wstring{L"bar"}, L"bar"_hws);