test: minor changes

test/entt/core/hashed_string.cpp

@@ -6,19 +6,19 @@
 #include <entt/core/hashed_string.hpp>
 
 template<typename>
-struct foobar_t;
+struct expected;
 
 template<>
-struct foobar_t<std::uint32_t> {
+struct expected<std::uint32_t> {
     static constexpr auto value = 0xbf9cf968;
 };
 
 template<>
-struct foobar_t<std::uint64_t> {
+struct expected<std::uint64_t> {
     static constexpr auto value = 0x85944171f73967e8;
 };
 
-inline constexpr auto foobar_v = foobar_t<entt::id_type>::value;
+inline constexpr auto expected_v = expected<entt::id_type>::value;
 
 TEST(BasicHashedString, DeductionGuide) {
     static_assert(std::is_same_v<decltype(entt::basic_hashed_string{"foo"}), entt::hashed_string>);
@@ -47,8 +47,8 @@ TEST(HashedString, Functionalities) {
 
     entt::hashed_string hs{"foobar"};
 
-    ASSERT_EQ(static_cast<hash_type>(hs), foobar_v);
-    ASSERT_EQ(hs.value(), foobar_v);
+    ASSERT_EQ(static_cast<hash_type>(hs), expected_v);
+    ASSERT_EQ(hs.value(), expected_v);
 
     ASSERT_EQ(foo_hs, "foo"_hs);
     ASSERT_NE(bar_hs, "foo"_hs);
@@ -78,13 +78,13 @@ TEST(HashedString, Correctness) {
     const char *foobar = "foobar";
     std::string_view view{"foobar__", 6};
 
-    ASSERT_EQ(entt::hashed_string{foobar}, foobar_v);
-    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), foobar_v);
-    ASSERT_EQ(entt::hashed_string{"foobar"}, foobar_v);
+    ASSERT_EQ(entt::hashed_string{foobar}, expected_v);
+    ASSERT_EQ((entt::hashed_string{view.data(), view.size()}), expected_v);
+    ASSERT_EQ(entt::hashed_string{"foobar"}, expected_v);
 
-    ASSERT_EQ(entt::hashed_string::value(foobar), foobar_v);
-    ASSERT_EQ(entt::hashed_string::value(view.data(), view.size()), foobar_v);
-    ASSERT_EQ(entt::hashed_string::value("foobar"), foobar_v);
+    ASSERT_EQ(entt::hashed_string::value(foobar), expected_v);
+    ASSERT_EQ(entt::hashed_string::value(view.data(), view.size()), expected_v);
+    ASSERT_EQ(entt::hashed_string::value("foobar"), expected_v);
 
     ASSERT_EQ(entt::hashed_string{foobar}.size(), 6u);
     ASSERT_EQ((entt::hashed_string{view.data(), view.size()}).size(), 6u);
@@ -111,16 +111,16 @@ TEST(HashedString, Constexprness) {
     constexpr std::string_view view{"foobar__", 6};
 
     static_assert(entt::hashed_string{"quux"} == "quux"_hs);
-    static_assert(entt::hashed_string{"foobar"} == foobar_v);
+    static_assert(entt::hashed_string{"foobar"} == expected_v);
 
     static_assert(entt::hashed_string::value("quux") == "quux"_hs);
-    static_assert(entt::hashed_string::value("foobar") == foobar_v);
+    static_assert(entt::hashed_string::value("foobar") == expected_v);
 
     static_assert(entt::hashed_string{"quux", 4} == "quux"_hs);
-    static_assert(entt::hashed_string{view.data(), view.size()} == foobar_v);
+    static_assert(entt::hashed_string{view.data(), view.size()} == expected_v);
 
     static_assert(entt::hashed_string::value("quux", 4) == "quux"_hs);
-    static_assert(entt::hashed_string::value(view.data(), view.size()) == foobar_v);
+    static_assert(entt::hashed_string::value(view.data(), view.size()) == expected_v);
 
     static_assert(entt::hashed_string{"bar"} < "foo"_hs);
     static_assert(entt::hashed_string{"bar"} <= "bar"_hs);
@@ -151,8 +151,8 @@ TEST(HashedWString, Functionalities) {
 
     entt::hashed_wstring hws{L"foobar"};
 
-    ASSERT_EQ(static_cast<hash_type>(hws), foobar_v);
-    ASSERT_EQ(hws.value(), foobar_v);
+    ASSERT_EQ(static_cast<hash_type>(hws), expected_v);
+    ASSERT_EQ(hws.value(), expected_v);
 
     ASSERT_EQ(foo_hws, L"foo"_hws);
     ASSERT_NE(bar_hws, L"foo"_hws);
@@ -172,13 +172,13 @@ TEST(HashedWString, Correctness) {
     const wchar_t *foobar = L"foobar";
     std::wstring_view view{L"foobar__", 6};
 
-    ASSERT_EQ(entt::hashed_wstring{foobar}, foobar_v);
-    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), foobar_v);
-    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, foobar_v);
+    ASSERT_EQ(entt::hashed_wstring{foobar}, expected_v);
+    ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}), expected_v);
+    ASSERT_EQ(entt::hashed_wstring{L"foobar"}, expected_v);
 
