WIP: Reorganize test CMakeLists and add benchmark dir

rclcpp/CHANGELOG.rst

@@ -2,72 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-5.1.0 (2020-11-02)
-------------------
-* Deprecate Duration(rcl_duration_value_t) in favor of static Duration::from_nanoseconds(rcl_duration_value_t) (`#1432 <https://github.com/ros2/rclcpp/issues/1432>`_)
-* Avoid parsing arguments twice in `rclcpp::init_and_remove_ros_arguments` (`#1415 <https://github.com/ros2/rclcpp/issues/1415>`_)
-* Add service and client benchmarks (`#1425 <https://github.com/ros2/rclcpp/issues/1425>`_)
-* Set CMakeLists to only use default rmw for benchmarks (`#1427 <https://github.com/ros2/rclcpp/issues/1427>`_)
-* Update tracetools' QL in rclcpp's QD (`#1428 <https://github.com/ros2/rclcpp/issues/1428>`_)
-* Add missing locking to the rclcpp_action::ServerBase. (`#1421 <https://github.com/ros2/rclcpp/issues/1421>`_)
-* Initial benchmark tests for rclcpp::init/shutdown create/destroy node (`#1411 <https://github.com/ros2/rclcpp/issues/1411>`_)
-* Refactor test CMakeLists in prep for benchmarks (`#1422 <https://github.com/ros2/rclcpp/issues/1422>`_)
-* Add methods in topic and service interface to resolve a name (`#1410 <https://github.com/ros2/rclcpp/issues/1410>`_)
-* Update deprecated gtest macros (`#1370 <https://github.com/ros2/rclcpp/issues/1370>`_)
-* Clear members for StaticExecutorEntitiesCollector to avoid shared_ptr dependency (`#1303 <https://github.com/ros2/rclcpp/issues/1303>`_)
-* Increase test timeouts of slow running tests with rmw_connext_cpp (`#1400 <https://github.com/ros2/rclcpp/issues/1400>`_)
-* Avoid self dependency that not destoryed (`#1301 <https://github.com/ros2/rclcpp/issues/1301>`_)
-* Update maintainers (`#1384 <https://github.com/ros2/rclcpp/issues/1384>`_)
-* Add clock qos to node options (`#1375 <https://github.com/ros2/rclcpp/issues/1375>`_)
-* Fix NodeOptions copy constructor (`#1376 <https://github.com/ros2/rclcpp/issues/1376>`_)
-* Make sure to clean the external client/service handle. (`#1296 <https://github.com/ros2/rclcpp/issues/1296>`_)
-* Increase coverage of WaitSetTemplate (`#1368 <https://github.com/ros2/rclcpp/issues/1368>`_)
-* Increase coverage of guard_condition.cpp to 100% (`#1369 <https://github.com/ros2/rclcpp/issues/1369>`_)
-* Add coverage statement (`#1367 <https://github.com/ros2/rclcpp/issues/1367>`_)
-* Tests for LoanedMessage with mocked loaned message publisher (`#1366 <https://github.com/ros2/rclcpp/issues/1366>`_)
-* Add unit tests for qos and qos_event files (`#1352 <https://github.com/ros2/rclcpp/issues/1352>`_)
-* Finish coverage of publisher API (`#1365 <https://github.com/ros2/rclcpp/issues/1365>`_)
-* Finish API coverage on executors. (`#1364 <https://github.com/ros2/rclcpp/issues/1364>`_)
-* Add test for ParameterService (`#1355 <https://github.com/ros2/rclcpp/issues/1355>`_)
-* Add time API coverage tests (`#1347 <https://github.com/ros2/rclcpp/issues/1347>`_)
-* Add timer coverage tests (`#1363 <https://github.com/ros2/rclcpp/issues/1363>`_)
-* Add in additional tests for parameter_client.cpp coverage.
-* Minor fixes to the parameter_service.cpp file.
-* reset rcl_context shared_ptr after calling rcl_init sucessfully (`#1357 <https://github.com/ros2/rclcpp/issues/1357>`_)
-* Improved test publisher - zero qos history depth value exception (`#1360 <https://github.com/ros2/rclcpp/issues/1360>`_)
-* Covered resolve_use_intra_process (`#1359 <https://github.com/ros2/rclcpp/issues/1359>`_)
-* Improve test_subscription_options (`#1358 <https://github.com/ros2/rclcpp/issues/1358>`_)
-* Add in more tests for init_options coverage. (`#1353 <https://github.com/ros2/rclcpp/issues/1353>`_)
-* Test the remaining node public API (`#1342 <https://github.com/ros2/rclcpp/issues/1342>`_)
-* Complete coverage of Parameter and ParameterValue API (`#1344 <https://github.com/ros2/rclcpp/issues/1344>`_)
-* Add in more tests for the utilities. (`#1349 <https://github.com/ros2/rclcpp/issues/1349>`_)
-* Add in two more tests for expand_topic_or_service_name. (`#1350 <https://github.com/ros2/rclcpp/issues/1350>`_)
-* Add tests for node_options API (`#1343 <https://github.com/ros2/rclcpp/issues/1343>`_)
-* Add in more coverage for expand_topic_or_service_name. (`#1346 <https://github.com/ros2/rclcpp/issues/1346>`_)
-* Test exception in spin_until_future_complete. (`#1345 <https://github.com/ros2/rclcpp/issues/1345>`_)
-* Add coverage tests graph_listener (`#1330 <https://github.com/ros2/rclcpp/issues/1330>`_)
-* Add in unit tests for the Executor class.
-* Allow mimick patching of methods with up to 9 arguments.
-* Improve the error messages in the Executor class.
-* Add coverage for client API (`#1329 <https://github.com/ros2/rclcpp/issues/1329>`_)
-* Increase service coverage (`#1332 <https://github.com/ros2/rclcpp/issues/1332>`_)
-* Make more of the static entity collector API private.
-* Const-ify more of the static executor.
-* Add more tests for the static single threaded executor.
-* Many more tests for the static_executor_entities_collector.
-* Get one more line of code coverage in memory_strategy.cpp
-* Bugfix when adding callback group.
-* Fix typos in comments.
-* Remove deprecated executor::FutureReturnCode APIs. (`#1327 <https://github.com/ros2/rclcpp/issues/1327>`_)
-* Increase coverage of publisher/subscription API (`#1325 <https://github.com/ros2/rclcpp/issues/1325>`_)
-* Not finalize guard condition while destructing SubscriptionIntraProcess (`#1307 <https://github.com/ros2/rclcpp/issues/1307>`_)
-* Expose qos setting for /rosout (`#1247 <https://github.com/ros2/rclcpp/issues/1247>`_)
-* Add coverage for missing API (except executors) (`#1326 <https://github.com/ros2/rclcpp/issues/1326>`_)
-* Include topic name in QoS mismatch warning messages (`#1286 <https://github.com/ros2/rclcpp/issues/1286>`_)
-* Add coverage tests context functions (`#1321 <https://github.com/ros2/rclcpp/issues/1321>`_)
-* Increase coverage of node_interfaces, including with mocking rcl errors (`#1322 <https://github.com/ros2/rclcpp/issues/1322>`_)
-* Contributors: Ada-King, Alejandro Hernández Cordero, Audrow Nash, Barry Xu, Chen Lihui, Chris Lalancette, Christophe Bedard, Ivan Santiago Paunovic, Jorge Perez, Morgan Quigley, brawner
-
 5.0.0 (2020-09-18)
 ------------------
 * Make node_graph::count_graph_users() const (`#1320 <https://github.com/ros2/rclcpp/issues/1320>`_)

rclcpp/CMakeLists.txt

@@ -222,6 +222,12 @@ if(BUILD_TESTING)
   find_package(ament_lint_auto REQUIRED)
   ament_lint_auto_find_test_dependencies()
 
+  # For benchmark tests. Currently there is a bug where these targets can't be
+  # found if these calls are added to the CMakeLists.txt in test/rclcpp/benchmark
+  find_package(benchmark REQUIRED)
+  find_package(osrf_testing_tools_cpp REQUIRED)
+  find_package(performance_test_fixture REQUIRED)
+
   add_subdirectory(test)
 endif()
 

rclcpp/QUALITY_DECLARATION.md

