build: refine signal tests

TODO

@@ -33,4 +33,5 @@ TODO:
 * meta: conversion_helper machinery has lot of room for improvements
 * organizer: view/storage only based model, no registry
 * refine tests: add prefixes (i.e. signal_delegate) or scope into their dirs
+* refine tests: create per-file scopes to avoid conflicts (ie const_nonconst_...)
 * introduce a way to inject stl from outside too

test/CMakeLists.txt

@@ -339,10 +339,14 @@ SETUP_BASIC_TEST(
 
 # Test signal
 
-SETUP_BASIC_TEST_DEPRECATED(delegate entt/signal/delegate.cpp)
-SETUP_BASIC_TEST_DEPRECATED(dispatcher entt/signal/dispatcher.cpp)
-SETUP_BASIC_TEST_DEPRECATED(emitter entt/signal/emitter.cpp)
-SETUP_BASIC_TEST_DEPRECATED(sigh entt/signal/sigh.cpp)
+SETUP_BASIC_TEST(
+    NAME signal
+    SOURCES
+        entt/signal/delegate.cpp
+        entt/signal/dispatcher.cpp
+        entt/signal/emitter.cpp
+        entt/signal/sigh.cpp
+)
 
 # Test stl
 

test/entt/signal/delegate.cpp

@@ -38,7 +38,7 @@ struct delegate_functor {
     const int data_member = 4;
 };
 
-struct const_nonconst_noexcept {
+struct delegate_const_nonconst_noexcept {
     void f() {
         ++cnt;
     }
@@ -239,25 +239,25 @@ TEST(Delegate, Comparison) {
 
 TEST(Delegate, ConstNonConstNoExcept) {
     entt::delegate<void()> delegate;
-    const_nonconst_noexcept functor;
+    delegate_const_nonconst_noexcept functor;
 
-    delegate.connect<&const_nonconst_noexcept::f>(functor);
+    delegate.connect<&delegate_const_nonconst_noexcept::f>(functor);
     delegate();
 
-    delegate.connect<&const_nonconst_noexcept::g>(functor);
+    delegate.connect<&delegate_const_nonconst_noexcept::g>(functor);
     delegate();
 
-    delegate.connect<&const_nonconst_noexcept::h>(functor);
+    delegate.connect<&delegate_const_nonconst_noexcept::h>(functor);
     delegate();
 
-    delegate.connect<&const_nonconst_noexcept::i>(functor);
+    delegate.connect<&delegate_const_nonconst_noexcept::i>(functor);
     delegate();
 
     ASSERT_EQ(functor.cnt, 4);
 }
 
 TEST(Delegate, DeductionGuide) {
-    const_nonconst_noexcept functor;
+    delegate_const_nonconst_noexcept functor;
     int value = 0;
 
     const entt::delegate plain_func{entt::connect_arg<&power_of_two>};
@@ -265,15 +265,15 @@ TEST(Delegate, DeductionGuide) {
     const entt::delegate sum_func_with_const_ref{entt::connect_arg<&sum_with_ref>, std::as_const(value)};
     const entt::delegate sum_func_with_ptr{entt::connect_arg<&sum_with_ptr>, &value};
     const entt::delegate sum_func_with_const_ptr{entt::connect_arg<&sum_with_ptr>, &std::as_const(value)};
-    const entt::delegate member_func_f{entt::connect_arg<&const_nonconst_noexcept::f>, functor};
-    const entt::delegate member_func_g{entt::connect_arg<&const_nonconst_noexcept::g>, functor};
-    const entt::delegate member_func_h{entt::connect_arg<&const_nonconst_noexcept::h>, &functor};
-    const entt::delegate member_func_h_const{entt::connect_arg<&const_nonconst_noexcept::h>, &std::as_const(functor)};
-    const entt::delegate member_func_i{entt::connect_arg<&const_nonconst_noexcept::i>, functor};
-    const entt::delegate member_func_i_const{entt::connect_arg<&const_nonconst_noexcept::i>, std::as_const(functor)};
-    const entt::delegate data_member_u{entt::connect_arg<&const_nonconst_noexcept::u>, functor};
-    const entt::delegate data_member_v{entt::connect_arg<&const_nonconst_noexcept::v>, &functor};
-    const entt::delegate data_member_v_const{entt::connect_arg<&const_nonconst_noexcept::v>, &std::as_const(functor)};
+    const entt::delegate member_func_f{entt::connect_arg<&delegate_const_nonconst_noexcept::f>, functor};
+    const entt::delegate member_func_g{entt::connect_arg<&delegate_const_nonconst_noexcept::g>, functor};
+    const entt::delegate member_func_h{entt::connect_arg<&delegate_const_nonconst_noexcept::h>, &functor};
+    const entt::delegate member_func_h_const{entt::connect_arg<&delegate_const_nonconst_noexcept::h>, &std::as_const(functor)};
+    const entt::delegate member_func_i{entt::connect_arg<&delegate_const_nonconst_noexcept::i>, functor};
+    const entt::delegate member_func_i_const{entt::connect_arg<&delegate_const_nonconst_noexcept::i>, std::as_const(functor)};
+    const entt::delegate data_member_u{entt::connect_arg<&delegate_const_nonconst_noexcept::u>, functor};
+    const entt::delegate data_member_v{entt::connect_arg<&delegate_const_nonconst_noexcept::v>, &functor};
+    const entt::delegate data_member_v_const{entt::connect_arg<&delegate_const_nonconst_noexcept::v>, &std::as_const(functor)};
     const entt::delegate lambda{+[](const void *, int) { return 0; }};
 
     testing::StaticAssertTypeEq<decltype(plain_func)::type, int(const int &)>();

test/entt/signal/sigh.cpp

@@ -27,7 +27,7 @@ struct sigh_listener {
     bool val{false};
 };
 
-struct const_nonconst_noexcept {
+struct sigh_const_nonconst_noexcept {
     void f() {
         ++cnt;
     }
@@ -430,22 +430,22 @@ TEST(SigH, ScopedConnectionConstructorsAndOperators) {
 TEST(SigH, ConstNonConstNoExcept) {
     entt::sigh<void()> sigh;
     entt::sink sink{sigh};
-    const_nonconst_noexcept functor;
-    const const_nonconst_noexcept cfunctor;
+    sigh_const_nonconst_noexcept functor;
+    const sigh_const_nonconst_noexcept cfunctor;
 
-    sink.connect<&const_nonconst_noexcept::f>(functor);
-    sink.connect<&const_nonconst_noexcept::g>(&functor);
-    sink.connect<&const_nonconst_noexcept::h>(cfunctor);
-    sink.connect<&const_nonconst_noexcept::i>(&cfunctor);
+    sink.connect<&sigh_const_nonconst_noexcept::f>(functor);
+    sink.connect<&sigh_const_nonconst_noexcept::g>(&functor);
+    sink.connect<&sigh_const_nonconst_noexcept::h>(cfunctor);
+    sink.connect<&sigh_const_nonconst_noexcept::i>(&cfunctor);
     sigh.publish();
 
     ASSERT_EQ(functor.cnt, 2);
     ASSERT_EQ(cfunctor.cnt, 2);
 
-    sink.disconnect<&const_nonconst_noexcept::f>(functor);
-    sink.disconnect<&const_nonconst_noexcept::g>(&functor);
-    sink.disconnect<&const_nonconst_noexcept::h>(cfunctor);
-    sink.disconnect<&const_nonconst_noexcept::i>(&cfunctor);
+    sink.disconnect<&sigh_const_nonconst_noexcept::f>(functor);
+    sink.disconnect<&sigh_const_nonconst_noexcept::g>(&functor);
+    sink.disconnect<&sigh_const_nonconst_noexcept::h>(cfunctor);
+    sink.disconnect<&sigh_const_nonconst_noexcept::i>(&cfunctor);
     sigh.publish();
 
     ASSERT_EQ(functor.cnt, 2);