more tests

test/entt/core/hashed_string.cpp

@@ -1,7 +1,18 @@
+#include <cstddef>
 #include <gtest/gtest.h>
 #include <entt/core/hashed_string.hpp>
 
-constexpr bool check(const char *str) {
+constexpr bool ptr(const char *str) {
+    using hash_type = entt::HashedString::hash_type;
+
+    return (static_cast<hash_type>(entt::HashedString{str}) == entt::HashedString{str}
+            && static_cast<const char *>(entt::HashedString{str}) == str
+            && entt::HashedString{str} == entt::HashedString{str}
+            && !(entt::HashedString{str} != entt::HashedString{str}));
+}
+
+template<std::size_t N>
+constexpr bool ref(const char (&str)[N]) {
     using hash_type = entt::HashedString::hash_type;
 
     return (static_cast<hash_type>(entt::HashedString{str}) == entt::HashedString{str}
@@ -12,7 +23,8 @@ constexpr bool check(const char *str) {
 
 TEST(HashedString, Constexprness) {
     // how would you test a constepxr otherwise?
-    static_assert(check("foobar"), "!");
+    static_assert(ptr("foo"), "!");
+    static_assert(ref("bar"), "!");
     ASSERT_TRUE(true);
 }
 
@@ -29,7 +41,7 @@ TEST(HashedString, Functionalities) {
     ASSERT_EQ(static_cast<const char *>(barHs), bar);
 
     ASSERT_TRUE(fooHs == fooHs);
-    ASSERT_FALSE(fooHs == barHs);
+    ASSERT_TRUE(fooHs != barHs);
 
     entt::HashedString hs{"foobar"};
 

test/entt/entity/registry.cpp

@@ -8,6 +8,8 @@ TEST(DefaultRegistry, Functionalities) {
 
     ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{0});
     ASSERT_NO_THROW(registry.reserve(42));
+    ASSERT_NO_THROW(registry.reserve<int>(8));
+    ASSERT_NO_THROW(registry.reserve<char>(8));
     ASSERT_TRUE(registry.empty());
 
     ASSERT_EQ(registry.capacity(), entt::DefaultRegistry::size_type{0});

test/entt/resource/resource.cpp

@@ -27,6 +27,7 @@ TEST(ResourceCache, Functionalities) {
     ASSERT_FALSE(cache.contains(hs2));
 
     ASSERT_FALSE(cache.load<BrokenLoader>(hs1, 42));
+    ASSERT_FALSE(cache.reload<BrokenLoader>(hs1, 42));
 
     ASSERT_EQ(cache.size(), entt::ResourceCache<Resource>::size_type{});
     ASSERT_TRUE(cache.empty());
@@ -34,6 +35,7 @@ TEST(ResourceCache, Functionalities) {
     ASSERT_FALSE(cache.contains(hs2));
 
     ASSERT_TRUE(cache.load<Loader>(hs1, 42));
+    ASSERT_TRUE(cache.reload<Loader>(hs1, 42));
 
     ASSERT_NE(cache.size(), entt::ResourceCache<Resource>::size_type{});
     ASSERT_FALSE(cache.empty());

test/entt/signal/sigh.cpp

@@ -86,6 +86,21 @@ TEST(SigH, Clear) {
     ASSERT_TRUE(sigh.empty());
 }
 
+TEST(SigH, Swap) {
+    entt::SigH<void(int &)> sigh1;
+    entt::SigH<void(int &)> sigh2;
+
+    sigh1.connect<&S::f>();
+
+    ASSERT_FALSE(sigh1.empty());
+    ASSERT_TRUE(sigh2.empty());
+
+    std::swap(sigh1, sigh2);
+
+    ASSERT_TRUE(sigh1.empty());
+    ASSERT_FALSE(sigh2.empty());
+}
+
 TEST(SigH, Functions) {
     entt::SigH<void(int &)> sigh;
     int v = 0;

test/entt/signal/signal.cpp

@@ -91,6 +91,21 @@ TEST(Signal, Clear) {
     ASSERT_TRUE(signal.empty());
 }
 
+TEST(Signal, Swap) {
+    entt::Signal<void(const int &)> sig1;
+    entt::Signal<void(const int &)> sig2;
+
+    sig1.connect<&S::f>();
+
+    ASSERT_FALSE(sig1.empty());
+    ASSERT_TRUE(sig2.empty());
+
+    std::swap(sig1, sig2);
+
+    ASSERT_TRUE(sig1.empty());
+    ASSERT_FALSE(sig2.empty());
+}
+
 TEST(Signal, Functions) {
     entt::Signal<void(const int &)> signal;
     auto val = S::i + 1;