@@ -197,7 +197,7 @@ It is **Quality Level 3**, see its [Quality Declaration document](https://github
 
 The `tracetools` package provides utilities for instrumenting the code in `rclcpp` so that it may be traced for debugging and performance analysis.
 
-It is **Quality Level 1**, see its [Quality Declaration document](https://gitlab.com/ros-tracing/ros2_tracing/-/blob/master/tracetools/QUALITY_DECLARATION.md).
+It is **Quality Level 2**, see its [Quality Declaration document](https://gitlab.com/micro-ROS/ros_tracing/ros2_tracing/-/blob/master/tracetools/QUALITY_DECLARATION.md).
 
 ### Direct Runtime non-ROS Dependency [5.iii]
 

rclcpp/include/rclcpp/duration.hpp

@@ -38,14 +38,10 @@ public:
    */
   Duration(int32_t seconds, uint32_t nanoseconds);
 
-  /// Construct duration from the specified nanoseconds.
-  [[deprecated(
-    "Use Duration::from_nanoseconds instead or std::chrono_literals. For example:"
-    "rclcpp::Duration::from_nanoseconds(int64_variable);"
-    "rclcpp::Duration(0ns);")]]
+  // This constructor matches any numeric value - ints or floats.
   explicit Duration(rcl_duration_value_t nanoseconds);
 
-  /// Construct duration from the specified std::chrono::nanoseconds.
+  // This constructor matches std::chrono::nanoseconds.
   explicit Duration(std::chrono::nanoseconds nanoseconds);
 
   // This constructor matches any std::chrono value other than nanoseconds
@@ -133,10 +129,6 @@ public:
   static Duration
   from_seconds(double seconds);
 
-  /// Create a duration object from an integer number representing nanoseconds
-  static Duration
-  from_nanoseconds(rcl_duration_value_t nanoseconds);
-
   /// Convert Duration into a std::chrono::Duration.
   template<class DurationT>
   DurationT
@@ -151,8 +143,6 @@ public:
 
 private:
   rcl_duration_t rcl_duration_;
-
-  Duration() = default;
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/experimental/intra_process_manager.hpp

@@ -207,7 +207,7 @@ public:
       sub_ids.take_shared_subscriptions.size() <= 1)
     {
       // There is at maximum 1 buffer that does not require ownership.
-      // So this case is equivalent to all the buffers requiring ownership
+      // So we this case is equivalent to all the buffers requiring ownership
 
       // Merge the two vector of ids into a unique one
       std::vector<uint64_t> concatenated_vector(sub_ids.take_shared_subscriptions);

rclcpp/include/rclcpp/node_interfaces/node_base.hpp

@@ -118,10 +118,6 @@ public:
   bool
   get_enable_topic_statistics_default() const override;
 
-  std::string
-  resolve_topic_or_service_name(
-    const std::string & name, bool is_service, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeBase)
 

rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp

@@ -163,13 +163,6 @@ public:
   virtual
   bool
   get_enable_topic_statistics_default() const = 0;
-
-  /// Expand and remap a given topic or service name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_topic_or_service_name(
-    const std::string & name, bool is_service, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_services.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__NODE_INTERFACES__NODE_SERVICES_HPP_
 #define RCLCPP__NODE_INTERFACES__NODE_SERVICES_HPP_
 
-#include <string>
-
 #include "rclcpp/callback_group.hpp"
 #include "rclcpp/client.hpp"
 #include "rclcpp/macros.hpp"
@@ -55,10 +53,6 @@ public:
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::CallbackGroup::SharedPtr group) override;
 
-  RCLCPP_PUBLIC
-  std::string
-  resolve_service_name(const std::string & name, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeServices)
 

rclcpp/include/rclcpp/node_interfaces/node_services_interface.hpp

@@ -15,8 +15,6 @@
 #ifndef RCLCPP__NODE_INTERFACES__NODE_SERVICES_INTERFACE_HPP_
 #define RCLCPP__NODE_INTERFACES__NODE_SERVICES_INTERFACE_HPP_
 
-#include <string>
-
 #include "rclcpp/callback_group.hpp"
 #include "rclcpp/client.hpp"
 #include "rclcpp/macros.hpp"
@@ -51,12 +49,6 @@ public:
   add_service(
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::CallbackGroup::SharedPtr group) = 0;
-
-  /// Get the remapped and expanded service name given a input name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_service_name(const std::string & name, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_topics.hpp

@@ -81,10 +81,6 @@ public:
   rclcpp::node_interfaces::NodeTimersInterface *
   get_node_timers_interface() const override;
 
-  RCLCPP_PUBLIC
-  std::string
-  resolve_topic_name(const std::string & name, bool only_expand = false) const override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeTopics)
 

rclcpp/include/rclcpp/node_interfaces/node_topics_interface.hpp

@@ -86,12 +86,6 @@ public:
   virtual
   rclcpp::node_interfaces::NodeTimersInterface *
   get_node_timers_interface() const = 0;
-
-  /// Get a remapped and expanded topic name given an input name.
-  RCLCPP_PUBLIC
-  virtual
-  std::string
-  resolve_topic_name(const std::string & name, bool only_expand = false) const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp</name>
-  <version>5.1.0</version>
+  <version>5.0.0</version>
   <description>The ROS client library in C++.</description>
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
   <maintainer email="mabel@openrobotics.org">Mabel Zhang</maintainer>

rclcpp/src/rclcpp/duration.cpp

@@ -37,7 +37,7 @@ Duration::Duration(int32_t seconds, uint32_t nanoseconds)
   rcl_duration_.nanoseconds += nanoseconds;
 }
 
-Duration::Duration(rcl_duration_value_t nanoseconds)
+Duration::Duration(int64_t nanoseconds)
 {
   rcl_duration_.nanoseconds = nanoseconds;
 }
@@ -148,7 +148,7 @@ Duration::operator+(const rclcpp::Duration & rhs) const
     this->rcl_duration_.nanoseconds,
     rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
-  return Duration::from_nanoseconds(
+  return Duration(
     rcl_duration_.nanoseconds + rhs.rcl_duration_.nanoseconds);
 }
 
@@ -177,7 +177,7 @@ Duration::operator-(const rclcpp::Duration & rhs) const
     rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
 
-  return Duration::from_nanoseconds(
+  return Duration(
     rcl_duration_.nanoseconds - rhs.rcl_duration_.nanoseconds);
 }
 
@@ -208,7 +208,7 @@ Duration::operator*(double scale) const
     scale,
     std::numeric_limits<rcl_duration_value_t>::max());
   long double scale_ld = static_cast<long double>(scale);
-  return Duration::from_nanoseconds(
+  return Duration(
     static_cast<rcl_duration_value_t>(
       static_cast<long double>(rcl_duration_.nanoseconds) * scale_ld));
 }
@@ -249,17 +249,7 @@ Duration::to_rmw_time() const
 Duration
 Duration::from_seconds(double seconds)
 {
-  Duration ret;
-  ret.rcl_duration_.nanoseconds = static_cast<int64_t>(RCL_S_TO_NS(seconds));
-  return ret;
-}
-
-Duration
-Duration::from_nanoseconds(rcl_duration_value_t nanoseconds)
-{
-  Duration ret;
-  ret.rcl_duration_.nanoseconds = nanoseconds;
-  return ret;
+  return Duration(static_cast<int64_t>(RCL_S_TO_NS(seconds)));
 }
 
 }  // namespace rclcpp

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -288,24 +288,3 @@ NodeBase::get_enable_topic_statistics_default() const
 {
   return enable_topic_statistics_default_;
 }
-
-std::string
-NodeBase::resolve_topic_or_service_name(
-  const std::string & name, bool is_service, bool only_expand) const
-{
-  char * output_cstr = NULL;
-  auto allocator = rcl_get_default_allocator();
-  rcl_ret_t ret = rcl_node_resolve_name(
-    node_handle_.get(),
-    name.c_str(),
-    allocator,
-    is_service,
-    only_expand,
-    &output_cstr);
-  if (RCL_RET_OK != ret) {
-    throw_from_rcl_error(ret, "failed to resolve name", rcl_get_error_state());
-  }
-  std::string output{output_cstr};
-  allocator.deallocate(output_cstr, allocator.state);
-  return output;
-}

rclcpp/src/rclcpp/node_interfaces/node_services.cpp

@@ -78,9 +78,3 @@ NodeServices::add_client(
     }
   }
 }
-
-std::string
-NodeServices::resolve_service_name(const std::string & name, bool only_expand) const
-{
-  return node_base_->resolve_topic_or_service_name(name, true, only_expand);
-}

rclcpp/src/rclcpp/node_interfaces/node_topics.cpp

@@ -129,9 +129,3 @@ NodeTopics::get_node_timers_interface() const
 {
   return node_timers_;
 }
-
-std::string
-NodeTopics::resolve_topic_name(const std::string & name, bool only_expand) const
-{
-  return node_base_->resolve_topic_or_service_name(name, false, only_expand);
-}

rclcpp/src/rclcpp/time.cpp

@@ -199,7 +199,7 @@ Time::operator-(const rclcpp::Time & rhs) const
     throw std::underflow_error("time subtraction leads to int64_t underflow");
   }
 
-  return Duration::from_nanoseconds(rcl_time_.nanoseconds - rhs.rcl_time_.nanoseconds);
+  return Duration(rcl_time_.nanoseconds - rhs.rcl_time_.nanoseconds);
 }
 
 Time

rclcpp/src/rclcpp/utilities.cpp

@@ -21,7 +21,6 @@
 
 #include "./signal_handler.hpp"
 #include "rclcpp/contexts/default_context.hpp"
-#include "rclcpp/detail/utilities.hpp"
 #include "rclcpp/exceptions.hpp"
 
 #include "rcl/error_handling.h"
