Add -Wall to warning level in CI clang compilation (#8)

jparisu · web-flow · commit 180161b839de · 2022-10-10T14:21:46.000+02:00
* Add -Wall and pedantic to warning level in CI clang compilation

Signed-off-by: jparisu &lt;javierparis@eprosima.com&gt;

* Fix -Wall warnings

Signed-off-by: jparisu &lt;javierparis@eprosima.com&gt;

* remove pedantic

Signed-off-by: jparisu &lt;javierparis@eprosima.com&gt;

Signed-off-by: jparisu &lt;javierparis@eprosima.com&gt;
diff --git a/.github/workflows/clang_colcon.meta b/.github/workflows/clang_colcon.meta
@@ -7,7 +7,7 @@
             [
                 "-DCMAKE_BUILD_TYPE=Release",
                 "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
-                "-DCMAKE_CXX_FLAGS='-Werror'"
+                "-DCMAKE_CXX_FLAGS='-Werror -Wall'",
             ]
         }
     }
diff --git a/cpp_utils/include/cpp_utils/macros/custom_enumeration.hpp b/cpp_utils/include/cpp_utils/macros/custom_enumeration.hpp
@@ -84,7 +84,7 @@ namespace utils {
     { os << to_string(e); return os; }         \
                                                                                                   \
     /* Number of elements in enumeration */                                                                           \
-    constexpr const unsigned int N_VALUES_ ## enumeration_name = COUNT_ARGUMENTS(__VA_ARGS__);
+    constexpr const unsigned int N_VALUES_ ## enumeration_name = COUNT_ARGUMENTS(__VA_ARGS__)
 
 
 } /* namespace utils */
diff --git a/cpp_utils/include/cpp_utils/types/Fuzzy.hpp b/cpp_utils/include/cpp_utils/types/Fuzzy.hpp
@@ -190,19 +190,19 @@ class Fuzzy
     /////////////////////////
 
     /**
-     * @brief Fuzzy level of this object.
+     * @brief Internal value of type \c T .
      *
-     * This defines the certainty with which the internal \c value has been set.
-     * By default is set to \c fuzzy_level_default if the internal value has not been set.
+     * By default this value would be initialized with default constructor.
      */
-    FuzzyLevelType fuzzy_level = FuzzyLevelValues::fuzzy_level_default;
+    T value = T();
 
     /**
-     * @brief Internal value of type \c T .
+     * @brief Fuzzy level of this object.
      *
-     * By default this value would be initialized with default constructor.
+     * This defines the certainty with which the internal \c value has been set.
+     * By default is set to \c fuzzy_level_default if the internal value has not been set.
      */
-    T value = T();
+    FuzzyLevelType fuzzy_level = FuzzyLevelValues::fuzzy_level_default;
 };
 
 
diff --git a/cpp_utils/include/cpp_utils/wait/impl/WaitHandler.ipp b/cpp_utils/include/cpp_utils/wait/impl/WaitHandler.ipp
@@ -36,9 +36,9 @@ template <typename T>
 WaitHandler<T>::WaitHandler(
         T init_value,
         bool enabled /* = true */)
-    : enabled_(enabled)
+    : value_(init_value)
+    , enabled_(enabled)
     , threads_waiting_(0)
-    , value_(init_value)
 {
 }
 
diff --git a/cpp_utils/test/unittest/event/periodic_event/PeriodicEventHandlerTest.cpp b/cpp_utils/test/unittest/event/periodic_event/PeriodicEventHandlerTest.cpp
@@ -127,7 +127,7 @@ TEST(PeriodicEventHandlerTest, handler_period)
         // Wait twice for the period time
         handler.wait_for_event(2);
 
-        ASSERT_GE(calls.load(), 2) << calls;
+        ASSERT_GE(calls.load(), 2u) << calls;
     }
 }
 
@@ -143,7 +143,7 @@ TEST(PeriodicEventHandlerTest, handler_period_without_callback)
     std::this_thread::sleep_for(std::chrono::milliseconds(handler_period * 5)); // It should have activated 5 times
 
     // Check it has not been activated
