Fix warnings on Windows. (#2692)

For reasons I admit I do not understand, the deprecation
warnings for StaticSingleThreadedExecutor on Windows
happen when we construct a shared_ptr for it in the tests.
If we construct a regular object, then it is fine.  Luckily
this test does not require a shared_ptr, so just make it
a regular object here, which rixes the warning.

While we are in here, make all of the tests camel case to
be consistent.

Signed-off-by: Chris Lalancette <[email protected]>
(cherry picked from commit 3310f9e)

# Conflicts:
#	rclcpp/test/rclcpp/executors/test_executors.cpp

Author: clalancette

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -388,7 +388,7 @@ to_nanoseconds_helper(DurationT duration)
 //   - works nominally (it can execute entities)
 //   - it can execute multiple items at once
 //   - it does not wait for work to be available before returning
-TYPED_TEST(TestExecutors, spin_some)
+TYPED_TEST(TestExecutors, spinSome)
 {
   using ExecutorType = TypeParam;
 
@@ -480,7 +480,15 @@ TYPED_TEST(TestExecutors, spin_some)
 
 // The purpose of this test is to check that the ExecutorT.spin_some() method:
 //   - does not continue executing after max_duration has elapsed
+<<<<<<< HEAD
 TYPED_TEST(TestExecutors, spin_some_max_duration)
+=======
+// TODO(wjwwood): The `StaticSingleThreadedExecutor`
+//   do not properly implement max_duration (it seems), so disable this test
+//   for them in the meantime.
+//   see: https://github.com/ros2/rclcpp/issues/2462
+TYPED_TEST(TestExecutorsStable, spinSomeMaxDuration)
+>>>>>>> 3310f9ea (Fix warnings on Windows. (#2692))
 {
   using ExecutorType = TypeParam;
 
@@ -772,7 +780,7 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
   rclcpp::shutdown(non_default_context);
 }
 
-TYPED_TEST(TestExecutors, release_ownership_entity_after_spinning_cancel)
+TYPED_TEST(TestExecutors, releaseOwnershipEntityAfterSpinningCancel)
 {
   using ExecutorType = TypeParam;
   ExecutorType executor;
@@ -808,19 +816,20 @@ TYPED_TEST(TestExecutors, testRaceDropCallbackGroupFromSecondThread)
   }
 
   // Create an executor
-  auto executor = std::make_shared<ExecutorType>();
-  executor->add_node(this->node);
+  ExecutorType executor;
+  executor.add_node(this->node);
 
   // Start spinning
   auto executor_thread = std::thread(
-    [executor]() {
-      executor->spin();
+    [&executor]() {
+      executor.spin();
     });
 
   // As the problem is a race, we do this multiple times,
   // to raise our chances of hitting the problem
-  for(size_t i = 0; i < 10; i++) {
-    auto cg = this->node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
+  for (size_t i = 0; i < 10; i++) {
+    auto cg = this->node->create_callback_group(
+      rclcpp::CallbackGroupType::MutuallyExclusive);
     auto timer = this->node->create_timer(1s, [] {}, cg);
     // sleep a bit, so that the spin thread can pick up the callback group
     // and add it to the executor
@@ -831,6 +840,6 @@ TYPED_TEST(TestExecutors, testRaceDropCallbackGroupFromSecondThread)
     // If the executor has a race, we will experience a segfault at this point.
   }
 
-  executor->cancel();
+  executor.cancel();
   executor_thread.join();
 }