@@ -57,47 +56,6 @@ uninstall_signal_handlers()
   return SignalHandler::get_global_signal_handler().uninstall();
 }
 
-static
-std::vector<std::string>
-_remove_ros_arguments(
-  char const * const argv[],
-  const rcl_arguments_t * args,
-  rcl_allocator_t alloc)
-{
-  rcl_ret_t ret;
-  int nonros_argc = 0;
-  const char ** nonros_argv = NULL;
-
-  ret = rcl_remove_ros_arguments(
-    argv,
-    args,
-    alloc,
-    &nonros_argc,
-    &nonros_argv);
-
-  if (RCL_RET_OK != ret || nonros_argc < 0) {
-    // Not using throw_from_rcl_error, because we may need to append deallocation failures.
-    exceptions::RCLError exc(ret, rcl_get_error_state(), "");
-    rcl_reset_error();
-    if (NULL != nonros_argv) {
-      alloc.deallocate(nonros_argv, alloc.state);
-    }
-    throw exc;
-  }
-
-  std::vector<std::string> return_arguments(static_cast<size_t>(nonros_argc));
-
-  for (size_t ii = 0; ii < static_cast<size_t>(nonros_argc); ++ii) {
-    return_arguments[ii] = std::string(nonros_argv[ii]);
-  }
-
-  if (NULL != nonros_argv) {
-    alloc.deallocate(nonros_argv, alloc.state);
-  }
-
-  return return_arguments;
-}
-
 std::vector<std::string>
 init_and_remove_ros_arguments(
   int argc,
@@ -105,10 +63,7 @@ init_and_remove_ros_arguments(
   const InitOptions & init_options)
 {
   init(argc, argv, init_options);
-
-  using rclcpp::contexts::get_global_default_context;
-  auto rcl_context = get_global_default_context()->get_rcl_context();
-  return _remove_ros_arguments(argv, &(rcl_context->global_arguments), rcl_get_default_allocator());
+  return remove_ros_arguments(argc, argv);
 }
 
 std::vector<std::string>
@@ -124,17 +79,40 @@ remove_ros_arguments(int argc, char const * const argv[])
     exceptions::throw_from_rcl_error(ret, "failed to parse arguments");
   }
 
-  std::vector<std::string> return_arguments;
-  try {
-    return_arguments = _remove_ros_arguments(argv, &parsed_args, alloc);
-  } catch (exceptions::RCLError & exc) {
+  int nonros_argc = 0;
+  const char ** nonros_argv = NULL;
+
+  ret = rcl_remove_ros_arguments(
+    argv,
+    &parsed_args,
+    alloc,
+    &nonros_argc,
+    &nonros_argv);
+
+  if (RCL_RET_OK != ret || nonros_argc < 0) {
+    // Not using throw_from_rcl_error, because we may need to append deallocation failures.
+    exceptions::RCLErrorBase base_exc(ret, rcl_get_error_state());
+    rcl_reset_error();
+    if (NULL != nonros_argv) {
+      alloc.deallocate(nonros_argv, alloc.state);
+    }
     if (RCL_RET_OK != rcl_arguments_fini(&parsed_args)) {
-      exc.formatted_message += std::string(
+      base_exc.formatted_message += std::string(
         ", failed also to cleanup parsed arguments, leaking memory: ") +
         rcl_get_error_string().str;
       rcl_reset_error();
     }
-    throw exc;
+    throw exceptions::RCLError(base_exc, "");
+  }
+
+  std::vector<std::string> return_arguments(static_cast<size_t>(nonros_argc));
+
+  for (size_t ii = 0; ii < static_cast<size_t>(nonros_argc); ++ii) {
+    return_arguments[ii] = std::string(nonros_argv[ii]);
+  }
+
+  if (NULL != nonros_argv) {
+    alloc.deallocate(nonros_argv, alloc.state);
   }
 
   ret = rcl_arguments_fini(&parsed_args);

rclcpp/test/CMakeLists.txt

@@ -4,7 +4,14 @@ find_package(test_msgs REQUIRED)
 
 include(cmake/rclcpp_add_build_failure_test.cmake)
 
-add_subdirectory(benchmark)
+rosidl_generate_interfaces(${PROJECT_NAME}_test_msgs
+  msg/Header.msg
+  msg/MessageWithHeader.msg
+  DEPENDENCIES builtin_interfaces
+  LIBRARY_NAME ${PROJECT_NAME}
+  SKIP_INSTALL
+)
+
 add_subdirectory(rclcpp)
 
 ament_add_gtest(test_rclcpp_gtest_macros utils/test_rclcpp_gtest_macros.cpp)

rclcpp/test/benchmark/CMakeLists.txt

@@ -1,27 +0,0 @@
-find_package(performance_test_fixture REQUIRED)
-
-# These benchmarks are only being created and run for the default RMW
-# implementation. We are looking to test the performance of the ROS 2 code, not
-# the underlying middleware.
-
-add_performance_test(benchmark_client benchmark_client.cpp)
-if(TARGET benchmark_client)
-  target_link_libraries(benchmark_client ${PROJECT_NAME})
-  ament_target_dependencies(benchmark_client test_msgs rcl_interfaces)
-endif()
-
-add_performance_test(benchmark_init_shutdown benchmark_init_shutdown.cpp)
-if(TARGET benchmark_init_shutdown)
-  target_link_libraries(benchmark_init_shutdown ${PROJECT_NAME})
-endif()
-
-add_performance_test(benchmark_node benchmark_node.cpp)
-if(TARGET benchmark_node)
-  target_link_libraries(benchmark_node ${PROJECT_NAME})
-endif()
-
-add_performance_test(benchmark_service benchmark_service.cpp)
-if(TARGET benchmark_service)
-  target_link_libraries(benchmark_service ${PROJECT_NAME})
-  ament_target_dependencies(benchmark_service test_msgs rcl_interfaces)
-endif()

rclcpp/test/benchmark/benchmark_client.cpp

@@ -1,153 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-#include <string>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "test_msgs/srv/empty.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-constexpr char empty_service_name[] = "empty_service";
-
-class ClientPerformanceTest : public PerformanceTest
-{
-public:
-  explicit ClientPerformanceTest(rclcpp::NodeOptions = rclcpp::NodeOptions()) {}
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_unique<rclcpp::Node>("node", "ns");
-
-    auto empty_service_callback =
-      [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {};
-    empty_service =
-      node->create_service<test_msgs::srv::Empty>(empty_service_name, empty_service_callback);
-
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-    empty_service.reset();
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-protected:
-  std::unique_ptr<rclcpp::Node> node;
-  std::shared_ptr<rclcpp::Service<test_msgs::srv::Empty>> empty_service;
-};
-
-BENCHMARK_F(ClientPerformanceTest, construct_client_no_service)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>("not_an_existing_service");
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto client = node->create_client<test_msgs::srv::Empty>("not_an_existing_service");
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, construct_client_empty_srv)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, destroy_client_empty_srv)(benchmark::State & state) {
-  // Prime cache
-  auto outer_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  outer_client.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(client);
-    benchmark::ClobberMemory();
-
-    client.reset();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, wait_for_service)(benchmark::State & state) {
-  int count = 0;
-  for (auto _ : state) {
-    state.PauseTiming();
-    const std::string service_name = std::string("service_") + std::to_string(count++);
-    // Create client before service so it has to 'discover' the service after construction
-    auto client = node->create_client<test_msgs::srv::Empty>(service_name);
-    auto callback =
-      [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {};
-    auto service =
-      node->create_service<test_msgs::srv::Empty>(service_name, callback);
-    state.ResumeTiming();
-
-    client->wait_for_service(std::chrono::seconds(1));
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, async_send_request_only)(benchmark::State & state) {
-  auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  auto shared_request = std::make_shared<test_msgs::srv::Empty::Request>();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future = client->async_send_request(shared_request);
-    benchmark::DoNotOptimize(future);
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(ClientPerformanceTest, async_send_request_and_response)(benchmark::State & state) {
-  auto client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-  auto shared_request = std::make_shared<test_msgs::srv::Empty::Request>();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future = client->async_send_request(shared_request);
-    rclcpp::spin_until_future_complete(
-      node->get_node_base_interface(), future, std::chrono::seconds(1));
-    benchmark::DoNotOptimize(future);
-    benchmark::ClobberMemory();
-  }
-}

rclcpp/test/benchmark/benchmark_init_shutdown.cpp

@@ -1,53 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-
-#include "rclcpp/rclcpp.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-BENCHMARK_F(PerformanceTest, rclcpp_init)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  rclcpp::init(0, nullptr);
-  rclcpp::shutdown();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    rclcpp::init(0, nullptr);
-
-    state.PauseTiming();
-    rclcpp::shutdown();
-    state.ResumeTiming();
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_F(PerformanceTest, rclcpp_shutdown)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  rclcpp::init(0, nullptr);
-  rclcpp::shutdown();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    rclcpp::init(0, nullptr);
-    state.ResumeTiming();
-
-    rclcpp::shutdown();
-    benchmark::ClobberMemory();
-  }
-}

rclcpp/test/benchmark/benchmark_node.cpp

@@ -1,77 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-#include <string>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-class NodePerformanceTest : public PerformanceTest
-{
-public:
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-    rclcpp::shutdown();
-  }
-};
-
-BENCHMARK_F(NodePerformanceTest, create_node)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  auto outer_node = std::make_shared<rclcpp::Node>("node");
-  outer_node.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // Using pointer to separate construction and destruction in timing
-    auto node = std::make_shared<rclcpp::Node>("node");
-    benchmark::DoNotOptimize(node);
-    benchmark::ClobberMemory();
-
-    // Ensure destruction of node is not counted toward timing
-    state.PauseTiming();
-    node.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(NodePerformanceTest, destroy_node)(benchmark::State & state)
-{
-  // Warmup and prime caches
-  auto outer_node = std::make_shared<rclcpp::Node>("node");
-  outer_node.reset();
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // Using pointer to separate construction and destruction in timing
-    state.PauseTiming();
-    auto node = std::make_shared<rclcpp::Node>("node");
-    state.ResumeTiming();
-
-    benchmark::DoNotOptimize(node);
-    benchmark::ClobberMemory();
-
-    node.reset();
-  }
-}