-    ASSERT_EQ(handler.event_count(), 0);
+    ASSERT_EQ(handler.event_count(), 0u);
 }
 
 /**
@@ -165,7 +165,7 @@ TEST(PeriodicEventHandlerTest, limit_cases)
         // Wait 100 events for the period time
         handler.wait_for_event(100);
 
-        ASSERT_GE(handler.event_count(), 100);
+        ASSERT_GE(handler.event_count(), 100u);
     }
 
     // 1ms period and instant close
diff --git a/cpp_utils/test/unittest/event/signal/SignalEventHandlerTest.cpp b/cpp_utils/test/unittest/event/signal/SignalEventHandlerTest.cpp
@@ -84,7 +84,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)
     // N signal handlers of SIGINT
     {
         std::vector<std::unique_ptr<SignalEventHandler<Signal::sigint>>> v;
-        for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
+        for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
         {
             v.push_back(std::make_unique<SignalEventHandler<Signal::sigint>>());
         }
@@ -93,7 +93,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)
     // N signal handlers of SIGTERM
     {
         std::vector<std::unique_ptr<SignalEventHandler<Signal::sigterm>>> v;
-        for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
+        for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
         {
             v.push_back(std::make_unique<SignalEventHandler<Signal::sigterm>>());
         }
@@ -102,7 +102,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)
     // N signal handlers of SIGINT & SIGTERM
     {
         std::vector<std::unique_ptr<IBaseSignalEventHandler>> v;
-        for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
+        for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)
         {
             v.push_back(std::make_unique<SignalEventHandler<Signal::sigint>>());
             v.push_back(std::make_unique<SignalEventHandler<Signal::sigterm>>());
@@ -131,7 +131,7 @@ TEST(SignalEventHandlerTest, receive_signal_trivial)
     handler.wait_for_event();
 
     // Check that signal has been received
-    ASSERT_EQ(1, calls);
+    ASSERT_EQ(calls, 1u);
 }
 
 /**
@@ -168,7 +168,7 @@ TEST(SignalEventHandlerTest, receive_signal)
         handler2.wait_for_event();
 
         // Check that signal has been received
-        ASSERT_EQ(2, calls);
+        ASSERT_EQ(calls, 2u);
     }
 
     // SIGINT double signal
@@ -190,7 +190,7 @@ TEST(SignalEventHandlerTest, receive_signal)
         handler.wait_for_event(2);
 
         // Check that signal has been received
-        ASSERT_EQ(2, calls);
+        ASSERT_EQ(calls, 2u);
     }
 
     // SIGINT receive signal after unset
@@ -211,7 +211,7 @@ TEST(SignalEventHandlerTest, receive_signal)
         handler.wait_for_event();
 
         // Check that signal has been received
-        ASSERT_EQ(1, calls);
+        ASSERT_EQ(calls, 1u);
 
         // Unset callback, so new signal raise is not listened
 
@@ -221,7 +221,7 @@ TEST(SignalEventHandlerTest, receive_signal)
         raise(static_cast<int>(Signal::sigint));
 
         // Check that signal has not been received
-        ASSERT_EQ(1, calls);
+        ASSERT_EQ(calls, 1u);
     }
 
     // SIGINT receive signal just before destroying
@@ -307,7 +307,7 @@ TEST(SignalEventHandlerTest, erase_callback_while_other_handling)
     handler2.wait_for_event();
 
     // Check that signal has been received by both
-    ASSERT_EQ(11, calls);
+    ASSERT_EQ(calls, 11u);
 
     // Unset handler 1 (adds 10)
     handler1.unset_callback();
@@ -319,7 +319,7 @@ TEST(SignalEventHandlerTest, erase_callback_while_other_handling)
     handler2.wait_for_event(2);
 
     // Check that signal has been received by only 2 (that adds 1)
-    ASSERT_EQ(12, calls);
+    ASSERT_EQ(calls, 12u);
 }
 
 int main(
diff --git a/cpp_utils/test/unittest/macros/enumerationBuilderMacrosTest.cpp b/cpp_utils/test/unittest/macros/enumerationBuilderMacrosTest.cpp
@@ -102,7 +102,7 @@ TEST(enumerationBuilderMacrosTest, n_values)
 TEST(enumerationBuilderMacrosTest, from_string)
 {
     // x each element inside
-    for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
+    for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
     {
         test::TestCustomEnum value = test::from_string_TestCustomEnum(test::string_values[i]);
         ASSERT_TRUE(value == test::enum_values[i]);
@@ -121,7 +121,7 @@ TEST(enumerationBuilderMacrosTest, from_string)
 TEST(enumerationBuilderMacrosTest, to_string)
 {
     // x each element inside
-    for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
+    for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
     {
         ASSERT_EQ(test::to_string(test::enum_values[i]), test::string_values[i]);
     }
@@ -136,7 +136,7 @@ TEST(enumerationBuilderMacrosTest, to_string)
 TEST(enumerationBuilderMacrosTest, serializator)
 {
     // x each element inside
-    for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
+    for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)
     {
         std::stringstream ss;
         ss << test::enum_values[i];
diff --git a/cpp_utils/test/unittest/macros/macrosTest.cpp b/cpp_utils/test/unittest/macros/macrosTest.cpp
@@ -47,13 +47,15 @@ TEST(macrosTest, stringify)
             std::string(STRINGIFY(_random_value)),
             std::string("_random_value")
             );
+        static_cast<void>(_random_value);  // This is require to avoid unused-variable warning
 
         // String
         std::string _random_string = "other value";
         ASSERT_EQ(
             std::string(STRINGIFY(_random_string)),
             std::string("_random_string")
             );
+        static_cast<void>(_random_string);  // This is require to avoid unused-variable warning
     }
 }
 
diff --git a/cpp_utils/test/unittest/thread_pool/slot_thread_pool_test.cpp b/cpp_utils/test/unittest/thread_pool/slot_thread_pool_test.cpp
@@ -28,8 +28,9 @@ namespace test {
 eprosima::utils::Duration_ms DEFAULT_TIME_TEST = 200u;
 eprosima::utils::Duration_ms RESIDUAL_TIME_TEST = DEFAULT_TIME_TEST / 2u;
 
-uint32_t N_THREADS_IN_TEST = 10;
-uint32_t N_EXECUTIONS_IN_TEST = 5;
+// NOTE: These values are int and not unsigned int to simplify test code, as it avoids a cast
+constexpr const int N_THREADS_IN_TEST = 10;
+constexpr const int N_EXECUTIONS_IN_TEST = 5;
 
 void test_lambda_increase_waiter(
         eprosima::utils::event::IntWaitHandler& counter,
@@ -73,7 +74,7 @@ TEST(slot_thread_pool_test, pool_one_thread_one_slot)
         );
 
     // Emit task n times
-    for (uint32_t i = 0; i < test::N_EXECUTIONS_IN_TEST; ++i)
+    for (int i = 0; i < test::N_EXECUTIONS_IN_TEST; ++i)
     {
         thread_pool.emit(task_id);
     }
@@ -99,7 +100,7 @@ TEST(slot_thread_pool_test, pool_one_thread_n_slots)
     eprosima::utils::Timer timer;
 
     // Create slot
-    for (uint32_t i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)
+    for (int i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)
     {
         TaskId task_id(i);
         thread_pool.slot(
@@ -113,7 +114,7 @@ TEST(slot_thread_pool_test, pool_one_thread_n_slots)
     }
 
     // Emit every task 1 time
-    for (uint32_t i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)
+    for (int i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)
     {
         thread_pool.emit(TaskId(i));
     }
@@ -150,7 +151,7 @@ TEST(slot_thread_pool_test, pool_n_threads_one_slot)
         );
 
     // Emit task n times
-    for (uint32_t i = 0; i < test::N_EXECUTIONS_IN_TEST* test::N_THREADS_IN_TEST; ++i)
+    for (int i = 0; i < test::N_EXECUTIONS_IN_TEST* test::N_THREADS_IN_TEST; ++i)
     {
         thread_pool.emit(task_id);
     }
diff --git a/cpp_utils/test/unittest/time/PausableTimerTest.cpp b/cpp_utils/test/unittest/time/PausableTimerTest.cpp
@@ -170,7 +170,7 @@ TEST(PausableTimerTest, play_and_pause)
     sleep_for(test::TIME_WAIT_TEST);
 
     // Check time
-    ASSERT_EQ(0, timer.elapsed_ms());
+    ASSERT_EQ(timer.elapsed_ms(), 0u);
 }
 
 int main(
diff --git a/thirdparty/filewatch/FileWatch.hpp b/thirdparty/filewatch/FileWatch.hpp
@@ -521,7 +521,7 @@ class FileWatch
         {
             throw std::system_error(errno, std::system_category());
         }
-        const auto listen_filters = _listen_filters;
+        // const auto listen_filters = _listen_filters;  // Unused variable
 
         _watching_single_file = is_file(path);
 

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`[`
`8`	`8`	`"-DCMAKE_BUILD_TYPE=Release",`
`9`	`9`	`"-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",`
`10`		`- "-DCMAKE_CXX_FLAGS='-Werror'"`
	`10`	`+ "-DCMAKE_CXX_FLAGS='-Werror -Wall'",`
`11`	`11`	`]`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ namespace utils {`
`84`	`84`	`{ os << to_string(e); return os; } \`
`85`	`85`	`\`
`86`	`86`	`/* Number of elements in enumeration */ \`
`87`		`- constexpr const unsigned int N_VALUES_ ## enumeration_name = COUNT_ARGUMENTS(__VA_ARGS__);`
	`87`	`+ constexpr const unsigned int N_VALUES_ ## enumeration_name = COUNT_ARGUMENTS(__VA_ARGS__)`