-    ASSERT_EQ(entt::hashed_wstring::value(foobar), foobar_v);
-    ASSERT_EQ(entt::hashed_wstring::value(view.data(), view.size()), foobar_v);
-    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), foobar_v);
+    ASSERT_EQ(entt::hashed_wstring::value(foobar), expected_v);
+    ASSERT_EQ(entt::hashed_wstring::value(view.data(), view.size()), expected_v);
+    ASSERT_EQ(entt::hashed_wstring::value(L"foobar"), expected_v);
 
     ASSERT_EQ(entt::hashed_wstring{foobar}.size(), 6u);
     ASSERT_EQ((entt::hashed_wstring{view.data(), view.size()}).size(), 6u);
@@ -205,16 +205,16 @@ TEST(HashedWString, Constexprness) {
     constexpr std::wstring_view view{L"foobar__", 6};
 
     static_assert(entt::hashed_wstring{L"quux"} == L"quux"_hws);
-    static_assert(entt::hashed_wstring{L"foobar"} == foobar_v);
+    static_assert(entt::hashed_wstring{L"foobar"} == expected_v);
 
     static_assert(entt::hashed_wstring::value(L"quux") == L"quux"_hws);
-    static_assert(entt::hashed_wstring::value(L"foobar") == foobar_v);
+    static_assert(entt::hashed_wstring::value(L"foobar") == expected_v);
 
     static_assert(entt::hashed_wstring{L"quux", 4} == L"quux"_hws);
-    static_assert(entt::hashed_wstring{view.data(), view.size()} == foobar_v);
+    static_assert(entt::hashed_wstring{view.data(), view.size()} == expected_v);
 
     static_assert(entt::hashed_wstring::value(L"quux", 4) == L"quux"_hws);
-    static_assert(entt::hashed_wstring::value(view.data(), view.size()) == foobar_v);
+    static_assert(entt::hashed_wstring::value(view.data(), view.size()) == expected_v);
 
     static_assert(entt::hashed_wstring{L"bar"} < L"foo"_hws);
     static_assert(entt::hashed_wstring{L"bar"} <= L"bar"_hws);

test/entt/entity/snapshot.cpp

@@ -572,8 +572,8 @@ TEST(Snapshot, SyncDataMembers) {
     ASSERT_EQ(component.bar, loader.map(parent));
     ASSERT_EQ(component.quux[0], loader.map(child));
 
-    const auto &foobar = dst.get<map_component>(loader.map(child));
-    ASSERT_EQ(foobar.keys.at(loader.map(child)), 10);
-    ASSERT_EQ(foobar.values.at(10), loader.map(child));
-    ASSERT_EQ(foobar.both.at(loader.map(child)), loader.map(child));
+    const auto &elem = dst.get<map_component>(loader.map(child));
+    ASSERT_EQ(elem.keys.at(loader.map(child)), 10);
+    ASSERT_EQ(elem.values.at(10), loader.map(child));
+    ASSERT_EQ(elem.both.at(loader.map(child)), loader.map(child));
 }