rclcpp/test/benchmark/benchmark_service.cpp

@@ -1,141 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "test_msgs/srv/empty.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-constexpr char empty_service_name[] = "empty_service";
-
-class ServicePerformanceTest : public PerformanceTest
-{
-public:
-  ServicePerformanceTest()
-  : callback_count(0) {}
-
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    node = std::make_unique<rclcpp::Node>("node", "ns");
-    empty_client = node->create_client<test_msgs::srv::Empty>(empty_service_name);
-    callback_count = 0;
-
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-
-    empty_client.reset();
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-  void ServiceCallback(
-    const test_msgs::srv::Empty::Request::SharedPtr,
-    test_msgs::srv::Empty::Response::SharedPtr)
-  {
-    callback_count++;
-  }
-
-protected:
-  std::unique_ptr<rclcpp::Node> node;
-  std::shared_ptr<rclcpp::Client<test_msgs::srv::Empty>> empty_client;
-  int callback_count;
-};
-
-BENCHMARK_F(ServicePerformanceTest, construct_service_no_client)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-
-  auto outer_service = node->create_service<test_msgs::srv::Empty>("not_a_service", callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto service = node->create_service<test_msgs::srv::Empty>("not_a_service", callback);
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    service.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, construct_service_empty_srv)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto outer_service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    state.PauseTiming();
-    service.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, destroy_service_empty_srv)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto outer_service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    service.reset();
-  }
-}
-
-BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & state) {
-  auto callback = std::bind(
-    &ServicePerformanceTest::ServiceCallback,
-    this, std::placeholders::_1, std::placeholders::_2);
-  auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    // Clear executor queue
-    rclcpp::spin_some(node->get_node_base_interface());
-
-    auto request = std::make_shared<test_msgs::srv::Empty::Request>();
-    auto future = empty_client->async_send_request(request);
-    state.ResumeTiming();
-    benchmark::DoNotOptimize(service);
-    benchmark::ClobberMemory();
-
-    rclcpp::spin_until_future_complete(node->get_node_base_interface(), future);
-  }
-  if (callback_count == 0) {
-    state.SkipWithError("Service callback was not called");
-  }
-}

rclcpp/test/rclcpp/CMakeLists.txt

@@ -1,17 +1,11 @@
+add_subdirectory(benchmark)
+
 find_package(ament_cmake_gtest REQUIRED)
 
 find_package(rmw_implementation_cmake REQUIRED)
 
 add_definitions(-DTEST_RESOURCES_DIRECTORY="${CMAKE_CURRENT_BINARY_DIR}/../resources")
 
-rosidl_generate_interfaces(${PROJECT_NAME}_test_msgs
-  ../msg/Header.msg
-  ../msg/MessageWithHeader.msg
-  DEPENDENCIES builtin_interfaces
-  LIBRARY_NAME ${PROJECT_NAME}
-  SKIP_INSTALL
-)
-
 ament_add_gtest(
   test_allocator_common
   allocator/test_allocator_common.cpp)

rclcpp/test/rclcpp/benchmark/CMakeLists.txt

@@ -0,0 +1,29 @@
+# Give cppcheck hints about macro definitions coming from outside this package
+get_target_property(
+  ament_cmake_cppcheck_ADDITIONAL_INCLUDE_DIRS
+  performance_test_fixture::performance_test_fixture
+  INTERFACE_INCLUDE_DIRECTORIES)
+
+function(add_rclcpp_benchmark NAME SOURCE)
+  cmake_parse_arguments(RCLCPP_BENCHMARK "" "LIBRARIES" "")
+  if(RCLCPP_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unrecognized arguments for 'add_rclcpp_benchmark' (${RCLCPP_UNPARSED_ARGUMENTS})")
+    return()
+  endif()
+  find_package(${rmw_implementation} REQUIRED)
+  message(STATUS "Adding ${NAME} for '${rmw_implementation}'")
+  set(rmw_implementation_env_var RMW_IMPLEMENTATION=${rmw_implementation})
+
+  set(full_benchmark_name ${NAME}${target_suffix})
+  add_performance_test(${full_benchmark_name} ${SOURCE})
+  if(TARGET ${full_benchmark_name})
+    target_link_libraries(${full_benchmark_name} ${PROJECT_NAME} ${LIBRARIES})
+  endif()
+endfunction()
+
+# Add new benchmarks inside this macro
+macro(rclcpp_benchmarks)
+  add_rclcpp_benchmark(benchmark_client benchmark_client.cpp)
+endmacro()
+
+call_for_each_rmw_implementation(rclcpp_benchmarks)

rclcpp/test/rclcpp/benchmark/benchmark_client.cpp

@@ -0,0 +1,13 @@
+// Copyright 2020 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -115,9 +115,9 @@ public:
   }
 };
 
-// TYPED_TEST_SUITE is deprecated as of gtest 1.9, use TYPED_TEST_SUITE when gtest dependency
+// TYPED_TEST_CASE is deprecated as of gtest 1.9, use TYPED_TEST_SUITE when gtest dependency
 // is updated.
-TYPED_TEST_SUITE(TestExecutors, ExecutorTypes, ExecutorTypeNames);
+TYPED_TEST_CASE(TestExecutors, ExecutorTypes, ExecutorTypeNames);
 
 // StaticSingleThreadedExecutor is not included in these tests for now, due to:
 // https://github.com/ros2/rclcpp/issues/1219
@@ -125,7 +125,7 @@ using StandardExecutors =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
   rclcpp::executors::MultiThreadedExecutor>;
-TYPED_TEST_SUITE(TestExecutorsStable, StandardExecutors, ExecutorTypeNames);
+TYPED_TEST_CASE(TestExecutorsStable, StandardExecutors, ExecutorTypeNames);
 
 // Make sure that executors detach from nodes when destructing
 TYPED_TEST(TestExecutors, detachOnDestruction) {

rclcpp/test/rclcpp/node_interfaces/test_node_services.cpp

@@ -16,7 +16,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "rcl/node_options.h"
 #include "rclcpp/node.hpp"
@@ -56,9 +55,7 @@ public:
   {
     rclcpp::init(0, nullptr);
 
-    rclcpp::NodeOptions options{};
-    options.arguments(std::vector<std::string>{"-r", "foo:=bar"});
-    node = std::make_shared<rclcpp::Node>("node", "ns", options);
+    node = std::make_shared<rclcpp::Node>("node", "ns");
 
     // This dynamic cast is not necessary for the unittest itself, but instead is used to ensure
     // the proper type is being tested and covered.
@@ -132,13 +129,3 @@ TEST_F(TestNodeService, add_client_rcl_trigger_guard_condition_error)
     node_services->add_client(client, callback_group),
     std::runtime_error("Failed to notify wait set on client creation: error not set"));
 }
-
-TEST_F(TestNodeService, resolve_service_name)
-{
-  EXPECT_EQ("/ns/bar", node_services->resolve_service_name("foo", false));
-  EXPECT_EQ("/ns/foo", node_services->resolve_service_name("foo", true));
-  EXPECT_EQ("/foo", node_services->resolve_service_name("/foo", true));
-  EXPECT_THROW(
-    node_services->resolve_service_name("this is not a valid name!~>", true),
-    rclcpp::exceptions::RCLError);
-}

rclcpp/test/rclcpp/node_interfaces/test_node_topics.cpp

@@ -17,7 +17,6 @@
 #include <memory>
 #include <string>
 #include <type_traits>
-#include <vector>
 
 #include "rcl/node_options.h"
 #include "rclcpp/node.hpp"