`88`	`88`
`89`	`89`
`90`	`90`	`} /* namespace utils */`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,9 @@ template <typename T>`
`36`	`36`	`WaitHandler<T>::WaitHandler(`
`37`	`37`	`T init_value,`
`38`	`38`	`bool enabled /* = true */)`
`39`		`- : enabled_(enabled)`
	`39`	`+ : value_(init_value)`
	`40`	`+ , enabled_(enabled)`
`40`	`41`	`, threads_waiting_(0)`
`41`		`- , value_(init_value)`
`42`	`42`	`{`
`43`	`43`	`}`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ TEST(PeriodicEventHandlerTest, handler_period)`
`127`	`127`	`// Wait twice for the period time`
`128`	`128`	`handler.wait_for_event(2);`
`129`	`129`
`130`		`- ASSERT_GE(calls.load(), 2) << calls;`
	`130`	`+ ASSERT_GE(calls.load(), 2u) << calls;`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`@@ -143,7 +143,7 @@ TEST(PeriodicEventHandlerTest, handler_period_without_callback)`
`143`	`143`	`std::this_thread::sleep_for(std::chrono::milliseconds(handler_period * 5)); // It should have activated 5 times`
`144`	`144`
`145`	`145`	`// Check it has not been activated`
`146`		`- ASSERT_EQ(handler.event_count(), 0);`
	`146`	`+ ASSERT_EQ(handler.event_count(), 0u);`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`/**`
`@@ -165,7 +165,7 @@ TEST(PeriodicEventHandlerTest, limit_cases)`
`165`	`165`	`// Wait 100 events for the period time`
`166`	`166`	`handler.wait_for_event(100);`
`167`	`167`
`168`		`- ASSERT_GE(handler.event_count(), 100);`
	`168`	`+ ASSERT_GE(handler.event_count(), 100u);`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`// 1ms period and instant close`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)`
`84`	`84`	`// N signal handlers of SIGINT`
`85`	`85`	`{`
`86`	`86`	`std::vector<std::unique_ptr<SignalEventHandler<Signal::sigint>>> v;`
`87`		`- for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
	`87`	`+ for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
`88`	`88`	`{`
`89`	`89`	`v.push_back(std::make_unique<SignalEventHandler<Signal::sigint>>());`
`90`	`90`	`}`
`@@ -93,7 +93,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)`
`93`	`93`	`// N signal handlers of SIGTERM`
`94`	`94`	`{`
`95`	`95`	`std::vector<std::unique_ptr<SignalEventHandler<Signal::sigterm>>> v;`
`96`		`- for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
	`96`	`+ for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
`97`	`97`	`{`
`98`	`98`	`v.push_back(std::make_unique<SignalEventHandler<Signal::sigterm>>());`
`99`	`99`	`}`
`@@ -102,7 +102,7 @@ TEST(SignalEventHandlerTest, create_several_signal_handlers)`
`102`	`102`	`// N signal handlers of SIGINT & SIGTERM`
`103`	`103`	`{`
`104`	`104`	`std::vector<std::unique_ptr<IBaseSignalEventHandler>> v;`
`105`		`- for (int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
	`105`	`+ for (unsigned int i = 0; i < test::N_DEFAUL_TEST_EXECUTIONS; i++)`
`106`	`106`	`{`
`107`	`107`	`v.push_back(std::make_unique<SignalEventHandler<Signal::sigint>>());`
`108`	`108`	`v.push_back(std::make_unique<SignalEventHandler<Signal::sigterm>>());`
`@@ -131,7 +131,7 @@ TEST(SignalEventHandlerTest, receive_signal_trivial)`
`131`	`131`	`handler.wait_for_event();`
`132`	`132`
`133`	`133`	`// Check that signal has been received`
`134`		`- ASSERT_EQ(1, calls);`
	`134`	`+ ASSERT_EQ(calls, 1u);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`/**`
`@@ -168,7 +168,7 @@ TEST(SignalEventHandlerTest, receive_signal)`
`168`	`168`	`handler2.wait_for_event();`
`169`	`169`
`170`	`170`	`// Check that signal has been received`
`171`		`- ASSERT_EQ(2, calls);`
	`171`	`+ ASSERT_EQ(calls, 2u);`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`// SIGINT double signal`
`@@ -190,7 +190,7 @@ TEST(SignalEventHandlerTest, receive_signal)`
`190`	`190`	`handler.wait_for_event(2);`
`191`	`191`
`192`	`192`	`// Check that signal has been received`
`193`		`- ASSERT_EQ(2, calls);`
	`193`	`+ ASSERT_EQ(calls, 2u);`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`// SIGINT receive signal after unset`
`@@ -211,7 +211,7 @@ TEST(SignalEventHandlerTest, receive_signal)`
`211`	`211`	`handler.wait_for_event();`
`212`	`212`
`213`	`213`	`// Check that signal has been received`
`214`		`- ASSERT_EQ(1, calls);`
	`214`	`+ ASSERT_EQ(calls, 1u);`
`215`	`215`
`216`	`216`	`// Unset callback, so new signal raise is not listened`
`217`	`217`
`@@ -221,7 +221,7 @@ TEST(SignalEventHandlerTest, receive_signal)`
`221`	`221`	`raise(static_cast<int>(Signal::sigint));`
`222`	`222`
`223`	`223`	`// Check that signal has not been received`
`224`		`- ASSERT_EQ(1, calls);`
	`224`	`+ ASSERT_EQ(calls, 1u);`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`// SIGINT receive signal just before destroying`
`@@ -307,7 +307,7 @@ TEST(SignalEventHandlerTest, erase_callback_while_other_handling)`
`307`	`307`	`handler2.wait_for_event();`
`308`	`308`
`309`	`309`	`// Check that signal has been received by both`
`310`		`- ASSERT_EQ(11, calls);`
	`310`	`+ ASSERT_EQ(calls, 11u);`
`311`	`311`
`312`	`312`	`// Unset handler 1 (adds 10)`
`313`	`313`	`handler1.unset_callback();`
`@@ -319,7 +319,7 @@ TEST(SignalEventHandlerTest, erase_callback_while_other_handling)`
`319`	`319`	`handler2.wait_for_event(2);`
`320`	`320`
`321`	`321`	`// Check that signal has been received by only 2 (that adds 1)`
`322`		`- ASSERT_EQ(12, calls);`
	`322`	`+ ASSERT_EQ(calls, 12u);`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`int main(`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ TEST(enumerationBuilderMacrosTest, n_values)`
`102`	`102`	`TEST(enumerationBuilderMacrosTest, from_string)`
`103`	`103`	`{`
`104`	`104`	`// x each element inside`
`105`		`- for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
	`105`	`+ for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
`106`	`106`	`{`
`107`	`107`	`test::TestCustomEnum value = test::from_string_TestCustomEnum(test::string_values[i]);`
`108`	`108`	`ASSERT_TRUE(value == test::enum_values[i]);`
`@@ -121,7 +121,7 @@ TEST(enumerationBuilderMacrosTest, from_string)`
`121`	`121`	`TEST(enumerationBuilderMacrosTest, to_string)`
`122`	`122`	`{`
`123`	`123`	`// x each element inside`
`124`		`- for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
	`124`	`+ for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
`125`	`125`	`{`
`126`	`126`	`ASSERT_EQ(test::to_string(test::enum_values[i]), test::string_values[i]);`
`127`	`127`	`}`
`@@ -136,7 +136,7 @@ TEST(enumerationBuilderMacrosTest, to_string)`
`136`	`136`	`TEST(enumerationBuilderMacrosTest, serializator)`
`137`	`137`	`{`
`138`	`138`	`// x each element inside`
`139`		`- for (int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
	`139`	`+ for (unsigned int i = 0; i < test::N_VALUES_TestCustomEnum; i++)`
`140`	`140`	`{`
`141`	`141`	`std::stringstream ss;`
`142`	`142`	`ss << test::enum_values[i];`
Original file line number	Diff line number	Diff line change
`@@ -47,13 +47,15 @@ TEST(macrosTest, stringify)`
`47`	`47`	`std::string(STRINGIFY(_random_value)),`
`48`	`48`	`std::string("_random_value")`
`49`	`49`	`);`
	`50`	`+ static_cast<void>(_random_value); // This is require to avoid unused-variable warning`
`50`	`51`
`51`	`52`	`// String`
`52`	`53`	`std::string _random_string = "other value";`
`53`	`54`	`ASSERT_EQ(`
`54`	`55`	`std::string(STRINGIFY(_random_string)),`
`55`	`56`	`std::string("_random_string")`
`56`	`57`	`);`
	`58`	`+ static_cast<void>(_random_string); // This is require to avoid unused-variable warning`
`57`	`59`	`}`
`58`	`60`	`}`
`59`	`61`
Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,9 @@ namespace test {`
`28`	`28`	`eprosima::utils::Duration_ms DEFAULT_TIME_TEST = 200u;`
`29`	`29`	`eprosima::utils::Duration_ms RESIDUAL_TIME_TEST = DEFAULT_TIME_TEST / 2u;`
`30`	`30`
`31`		`-uint32_t N_THREADS_IN_TEST = 10;`
`32`		`-uint32_t N_EXECUTIONS_IN_TEST = 5;`
	`31`	`+// NOTE: These values are int and not unsigned int to simplify test code, as it avoids a cast`
	`32`	`+constexpr const int N_THREADS_IN_TEST = 10;`
	`33`	`+constexpr const int N_EXECUTIONS_IN_TEST = 5;`
`33`	`34`
`34`	`35`	`void test_lambda_increase_waiter(`
`35`	`36`	`eprosima::utils::event::IntWaitHandler& counter,`
`@@ -73,7 +74,7 @@ TEST(slot_thread_pool_test, pool_one_thread_one_slot)`
`73`	`74`	`);`
`74`	`75`
`75`	`76`	`// Emit task n times`
`76`		`- for (uint32_t i = 0; i < test::N_EXECUTIONS_IN_TEST; ++i)`
	`77`	`+ for (int i = 0; i < test::N_EXECUTIONS_IN_TEST; ++i)`
`77`	`78`	`{`
`78`	`79`	`thread_pool.emit(task_id);`
`79`	`80`	`}`
`@@ -99,7 +100,7 @@ TEST(slot_thread_pool_test, pool_one_thread_n_slots)`
`99`	`100`	`eprosima::utils::Timer timer;`
`100`	`101`
`101`	`102`	`// Create slot`
`102`		`- for (uint32_t i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)`
	`103`	`+ for (int i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)`
`103`	`104`	`{`
`104`	`105`	`TaskId task_id(i);`
`105`	`106`	`thread_pool.slot(`
`@@ -113,7 +114,7 @@ TEST(slot_thread_pool_test, pool_one_thread_n_slots)`
`113`	`114`	`}`
`114`	`115`
`115`	`116`	`// Emit every task 1 time`
`116`		`- for (uint32_t i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)`
	`117`	`+ for (int i = 1; i <= test::N_EXECUTIONS_IN_TEST; ++i)`
`117`	`118`	`{`
`118`	`119`	`thread_pool.emit(TaskId(i));`
`119`	`120`	`}`
`@@ -150,7 +151,7 @@ TEST(slot_thread_pool_test, pool_n_threads_one_slot)`
`150`	`151`	`);`
`151`	`152`
`152`	`153`	`// Emit task n times`
`153`		`- for (uint32_t i = 0; i < test::N_EXECUTIONS_IN_TEST* test::N_THREADS_IN_TEST; ++i)`
	`154`	`+ for (int i = 0; i < test::N_EXECUTIONS_IN_TEST* test::N_THREADS_IN_TEST; ++i)`
`154`	`155`	`{`
`155`	`156`	`thread_pool.emit(task_id);`
`156`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ TEST(PausableTimerTest, play_and_pause)`
`170`	`170`	`sleep_for(test::TIME_WAIT_TEST);`
`171`	`171`
`172`	`172`	`// Check time`
`173`		`- ASSERT_EQ(0, timer.elapsed_ms());`
	`173`	`+ ASSERT_EQ(timer.elapsed_ms(), 0u);`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`int main(`