@@ -81,9 +80,7 @@ public:
   void SetUp()
   {
     rclcpp::init(0, nullptr);
-    rclcpp::NodeOptions options{};
-    options.arguments(std::vector<std::string>{"-r", "foo:=bar"});
-    node = std::make_shared<rclcpp::Node>("node", "ns", options);
+    node = std::make_shared<rclcpp::Node>("node", "ns");
 
     // This dynamic cast is not necessary for the unittest itself, but instead is used to ensure
     // the proper type is being tested and covered.
@@ -157,13 +154,3 @@ TEST_F(TestNodeTopics, add_subscription_rcl_trigger_guard_condition_error)
     node_topics->add_subscription(subscription, callback_group),
     std::runtime_error("failed to notify wait set on subscription creation: error not set"));
 }
-
-TEST_F(TestNodeTopics, resolve_topic_name)
-{
-  EXPECT_EQ("/ns/bar", node_topics->resolve_topic_name("foo", false));
-  EXPECT_EQ("/ns/foo", node_topics->resolve_topic_name("foo", true));
-  EXPECT_EQ("/foo", node_topics->resolve_topic_name("/foo", true));
-  EXPECT_THROW(
-    node_topics->resolve_topic_name("this is not a valid name!~>", true),
-    rclcpp::exceptions::RCLError);
-}

rclcpp/test/rclcpp/test_add_callback_groups_to_executor.cpp

@@ -79,7 +79,7 @@ public:
   }
 };
 
-TYPED_TEST_SUITE(TestAddCallbackGroupsToExecutor, ExecutorTypes, ExecutorTypeNames);
+TYPED_TEST_CASE(TestAddCallbackGroupsToExecutor, ExecutorTypes, ExecutorTypeNames);
 
 /*
  * Test adding callback groups.

rclcpp/test/rclcpp/test_duration.cpp

@@ -68,7 +68,7 @@ TEST_F(TestDuration, operators) {
 TEST_F(TestDuration, chrono_overloads) {
   int64_t ns = 123456789l;
   auto chrono_ns = std::chrono::nanoseconds(ns);
-  auto d1 = rclcpp::Duration::from_nanoseconds(ns);
+  auto d1 = rclcpp::Duration(ns);
   auto d2 = rclcpp::Duration(chrono_ns);
   auto d3 = rclcpp::Duration(123456789ns);
   EXPECT_EQ(d1, d2);
@@ -85,11 +85,11 @@ TEST_F(TestDuration, chrono_overloads) {
 }
 
 TEST_F(TestDuration, overflows) {
-  auto max = rclcpp::Duration::from_nanoseconds(std::numeric_limits<rcl_duration_value_t>::max());
-  auto min = rclcpp::Duration::from_nanoseconds(std::numeric_limits<rcl_duration_value_t>::min());
+  rclcpp::Duration max(std::numeric_limits<rcl_duration_value_t>::max());
+  rclcpp::Duration min(std::numeric_limits<rcl_duration_value_t>::min());
 
-  rclcpp::Duration one(1ns);
-  rclcpp::Duration negative_one(-1ns);
+  rclcpp::Duration one(1);
+  rclcpp::Duration negative_one(-1);
 
   EXPECT_THROW(max + one, std::overflow_error);
   EXPECT_THROW(min - one, std::underflow_error);
@@ -106,7 +106,7 @@ TEST_F(TestDuration, overflows) {
 }
 
 TEST_F(TestDuration, negative_duration) {
-  rclcpp::Duration assignable_duration = rclcpp::Duration(0ns) - rclcpp::Duration(5, 0);
+  rclcpp::Duration assignable_duration = rclcpp::Duration(0) - rclcpp::Duration(5, 0);
 
   {
     // avoid windows converting a literal number less than -INT_MAX to unsigned int C4146
@@ -140,24 +140,22 @@ static const int64_t ONE_SEC_IN_NS = 1000 * 1000 * 1000;
 static const int64_t ONE_AND_HALF_SEC_IN_NS = 3 * HALF_SEC_IN_NS;
 
 TEST_F(TestDuration, from_seconds) {
-  EXPECT_EQ(rclcpp::Duration(0ns), rclcpp::Duration::from_seconds(0.0));
-  EXPECT_EQ(rclcpp::Duration(0ns), rclcpp::Duration::from_seconds(0));
+  EXPECT_EQ(rclcpp::Duration(0), rclcpp::Duration::from_seconds(0.0));
+  EXPECT_EQ(rclcpp::Duration(0), rclcpp::Duration::from_seconds(0));
   EXPECT_EQ(rclcpp::Duration(1, HALF_SEC_IN_NS), rclcpp::Duration::from_seconds(1.5));
-  EXPECT_EQ(
-    rclcpp::Duration::from_nanoseconds(-ONE_AND_HALF_SEC_IN_NS),
-    rclcpp::Duration::from_seconds(-1.5));
+  EXPECT_EQ(rclcpp::Duration(-ONE_AND_HALF_SEC_IN_NS), rclcpp::Duration::from_seconds(-1.5));
 }
 
 TEST_F(TestDuration, std_chrono_constructors) {
-  EXPECT_EQ(rclcpp::Duration(0ns), rclcpp::Duration(0.0s));
-  EXPECT_EQ(rclcpp::Duration(0ns), rclcpp::Duration(0s));
+  EXPECT_EQ(rclcpp::Duration(0), rclcpp::Duration(0.0s));
+  EXPECT_EQ(rclcpp::Duration(0), rclcpp::Duration(0s));
   EXPECT_EQ(rclcpp::Duration(1, HALF_SEC_IN_NS), rclcpp::Duration(1.5s));
   EXPECT_EQ(rclcpp::Duration(-1, 0), rclcpp::Duration(-1s));
 }
 
 TEST_F(TestDuration, conversions) {
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(HALF_SEC_IN_NS);
+    const rclcpp::Duration duration(HALF_SEC_IN_NS);
     const auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, 0);
     EXPECT_EQ(duration_msg.nanosec, HALF_SEC_IN_NS);
@@ -172,7 +170,7 @@ TEST_F(TestDuration, conversions) {
   }
 
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(ONE_SEC_IN_NS);
+    const rclcpp::Duration duration(ONE_SEC_IN_NS);
     const auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, 1);
     EXPECT_EQ(duration_msg.nanosec, 0u);
@@ -187,7 +185,7 @@ TEST_F(TestDuration, conversions) {
   }
 
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(ONE_AND_HALF_SEC_IN_NS);
+    const rclcpp::Duration duration(ONE_AND_HALF_SEC_IN_NS);
     auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, 1);
     EXPECT_EQ(duration_msg.nanosec, HALF_SEC_IN_NS);
@@ -202,7 +200,7 @@ TEST_F(TestDuration, conversions) {
   }
 
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(-HALF_SEC_IN_NS);
+    rclcpp::Duration duration(-HALF_SEC_IN_NS);
     auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, -1);
     EXPECT_EQ(duration_msg.nanosec, HALF_SEC_IN_NS);
@@ -215,7 +213,7 @@ TEST_F(TestDuration, conversions) {
   }
 
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(-ONE_SEC_IN_NS);
+    rclcpp::Duration duration(-ONE_SEC_IN_NS);
     auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, -1);
     EXPECT_EQ(duration_msg.nanosec, 0u);
@@ -228,7 +226,7 @@ TEST_F(TestDuration, conversions) {
   }
 
   {
-    auto duration = rclcpp::Duration::from_nanoseconds(-ONE_AND_HALF_SEC_IN_NS);
+    rclcpp::Duration duration(-ONE_AND_HALF_SEC_IN_NS);
     auto duration_msg = static_cast<builtin_interfaces::msg::Duration>(duration);
     EXPECT_EQ(duration_msg.sec, -2);
     EXPECT_EQ(duration_msg.nanosec, HALF_SEC_IN_NS);
@@ -255,10 +253,9 @@ TEST_F(TestDuration, test_some_constructors) {
 }
 
 TEST_F(TestDuration, test_some_exceptions) {
-  rclcpp::Duration test_duration(0ns);
+  rclcpp::Duration test_duration(0u);
   RCLCPP_EXPECT_THROW_EQ(
-    test_duration =
-    rclcpp::Duration::from_nanoseconds(INT64_MAX) - rclcpp::Duration(-1ns),
+    test_duration = rclcpp::Duration(INT64_MAX) - rclcpp::Duration(-1),
     std::overflow_error("duration subtraction leads to int64_t overflow"));
   RCLCPP_EXPECT_THROW_EQ(
     test_duration = test_duration * (std::numeric_limits<double>::infinity()),

rclcpp/test/rclcpp/test_publisher.cpp

@@ -184,7 +184,7 @@ static std::vector<TestParameters> invalid_qos_profiles()
   return parameters;
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
   TestPublisherThrows, TestPublisherInvalidIntraprocessQos,
   ::testing::ValuesIn(invalid_qos_profiles()),
   ::testing::PrintToStringParamName());

rclcpp/test/rclcpp/test_publisher_subscription_count_api.cpp

@@ -192,7 +192,7 @@ using AllTestDescriptions = ::testing::Types<
   TwoSubscriptionsInTwoContextsWithIntraprocessComm,
   TwoSubscriptionsInTwoContextsWithoutIntraprocessComm
 >;
-TYPED_TEST_SUITE(TestPublisherSubscriptionCount, AllTestDescriptions, PrintTestDescription);
+TYPED_TEST_CASE(TestPublisherSubscriptionCount, AllTestDescriptions, PrintTestDescription);
 
 
 using test_msgs::msg::Empty;

rclcpp/test/rclcpp/test_subscription.cpp

@@ -506,7 +506,7 @@ static std::vector<TestParameters> invalid_qos_profiles()
   return parameters;
 }
 
-INSTANTIATE_TEST_SUITE_P(
+INSTANTIATE_TEST_CASE_P(
   TestSubscriptionThrows, TestSubscriptionInvalidIntraprocessQos,
   ::testing::ValuesIn(invalid_qos_profiles()),
   ::testing::PrintToStringParamName());

rclcpp/test/rclcpp/test_subscription_publisher_count_api.cpp

@@ -129,7 +129,7 @@ struct TwoContextsPerTest
 };
 
 using AllTestDescriptions = ::testing::Types<OneContextPerTest, TwoContextsPerTest>;
-TYPED_TEST_SUITE(TestSubscriptionPublisherCount, AllTestDescriptions, PrintTestDescription);
+TYPED_TEST_CASE(TestSubscriptionPublisherCount, AllTestDescriptions, PrintTestDescription);
 
 
 using test_msgs::msg::Empty;

rclcpp/test/rclcpp/test_time.cpp

@@ -15,7 +15,6 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
-#include <chrono>
 #include <limits>
 #include <string>
 
@@ -31,8 +30,6 @@
 namespace
 {
 
-using namespace std::chrono_literals;
-
 bool logical_eq(const bool a, const bool b)
 {
   return (a && b) || ((!a) && !(b));
@@ -224,7 +221,7 @@ TEST_F(TestTime, operators) {
   EXPECT_EQ(sub, young - old);
 
   rclcpp::Time young_changed(young);
-  young_changed -= rclcpp::Duration::from_nanoseconds(old.nanoseconds());
+  young_changed -= rclcpp::Duration(old.nanoseconds());
   EXPECT_EQ(sub.nanoseconds(), young_changed.nanoseconds());
 
   rclcpp::Time system_time(0, 0, RCL_SYSTEM_TIME);
@@ -323,8 +320,8 @@ TEST_F(TestTime, overflow_detectors) {
 TEST_F(TestTime, overflows) {
   rclcpp::Time max_time(std::numeric_limits<rcl_time_point_value_t>::max());
   rclcpp::Time min_time(std::numeric_limits<rcl_time_point_value_t>::min());
-  rclcpp::Duration one(1ns);
-  rclcpp::Duration two(2ns);
+  rclcpp::Duration one(1);
+  rclcpp::Duration two(2);
 
   // Cross min/max
   EXPECT_THROW(max_time + one, std::overflow_error);
@@ -397,7 +394,7 @@ TEST_F(TestTime, test_assignment_operator_from_builtin_msg_time) {
 }
 
 TEST_F(TestTime, test_sum_operator) {
-  const rclcpp::Duration one(1ns);
+  const rclcpp::Duration one(1);
   const rclcpp::Time test_time(0u);
   EXPECT_EQ(0u, test_time.nanoseconds());
 
@@ -409,41 +406,41 @@ TEST_F(TestTime, test_overflow_underflow_throws) {
   rclcpp::Time test_time(0u);
 
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MAX) + rclcpp::Duration(1ns),
+    test_time = rclcpp::Time(INT64_MAX) + rclcpp::Duration(1),
     std::overflow_error("addition leads to int64_t overflow"));
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MIN) + rclcpp::Duration(-1ns),
+    test_time = rclcpp::Time(INT64_MIN) + rclcpp::Duration(-1),
     std::underflow_error("addition leads to int64_t underflow"));
 
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MAX) - rclcpp::Duration(-1ns),
+    test_time = rclcpp::Time(INT64_MAX) - rclcpp::Duration(-1),
     std::overflow_error("time subtraction leads to int64_t overflow"));
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MIN) - rclcpp::Duration(1ns),
+    test_time = rclcpp::Time(INT64_MIN) - rclcpp::Duration(1),
     std::underflow_error("time subtraction leads to int64_t underflow"));
 
   test_time = rclcpp::Time(INT64_MAX);
   RCLCPP_EXPECT_THROW_EQ(
-    test_time += rclcpp::Duration(1ns),
+    test_time += rclcpp::Duration(1),
     std::overflow_error("addition leads to int64_t overflow"));
   test_time = rclcpp::Time(INT64_MIN);
   RCLCPP_EXPECT_THROW_EQ(
-    test_time += rclcpp::Duration(-1ns),
+    test_time += rclcpp::Duration(-1),
     std::underflow_error("addition leads to int64_t underflow"));
 
   test_time = rclcpp::Time(INT64_MAX);
   RCLCPP_EXPECT_THROW_EQ(
-    test_time -= rclcpp::Duration(-1ns),
+    test_time -= rclcpp::Duration(-1),
     std::overflow_error("time subtraction leads to int64_t overflow"));
   test_time = rclcpp::Time(INT64_MIN);
   RCLCPP_EXPECT_THROW_EQ(
-    test_time -= rclcpp::Duration(1ns),
+    test_time -= rclcpp::Duration(1),
     std::underflow_error("time subtraction leads to int64_t underflow"));
 
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Duration::from_nanoseconds(INT64_MAX) + rclcpp::Time(1),
+    test_time = rclcpp::Duration(INT64_MAX) + rclcpp::Time(1),
     std::overflow_error("addition leads to int64_t overflow"));
   RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Duration::from_nanoseconds(INT64_MIN) + rclcpp::Time(-1),
+    test_time = rclcpp::Duration(INT64_MIN) + rclcpp::Time(-1),
     std::underflow_error("addition leads to int64_t underflow"));
 }

rclcpp/test/rclcpp/test_utilities.cpp

@@ -61,29 +61,6 @@ TEST(TestUtilities, init_with_args) {
   rclcpp::shutdown();
 }
 
-TEST(TestUtilities, init_with_args_contains_ros) {
-  EXPECT_FALSE(rclcpp::signal_handlers_installed());
-  const char * const argv[] = {
-    "process_name",
-    "-d", "--ros-args",
-    "-r", "__ns:=/foo/bar",
-    "-r", "__ns:=/fiz/buz",
-    "--", "--foo=bar", "--baz"
-  };
-  int argc = sizeof(argv) / sizeof(const char *);
-  auto args = rclcpp::init_and_remove_ros_arguments(argc, argv);
-
-  ASSERT_EQ(4u, args.size());
-  ASSERT_EQ(std::string{"process_name"}, args[0]);
-  ASSERT_EQ(std::string{"-d"}, args[1]);
-  ASSERT_EQ(std::string{"--foo=bar"}, args[2]);
-  ASSERT_EQ(std::string{"--baz"}, args[3]);
-  EXPECT_TRUE(rclcpp::signal_handlers_installed());
-
-  EXPECT_TRUE(rclcpp::ok());
-  rclcpp::shutdown();
-}
-
 TEST(TestUtilities, multi_init) {
   auto context1 = std::make_shared<rclcpp::contexts::DefaultContext>();
   auto context2 = std::make_shared<rclcpp::contexts::DefaultContext>();

rclcpp_action/CHANGELOG.rst

@@ -3,15 +3,6 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-5.1.0 (2020-11-02)
-------------------
-* Benchmark rclcpp_action action_client (`#1429 <https://github.com/ros2/rclcpp/issues/1429>`_)
-* Add missing locking to the rclcpp_action::ServerBase. (`#1421 <https://github.com/ros2/rclcpp/issues/1421>`_)
-* Increase test timeouts of slow running tests with rmw_connext_cpp (`#1400 <https://github.com/ros2/rclcpp/issues/1400>`_)
-* Update maintainers (`#1384 <https://github.com/ros2/rclcpp/issues/1384>`_)
-* Increase coverage rclcpp_action to 95% (`#1290 <https://github.com/ros2/rclcpp/issues/1290>`_)
-* Contributors: Chris Lalancette, Ivan Santiago Paunovic, brawner
-
 5.0.0 (2020-09-18)
 ------------------
 * Pass goal handle to goal response callback instead of a future (`#1311 <https://github.com/ros2/rclcpp/issues/1311>`_)

rclcpp_action/CMakeLists.txt

@@ -74,8 +74,6 @@ if(BUILD_TESTING)
   set(ament_cmake_cppcheck_ADDITIONAL_INCLUDE_DIRS ${rclcpp_INCLUDE_DIRS})
   ament_lint_auto_find_test_dependencies()
 
-  add_subdirectory(test/benchmark)
-
   ament_add_gtest(test_client test/test_client.cpp TIMEOUT 180)
   if(TARGET test_client)
     ament_target_dependencies(test_client

rclcpp_action/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_action</name>
-  <version>5.1.0</version>
+  <version>5.0.0</version>
   <description>Adds action APIs for C++.</description>
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
   <maintainer email="mabel@openrobotics.org">Mabel Zhang</maintainer>
@@ -26,7 +26,6 @@
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
   <test_depend>mimick_vendor</test_depend>
-  <test_depend>performance_test_fixture</test_depend>
   <test_depend>test_msgs</test_depend>
 
   <export>

rclcpp_action/src/server.cpp

@@ -44,7 +44,7 @@ public:
   }
 
   // Lock everything except user callbacks
-  std::recursive_mutex action_server_reentrant_mutex_;
+  std::recursive_mutex reentrant_mutex_;
 
   std::shared_ptr<rcl_action_server_t> action_server_;
 
@@ -88,13 +88,12 @@ ServerBase::ServerBase(
       if (nullptr != ptr) {
         rcl_node_t * rcl_node = node_base->get_rcl_node_handle();
         rcl_ret_t ret = rcl_action_server_fini(ptr, rcl_node);
-        if (RCL_RET_OK != ret) {
-          RCLCPP_DEBUG(
-            rclcpp::get_logger("rclcpp_action"),
-            "failed to fini rcl_action_server_t in deleter");
-        }
-        delete ptr;
+        (void)ret;
+        RCLCPP_DEBUG(
+          rclcpp::get_logger("rclcpp_action"),
+          "failed to fini rcl_action_server_t in deleter");
       }
+      delete ptr;
     };
 
   pimpl_->action_server_.reset(new rcl_action_server_t, deleter);
@@ -160,7 +159,7 @@ ServerBase::get_number_of_ready_guard_conditions()
 bool
 ServerBase::add_to_wait_set(rcl_wait_set_t * wait_set)
 {
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   rcl_ret_t ret = rcl_action_wait_set_add_action_server(
     wait_set, pimpl_->action_server_.get(), NULL);
   return RCL_RET_OK == ret;
@@ -169,7 +168,7 @@ ServerBase::add_to_wait_set(rcl_wait_set_t * wait_set)
 bool
 ServerBase::is_ready(rcl_wait_set_t * wait_set)
 {
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   rcl_ret_t ret = rcl_action_server_wait_set_get_entities_ready(
     wait_set,
     pimpl_->action_server_.get(),
@@ -211,7 +210,7 @@ ServerBase::execute_goal_request_received()
   rcl_action_goal_info_t goal_info = rcl_action_get_zero_initialized_goal_info();
   rmw_request_id_t request_header;
 
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
 
   std::shared_ptr<void> message = create_goal_request();
   ret = rcl_action_take_goal_request(
@@ -255,11 +254,10 @@ ServerBase::execute_goal_request_received()
       {
         if (nullptr != ptr) {
           rcl_ret_t fail_ret = rcl_action_goal_handle_fini(ptr);
-          if (RCL_RET_OK != fail_ret) {
-            RCLCPP_DEBUG(
-              rclcpp::get_logger("rclcpp_action"),
-              "failed to fini rcl_action_goal_handle_t in deleter");
-          }
+          (void)fail_ret;
+          RCLCPP_DEBUG(
+            rclcpp::get_logger("rclcpp_action"),
+            "failed to fini rcl_action_goal_handle_t in deleter");
           delete ptr;
         }
       };
@@ -299,7 +297,7 @@ ServerBase::execute_cancel_request_received()
   // Initialize cancel request
   auto request = std::make_shared<action_msgs::srv::CancelGoal::Request>();
 
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   ret = rcl_action_take_cancel_request(
     pimpl_->action_server_.get(),
     &request_header,
@@ -385,7 +383,7 @@ ServerBase::execute_result_request_received()
   // Get the result request message
   rmw_request_id_t request_header;
   std::shared_ptr<void> result_request = create_result_request();
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   ret = rcl_action_take_result_request(
     pimpl_->action_server_.get(), &request_header, result_request.get());
 
@@ -441,7 +439,7 @@ ServerBase::execute_check_expired_goals()
 
   // Loop in case more than 1 goal expired
   while (num_expired > 0u) {
-    std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
     rcl_ret_t ret;
     ret = rcl_action_expire_goals(pimpl_->action_server_.get(), expired_goals, 1, &num_expired);
     if (RCL_RET_OK != ret) {
@@ -463,11 +461,6 @@ ServerBase::publish_status()
 {
   rcl_ret_t ret;
 
-  // We need to hold the lock across this entire method because
-  // rcl_action_server_get_goal_handles() returns an internal pointer to the
-  // goal data.
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
-
   // Get all goal handles known to C action server
   rcl_action_goal_handle_t ** goal_handles = NULL;
   size_t num_goals = 0;
@@ -523,7 +516,7 @@ ServerBase::publish_result(const GoalUUID & uuid, std::shared_ptr<void> result_m
   // Check that the goal exists
   rcl_action_goal_info_t goal_info;
   convert(uuid, &goal_info);
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   bool goal_exists;
   goal_exists = rcl_action_server_goal_exists(pimpl_->action_server_.get(), &goal_info);
 
@@ -549,7 +542,7 @@ ServerBase::publish_result(const GoalUUID & uuid, std::shared_ptr<void> result_m
 void
 ServerBase::notify_goal_terminal_state()
 {
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   rcl_ret_t ret = rcl_action_notify_goal_done(pimpl_->action_server_.get());
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret);
@@ -559,7 +552,7 @@ ServerBase::notify_goal_terminal_state()
 void
 ServerBase::publish_feedback(std::shared_ptr<void> feedback_msg)
 {
-  std::lock_guard<std::recursive_mutex> lock(pimpl_->action_server_reentrant_mutex_);
+  std::lock_guard<std::recursive_mutex> lock(pimpl_->reentrant_mutex_);
   rcl_ret_t ret = rcl_action_publish_feedback(pimpl_->action_server_.get(), feedback_msg.get());
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret, "Failed to publish feedback");

rclcpp_action/test/benchmark/CMakeLists.txt

@@ -1,14 +0,0 @@
-find_package(performance_test_fixture REQUIRED)
-
-# These benchmarks are only being created and run for the default RMW
-# implementation. We are looking to test the performance of the ROS 2 code, not
-# the underlying middleware.
-
-add_performance_test(
-  benchmark_action_client
-  benchmark_action_client.cpp
-  TIMEOUT 120)
-if(TARGET benchmark_action_client)
-  target_link_libraries(benchmark_action_client ${PROJECT_NAME})
-  ament_target_dependencies(benchmark_action_client rclcpp test_msgs)
-endif()

rclcpp_action/test/benchmark/benchmark_action_client.cpp

@@ -1,351 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-#include <string>
-
-#include "performance_test_fixture/performance_test_fixture.hpp"
-#include "rclcpp_action/rclcpp_action.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "test_msgs/action/fibonacci.hpp"
-
-using performance_test_fixture::PerformanceTest;
-
-using Fibonacci = test_msgs::action::Fibonacci;
-using GoalHandle = rclcpp_action::ServerGoalHandle<Fibonacci>;
-using CancelResponse = typename Fibonacci::Impl::CancelGoalService::Response;
-using GoalUUID = rclcpp_action::GoalUUID;
-
-constexpr char fibonacci_action_name[] = "fibonacci";
-
-namespace
-{
-
-test_msgs::action::Fibonacci::Goal GetGoalOfOrder(int order)
-{
-  test_msgs::action::Fibonacci::Goal goal;
-  goal.order = order;
-  return goal;
-}
-
-}  // namespace
-
-class ActionClientPerformanceTest : public PerformanceTest
-{
-public:
-  void SetUp(benchmark::State & state)
-  {
-    rclcpp::init(0, nullptr);
-    // Use same node for server and client to avoid interprocess communication
-    node = std::make_shared<rclcpp::Node>("node", "ns");
-    performance_test_fixture::PerformanceTest::SetUp(state);
-  }
-
-  void SetUpServer(const std::string & action_name)
-  {
-    // This action server accepts and defers so that execution can be timed separately from
-    // accepting the goal
-    action_server = rclcpp_action::create_server<Fibonacci>(
-      node, action_name,
-      [](const GoalUUID &, std::shared_ptr<const Fibonacci::Goal> goal) {
-        if (goal->order <= 0) {
-          return rclcpp_action::GoalResponse::REJECT;
-        }
-        return rclcpp_action::GoalResponse::ACCEPT_AND_DEFER;
-      },
-      [](std::shared_ptr<GoalHandle>) {
-        return rclcpp_action::CancelResponse::ACCEPT;
-      },
-      [this](std::shared_ptr<GoalHandle> goal_handle) {
-        current_goal_handle = goal_handle;
-      });
-  }
-
-  void ComputeFibonacciAndSetSuccess()
-  {
-    // This method is suprisingly slow, primarily due to the goal_handle->execute/succeed calls.
-    current_goal_handle->execute();
-    const auto goal = current_goal_handle->get_goal();
-    auto result = std::make_shared<Fibonacci::Result>();
-
-    // Should be checked by the server above
-    assert(goal->order > 0);
-    result->sequence.resize(goal->order);
-    result->sequence[0] = 0;
-    if (goal->order == 1) {
-      current_goal_handle->succeed(result);
-      return;
-    }
-    result->sequence[1] = 1;
-    if (goal->order == 2) {
-      current_goal_handle->succeed(result);
-      return;
-    }
-    for (int i = 2; i < goal->order; ++i) {
-      result->sequence[i] =
-        result->sequence[i - 1] + result->sequence[i - 2];
-    }
-    current_goal_handle->succeed(result);
-  }
-
-  void TearDown(benchmark::State & state)
-  {
-    performance_test_fixture::PerformanceTest::TearDown(state);
-    // Ensure proper sequencing of destruction
-    current_goal_handle.reset();
-    action_server.reset();
-    node.reset();
-    rclcpp::shutdown();
-  }
-
-protected:
-  std::shared_ptr<rclcpp::Node> node;
-  std::shared_ptr<rclcpp_action::Server<test_msgs::action::Fibonacci>> action_server;
-  std::shared_ptr<GoalHandle> current_goal_handle;
-};
-
-BENCHMARK_F(ActionClientPerformanceTest, construct_client_without_server)(benchmark::State & state)
-{
-  constexpr char action_name[] = "no_corresponding_server";
-  for (auto _ : state) {
-    auto client = rclcpp_action::create_client<Fibonacci>(node, action_name);
-
-    // Only timing construction, so destruction needs to happen explicitly while timing is paused
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, construct_client_with_server)(benchmark::State & state)
-{
-  SetUpServer(fibonacci_action_name);
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-
-    // Only timing construction, so destruction needs to happen explicitly while timing is paused
-    state.PauseTiming();
-    client.reset();
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, destroy_client)(benchmark::State & state)
-{
-  for (auto _ : state) {
-    // This client does not have a corresponding server
-    state.PauseTiming();
-    auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-    state.ResumeTiming();
-
-    client.reset();
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_send_goal_only)(benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  const auto goal = GetGoalOfOrder(5);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future_goal_handle = client->async_send_goal(goal);
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_send_goal_rejected)(benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  // Order of 0 is invalid
-  const auto goal = GetGoalOfOrder(0);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    auto future_goal_handle = client->async_send_goal(goal);
-    rclcpp::spin_until_future_complete(node, future_goal_handle, std::chrono::seconds(1));
-    if (!future_goal_handle.valid()) {
-      state.SkipWithError("Shared future was invalid");
-      return;
-    }
-    if (nullptr != future_goal_handle.get()) {
-      state.SkipWithError("Invalid goal was not rejected");
-      return;
-    }
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_send_goal_get_accepted_response)(
-  benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  const auto goal = GetGoalOfOrder(10);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // This server's execution is deferred
-    auto future_goal_handle = client->async_send_goal(goal);
-    rclcpp::spin_until_future_complete(node, future_goal_handle, std::chrono::seconds(1));
-
-    if (!future_goal_handle.valid()) {
-      state.SkipWithError("Shared future was invalid");
-      return;
-    }
-
-    auto goal_handle = future_goal_handle.get();
-    if (rclcpp_action::GoalStatus::STATUS_ACCEPTED != goal_handle->get_status()) {
-      state.SkipWithError("Valid goal was not accepted");
-      return;
-    }
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_get_result)(benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  constexpr int expected_order = 5;
-  const auto goal = GetGoalOfOrder(expected_order);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    // Send goal, accept and execute while timing is paused
-    state.PauseTiming();
-    auto future_goal_handle = client->async_send_goal(goal);
-
-    // Action server accepts and defers, so this spin doesn't include result
-    rclcpp::spin_until_future_complete(node, future_goal_handle, std::chrono::seconds(1));
-
-    if (!future_goal_handle.valid()) {
-      state.SkipWithError("Shared future was invalid");
-      return;
-    }
-    auto goal_handle = future_goal_handle.get();
-    if (nullptr == goal_handle) {
-      state.SkipWithError("Goal handle was a nullptr");
-      break;
-    }
-
-    // Perform actual execution and set success
-    ComputeFibonacciAndSetSuccess();
-    state.ResumeTiming();
-
-    // Measure how long it takes client to receive the succeeded result
-    auto future_result = client->async_get_result(goal_handle);
-    rclcpp::spin_until_future_complete(node, future_result, std::chrono::seconds(1));
-    const auto & wrapped_result = future_result.get();
-    if (rclcpp_action::ResultCode::SUCCEEDED != wrapped_result.code) {
-      state.SkipWithError("Fibonacci action did not succeed");
-      break;
-    }
-
-    const auto & sequence = wrapped_result.result->sequence;
-    if (sequence.size() != expected_order || sequence.back() != 3) {
-      state.SkipWithError("Fibonacci result was not correct");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_cancel_goal)(benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  constexpr int expected_order = 5;
-  const auto goal = GetGoalOfOrder(expected_order);
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    auto future_goal_handle = client->async_send_goal(goal);
-
-    // Action server accepts and defers, so action can be canceled
-    rclcpp::spin_until_future_complete(node, future_goal_handle, std::chrono::seconds(1));
-    auto goal_handle = future_goal_handle.get();
-    state.ResumeTiming();
-
-    auto future_cancel = client->async_cancel_goal(goal_handle);
-    rclcpp::spin_until_future_complete(node, future_cancel, std::chrono::seconds(1));
-    auto cancel_response = future_cancel.get();
-
-    using CancelResponse = test_msgs::action::Fibonacci::Impl::CancelGoalService::Response;
-    if (CancelResponse::ERROR_NONE != cancel_response->return_code) {
-      state.SkipWithError("Cancel request did not succeed");
-      break;
-    }
-  }
-}
-
-BENCHMARK_F(ActionClientPerformanceTest, async_cancel_all_goals)(benchmark::State & state)
-{
-  auto client = rclcpp_action::create_client<Fibonacci>(node, fibonacci_action_name);
-  SetUpServer(fibonacci_action_name);
-  if (!client->wait_for_action_server(std::chrono::seconds(1))) {
-    state.SkipWithError("Waiting for server timed out");
-    return;
-  }
-
-  constexpr int expected_order = 5;
-  const auto goal = GetGoalOfOrder(expected_order);
-  constexpr int num_concurrently_inflight_goals = 10u;
-
-  reset_heap_counters();
-  for (auto _ : state) {
-    state.PauseTiming();
-    for (int i = 0; i < num_concurrently_inflight_goals; ++i) {
-      auto future_goal_handle = client->async_send_goal(goal);
-      rclcpp::spin_until_future_complete(node, future_goal_handle, std::chrono::seconds(1));
-    }
-    // Action server accepts and defers, so action can be canceled
-    state.ResumeTiming();
-
-    auto future_cancel_all = client->async_cancel_all_goals();
-    rclcpp::spin_until_future_complete(node, future_cancel_all, std::chrono::seconds(1));
-    auto cancel_response = future_cancel_all.get();
-
-    using CancelResponse = test_msgs::action::Fibonacci::Impl::CancelGoalService::Response;
-    if (CancelResponse::ERROR_NONE != cancel_response->return_code) {
-      state.SkipWithError("Cancel request did not succeed");
-      break;
-    }
-  }
-}

rclcpp_components/CHANGELOG.rst

@@ -2,12 +2,6 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-5.1.0 (2020-11-02)
-------------------
-* Update maintainers (`#1384 <https://github.com/ros2/rclcpp/issues/1384>`_)
-* ComponentManager: switch off parameter services and event publisher (`#1333 <https://github.com/ros2/rclcpp/issues/1333>`_)
-* Contributors: Ivan Santiago Paunovic, Martijn Buijs
-
 5.0.0 (2020-09-18)
 ------------------
 

rclcpp_components/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_components</name>
-  <version>5.1.0</version>
+  <version>5.0.0</version>
   <description>Package containing tools for dynamically loadable components</description>
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
   <maintainer email="mabel@openrobotics.org">Mabel Zhang</maintainer>

rclcpp_lifecycle/CHANGELOG.rst

@@ -3,13 +3,6 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-5.1.0 (2020-11-02)
-------------------
-* Increase test timeouts of slow running tests with rmw_connext_cpp (`#1400 <https://github.com/ros2/rclcpp/issues/1400>`_)
-* Update maintainers (`#1384 <https://github.com/ros2/rclcpp/issues/1384>`_)
-* Add clock qos to node options (`#1375 <https://github.com/ros2/rclcpp/issues/1375>`_)
-* Contributors: Ivan Santiago Paunovic, brawner
-
 5.0.0 (2020-09-18)
 ------------------
 * Increase test coverage of rclcpp_lifecycle to 96% (`#1298 <https://github.com/ros2/rclcpp/issues/1298>`_)

rclcpp_lifecycle/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_lifecycle</name>
-  <version>5.1.0</version>
+  <version>5.0.0</version>
   <description>Package containing a prototype for lifecycle implementation</description>
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
   <maintainer email="mabel@openrobotics.org">Mabel Zhang</maintainer>