28.3.0

Changelog.
Signed-off-by: Chris Lalancette <clalancette@gmail.com>
2024-06-17 14:23:03 +00:00 · 2024-06-17 14:22:56 +00:00 · 2024-06-11 07:41:09 -07:00 · 2024-06-04 16:22:38 -07:00 · 2024-05-30 14:57:17 -07:00 · 2024-05-29 09:40:49 -07:00
88 changed files with 681 additions and 3313 deletions
--- a/.github/workflows/mirror-rolling-to-master.yaml
+++ b/.github/workflows/mirror-rolling-to-master.yaml
@@ -0,0 +1,13 @@
+name: Mirror rolling to master
+
+on:
+  push:
+    branches: [ rolling ]
+
+jobs:
+  mirror-to-master:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: zofrex/mirror-branch@v1
+      with:
+        target-branch: master
--- a/2
+++ b/2
@@ -0,0 +1,2 @@
+# This file was generated by https://github.com/audrow/update-ros2-repos
+* @ivanpauno @hidmic @wjwwood
--- a/rclcpp/CHANGELOG.rst
+++ b/rclcpp/CHANGELOG.rst
@@ -2,272 +2,19 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-28.1.13 (2025-10-21)
--------------------
-
-28.1.12 (2025-09-11)
--------------------
-* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_) (`#2945 <https://github.com/ros2/rclcpp/issues/2945>`_)
-* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_) (`#2936 <https://github.com/ros2/rclcpp/issues/2936>`_) (`#2937 <https://github.com/ros2/rclcpp/issues/2937>`_)
-* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_) (`#2920 <https://github.com/ros2/rclcpp/issues/2920>`_)
-* Contributors: mergify[bot]
-
-28.1.11 (2025-08-06)
--------------------
-* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_) (`#2909 <https://github.com/ros2/rclcpp/issues/2909>`_)
-  * Fix `start_type_description_service` param handling
-  * Add test
-  * Demonstrate different exceptions depending on node options
-  * Same exact exception and `what()` message in both cases
-  * Uncrustify
-  ---------
-  (cherry picked from commit 4fb558ae7b2ce7ce9b546e103beaac4f99991e5c)
-  Co-authored-by: Patrick Roncagliolo <ronca.pat@gmail.com>
-* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_) (`#2906 <https://github.com/ros2/rclcpp/issues/2906>`_)
-  (cherry picked from commit 2fcef70ea78c2c3a45391e59aebb265c05113050)
-  Co-authored-by: Sriharsha Ghanta <ghanta_sriharsha@mymail.sutd.edu.sg>
-  Co-authored-by: Alejandro Hernandez Cordero <ahcorde@gmail.com>
-* [jazzy] Expose `typesupport_helpers` API needed for the Rosbag2 (backport `#2858 <https://github.com/ros2/rclcpp/issues/2858>`_) (`#2902 <https://github.com/ros2/rclcpp/issues/2902>`_)
-  * Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_)
-  * Expose extract_type_identifier and get_typesupport_library_path API
-  - Rationale: We need to use this API in the Rosbag2
-  - Reference PR https://github.com/ros2/rosbag2/pull/2017 in the Rosbag2
-  * Use C++ style in doxygen documentation
-  ---------
-  (cherry picked from commit 448287b1090567181c809e59a3c72eed5ef4c69c)
-  # Conflicts:
-  #	rclcpp/include/rclcpp/typesupport_helpers.hpp
-  * Address merge conflicts
-  ---------
-  Co-authored-by: Michael Orlov <morlovmr@gmail.com>
-* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_) (`#2900 <https://github.com/ros2/rclcpp/issues/2900>`_)
-  (cherry picked from commit 84c6fb1cfc945521680a0e1fccf5b32237acbcc3)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_) (`#2895 <https://github.com/ros2/rclcpp/issues/2895>`_)
-  (cherry picked from commit fa0cf2da31dfae7c83f185e3bf18cb8fd55f0f57)
-  Co-authored-by: Patrick Roncagliolo <ronca.pat@gmail.com>
-* Event exec timer fix for https://github.com/ros2/rclcpp/issues/2889 (`#2890 <https://github.com/ros2/rclcpp/issues/2890>`_)
-  Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com>
-  Co-authored-by: Alejandro Hernández Cordero <ahcorde@gmail.com>
-* Shutdown deadlock fix jazzy (`#2887 <https://github.com/ros2/rclcpp/issues/2887>`_)
-  * fix: Don't deadlock if removing shutdown callbacks in a shutdown callback
-  * refactor: Made fix API compatible
-  ---------
-  Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com>
-* fix test_publisher_with_system_default_qos. (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_) (`#2883 <https://github.com/ros2/rclcpp/issues/2883>`_)
-  (cherry picked from commit e6577c6792f76a74e303cc0c061e89abeb8cb1a6)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Contributors: Janosch Machowinski, mergify[bot]
-
-28.1.10 (2025-06-23)
--------------------
-* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_) (`#2864 <https://github.com/ros2/rclcpp/issues/2864>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2856 <https://github.com/ros2/rclcpp/issues/2856>`_)
-* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (backport `#2840 <https://github.com/ros2/rclcpp/issues/2840>`_) (`#2851 <https://github.com/ros2/rclcpp/issues/2851>`_)
-* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_) (`#2845 <https://github.com/ros2/rclcpp/issues/2845>`_)
-* throws std::invalid_argument if ParameterEvent is NULL. (`#2814 <https://github.com/ros2/rclcpp/issues/2814>`_) (`#2825 <https://github.com/ros2/rclcpp/issues/2825>`_)
-* Merge pull request `#2821 <https://github.com/ros2/rclcpp/issues/2821>`_ from ros2/mergify/bp/jazzy/pr-2819
-* Fix race condition (`#2819 <https://github.com/ros2/rclcpp/issues/2819>`_)
-* Contributors: Michael Orlov, Pedro de Azeredo, mergify[bot]
-
-28.1.9 (2025-04-23)
+28.3.0 (2024-06-17)
 -------------------
-* remove redundant typesupport check in serialization module (`#2808 <https://github.com/ros2/rclcpp/issues/2808>`_) (`#2815 <https://github.com/ros2/rclcpp/issues/2815>`_)
-  (cherry picked from commit f78ed952b27acc63ef8022d78cb816c309a9ca3d)
-  Co-authored-by: Tanishq Chaudhary <tanishqchaudhary101010@gmail.com>
-* Contributors: mergify[bot]
+* Add test creating two content filter topics with the same topic name (`#2546 <https://github.com/ros2/rclcpp/issues/2546>`_) (`#2549 <https://github.com/ros2/rclcpp/issues/2549>`_)
+* add impl pointer for ExecutorOptions (`#2523 <https://github.com/ros2/rclcpp/issues/2523>`_)
+* Fixup Executor::spin_all() regression fix (`#2517 <https://github.com/ros2/rclcpp/issues/2517>`_)
+* Add 'mimick' label to tests which use Mimick (`#2516 <https://github.com/ros2/rclcpp/issues/2516>`_)
+* Contributors: Alejandro Hernández Cordero, Scott K Logan, William Woodall

-28.1.8 (2025-04-02)
+28.2.0 (2024-04-26)
 -------------------
-
-28.1.7 (2025-03-26)
-------------------
-* fix(ClockConditionalVariable): Fixed potential crash on shutdown (`#2762 <https://github.com/ros2/rclcpp/issues/2762>`_)
-* doc: Added warning to not instantiate Clock directly with RCL_ROS_TIME (`#2769 <https://github.com/ros2/rclcpp/issues/2769>`_)
-  * Backports: `#2768 <https://github.com/ros2/rclcpp/issues/2768>`_
-* Use rmw_event_type_is_supported in test_qos_event (`#2766 <https://github.com/ros2/rclcpp/issues/2766>`_)
-  * Backports: `#2761 <https://github.com/ros2/rclcpp/issues/2761>`_
-* fix: Fixed expiring of goals if events executor is used (`#2674 <https://github.com/ros2/rclcpp/issues/2674>`_)
-* Executor strong reference fix (`#2754 <https://github.com/ros2/rclcpp/issues/2754>`_)
-  * Backports: `#2745 <https://github.com/ros2/rclcpp/issues/2745>`_
-* Double gc executor fix (`#2753 <https://github.com/ros2/rclcpp/issues/2753>`_)
-* Fix typo in doc section for get_service_typesupport_handle (`#2752 <https://github.com/ros2/rclcpp/issues/2752>`_)
-  * Backports: `#2751 <https://github.com/ros2/rclcpp/issues/2751>`_
-* Test case and fix for for https://github.com/ros2/rclcpp/issues/2652 (`#2740 <https://github.com/ros2/rclcpp/issues/2740>`_)
-  * Backports: `#2713 <https://github.com/ros2/rclcpp/issues/2713>`_
-* fix(timer): Delete node, after executor thread terminated (`#2738 <https://github.com/ros2/rclcpp/issues/2738>`_)
-  * Backports: `#2737 <https://github.com/ros2/rclcpp/issues/2737>`_
-* fix(Executor): Fixed entities not beeing executed after just beeing added (`#2729 <https://github.com/ros2/rclcpp/issues/2729>`_)
-  * Backports: `#2737 <https://github.com/ros2/rclcpp/issues/2724>`_
-* Fix transient local IPC publish  (`#2722 <https://github.com/ros2/rclcpp/issues/2722>`_)
-  * Backports: `#2708 <https://github.com/ros2/rclcpp/issues/2708>`_
-* Contributors: Janosch Machowinski, Jeffery Hsu, Tomoya Fujita, Francisco Martín Rico
-
-28.1.6 (2024-12-18)
-------------------
-* apply actual QoS from rmw to the IPC publisher. (`#2707 <https://github.com/ros2/rclcpp/issues/2707>`_) (`#2712 <https://github.com/ros2/rclcpp/issues/2712>`_)
-  * apply actual QoS from rmw to the IPC publisher.
-  * address uncrustify warning.
-  ---------
-  (cherry picked from commit 016cfeac99e4b67f58abdf247e57f05b85c09ec4)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Adding in topic name to logging on IPC issues (`#2706 <https://github.com/ros2/rclcpp/issues/2706>`_) (`#2710 <https://github.com/ros2/rclcpp/issues/2710>`_)
-  * Adding in topic name to logging on IPC issues
-  * Update test matching output logging
-  * adding in single quotes
-  ---------
-  (cherry picked from commit a13e16e2cbaeacb14ff31272d01cbb21bd8ac037)
-  Co-authored-by: Steve Macenski <stevenmacenski@gmail.com>
-* enable testRaceConditionAddNode for rmw_connextdds. (`#2698 <https://github.com/ros2/rclcpp/issues/2698>`_)
-* Re-enable executor test on rmw_connextdds. (`#2693 <https://github.com/ros2/rclcpp/issues/2693>`_) (`#2695 <https://github.com/ros2/rclcpp/issues/2695>`_)
-  It supports the events executor now, so re-enable the test.
-  (cherry picked from commit d7245365ed867db9b309ed3efbfb0391bda09bd5)
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-* Fix warnings on Windows. (backport `#2692 <https://github.com/ros2/rclcpp/issues/2692>`_) (`#2694 <https://github.com/ros2/rclcpp/issues/2694>`_)
-  * Fix warnings on Windows. (`#2692 <https://github.com/ros2/rclcpp/issues/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.
-  (cherry picked from commit 3310f9eaed967e0c18d17bb2f82d2def838bb7a5)
-  # Conflicts:
-  #	rclcpp/test/rclcpp/executors/test_executors.cpp
-  * resolve backport conflict.
-  ---------
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Omnibus fixes for running tests with Connext. (backport `#2684 <https://github.com/ros2/rclcpp/issues/2684>`_) (`#2690 <https://github.com/ros2/rclcpp/issues/2690>`_)
-  * Omnibus fixes for running tests with Connext. (`#2684 <https://github.com/ros2/rclcpp/issues/2684>`_)
-  * Omnibus fixes for running tests with Connext.
-  When running the tests with RTI Connext as the default
-  RMW, some of the tests are failing.  There are three
-  different failures fixed here:
-  1.  Setting the liveliness duration to a value smaller than
-  a microsecond causes Connext to throw an error.  Set it to
-  a millisecond.
-  2.  Using the SystemDefaultsQoS sets the QoS to KEEP_LAST 1.
-  Connext is somewhat slow in this regard, so it can be the case
-  that we are overwriting a previous service introspection event
-  with the next one.  Switch to the ServicesDefaultQoS in the test,
-  which ensures we will not lose events.
-  3.  Connext is slow to match publishers and subscriptions.  Thus,
-  when creating a subscription "on-the-fly", we should wait for the
-  publisher to match it before expecting the subscription to actually
-  receive data from it.
-  With these fixes in place, the test_client_common, test_generic_service,
-  test_service_introspection, and test_executors tests all pass for
-  me with rmw_connextdds.
-  * Fixes for executors.
-  * One more fix for services.
-  * More fixes for service_introspection.
-  * More fixes for introspection.
-  ---------
-  (cherry picked from commit 9984197c292d6c5ae0e7661aaea245ffb0fea057)
-  # Conflicts:
-  #	rclcpp/test/rclcpp/executors/test_executors.cpp
-  #	rclcpp/test/rclcpp/test_generic_service.cpp
-  * address backport merge conflicts.
-  ---------
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* fix(Executor): Fix segfault if callback group is deleted during rmw_wait (`#2682 <https://github.com/ros2/rclcpp/issues/2682>`_)
-* Fix NodeOptions assignment operator (`#2656 <https://github.com/ros2/rclcpp/issues/2656>`_) (`#2660 <https://github.com/ros2/rclcpp/issues/2660>`_)
-  * Fix NodeOptions assignment operator
-  Also copy the enable_logger_service\_ member during the assignment operation
-  * Add more checks for NodeOptions copy test
-  * Set non default values by avoiding the copy-assignement
-  Co-authored-by: Christophe Bedard <bedard.christophe@gmail.com>
-  (cherry picked from commit 9b654942f99f17850e0e95480958abdbb508bc00)
-  Co-authored-by: Romain DESILLE <r.desille@gmail.com>
-* set QoS History KEEP_ALL explicitly for statistics publisher. (`#2650 <https://github.com/ros2/rclcpp/issues/2650>`_) (`#2657 <https://github.com/ros2/rclcpp/issues/2657>`_)
-  * set QoS History KEEP_ALL explicitly for statistics publisher.
-  * test_subscription_options adjustment.
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Contributors: Cristóbal Arroyo, Tomoya Fujita, jmachowinski, mergify[bot]
-
-28.1.5 (2024-09-19)
-------------------
-* backport fix events-executor warm-up bug and add unit-tests (`#2591 <https://github.com/ros2/rclcpp/issues/2591>`_) (`#2628 <https://github.com/ros2/rclcpp/issues/2628>`_)
-* Contributors: Alberto Soragna
-
-28.1.4 (2024-09-06)
-------------------
-* Split test_executors.cpp even further. (`#2572 <https://github.com/ros2/rclcpp/issues/2572>`_) (`#2619 <https://github.com/ros2/rclcpp/issues/2619>`_)
-  That's because it is too large for Windows Debug to compile,
-  so split into smaller bits.
-  Even with this split, the file is too big; that's likely
-  because we are using TYPED_TEST here, which generates multiple
-  symbols per test case.  To deal with this, without further
-  breaking up the file, also add in the /bigobj flag when
-  compiling on Windows Debug.
-  (cherry picked from commit c743c173e68d92af872cf163e10721a8dbe51dd0)
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-* Correct node name in service test code (`#2615 <https://github.com/ros2/rclcpp/issues/2615>`_) (`#2616 <https://github.com/ros2/rclcpp/issues/2616>`_)
-  (cherry picked from commit e846f56224a39b93f1c609e7ee03fff0662b7453)
-  Co-authored-by: Barry Xu <barry.xu@sony.com>
-* Release ownership of entities after spinning cancelled (backport `#2556 <https://github.com/ros2/rclcpp/issues/2556>`_) (`#2580 <https://github.com/ros2/rclcpp/issues/2580>`_)
-  * Release ownership of entities after spinning cancelled (`#2556 <https://github.com/ros2/rclcpp/issues/2556>`_)
-  * Release ownership of entities after spinning cancelled
-  * Move release action to every exit point in different spin functions
-  * Move wait_result\_.reset() before setting spinning to false
-  * Update test code
-  * Move test code to test_executors.cpp
-  ---------
-  (cherry picked from commit 069a0018935b33a14632a1cdf4074984a1cf80fe)
-  # Conflicts:
-  #	rclcpp/test/rclcpp/executors/test_executors.cpp
-  * Fix backport issue (`#2581 <https://github.com/ros2/rclcpp/issues/2581>`_)
-  ---------
-  Co-authored-by: Barry Xu <barry.xu@sony.com>
-* Contributors: mergify[bot]
-
-28.1.3 (2024-06-27)
-------------------
-* Add test creating two content filter topics with the same topic name (`#2546 <https://github.com/ros2/rclcpp/issues/2546>`_) (`#2549 <https://github.com/ros2/rclcpp/issues/2549>`_) (`#2552 <https://github.com/ros2/rclcpp/issues/2552>`_)
-  Co-authored-by: Mario Domínguez López <116071334+Mario-DL@users.noreply.github.com>
-  (cherry picked from commit 7c096888caf92aa7557e1d3efc5448b56d8ce81c)
-  Co-authored-by: Alejandro Hernández Cordero <ahcorde@gmail.com>
-* Contributors: mergify[bot]
-
-28.1.2 (2024-05-13)
-------------------
-* add impl pointer for ExecutorOptions (`#2523 <https://github.com/ros2/rclcpp/issues/2523>`_) (`#2525 <https://github.com/ros2/rclcpp/issues/2525>`_)
-  * add impl pointer for ExecutorOptions
-  (cherry picked from commit 343b29b617b163ad72b9fe3f6441dd4ed3d3af09)
-  Co-authored-by: William Woodall <william@osrfoundation.org>
-* Fixup Executor::spin_all() regression fix (`#2517 <https://github.com/ros2/rclcpp/issues/2517>`_) (`#2521 <https://github.com/ros2/rclcpp/issues/2521>`_)
-  * test(Executors): Added tests for busy waiting
-  Checks if executors are busy waiting while they should block
-  in spin_some or spin_all.
-  * fix: Reworked spinAll test
-  This test was strange. It looked like, it assumed that spin_all did
-  not return instantly. Also it was racy, as the thread could terminate
-  instantly.
-  * fix(Executor): Fixed spin_all not returning instantly is no work was available
-  * Update rclcpp/test/rclcpp/executors/test_executors.cpp
-  * test(executors): Added test for busy waiting while calling spin
-  * fix(executor): Reset wait_result on every call to spin_some_impl
-  Before, the method would not recollect available work in case of
-  spin_some, spin_all. This would lead to the method behaving differently
-  than to what the documentation states.
-  * restore previous test logic for now
-  * refactor spin_some_impl's logic and improve busy wait tests
-  * added some more comments about the implementation
-  ---------
-  Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com>
-  Co-authored-by: jmachowinski <jmachowinski@users.noreply.github.com>
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-  Co-authored-by: William Woodall <william@osrfoundation.org>
-* Contributors: mergify[bot]
-
-28.1.1 (2024-04-24)
-------------------
-* Revise the description of service configure_introspection() (`#2511 <https://github.com/ros2/rclcpp/issues/2511>`_) (`#2513 <https://github.com/ros2/rclcpp/issues/2513>`_)
-* Contributors: mergify[bot]
+* Check for negative time in rclcpp::Time(int64_t nanoseconds, ...) constructor (`#2510 <https://github.com/ros2/rclcpp/issues/2510>`_)
+* Revise the description of service configure_introspection() (`#2511 <https://github.com/ros2/rclcpp/issues/2511>`_)
+* Contributors: Barry Xu, Sharmin Ramli

 28.1.0 (2024-04-16)
 -------------------
--- a/rclcpp/include/rclcpp/clock.hpp
+++ b/rclcpp/include/rclcpp/clock.hpp
@@ -60,13 +60,6 @@ public:
  /**
   * Initializes the clock instance with the given clock_type.
   *
-   * WARNING Don't instantiate a clock using RCL_ROS_TIME directly,
-   * unless you really know what you are doing. By default no TimeSource
-   * is attached to a new clock. This will lead to the unexpected behavior,
-   * that your RCL_ROS_TIME will run always on system time. If you want
-   * a RCL_ROS_TIME use Node::get_clock(), or make sure to attach a
-   * TimeSource yourself.
-   *
   * \param clock_type type of the clock.
   * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
   */
@@ -267,117 +260,6 @@ private:
  std::shared_ptr<Impl> impl_;
 };

-/**
- * A synchronization primitive, equal to std::conditional_variable,
- * that works with the rclcpp::Clock.
- *
- * For more information on the API see https://en.cppreference.com/w/cpp/thread/condition_variable.
- *
- * Note, this class does not handle shutdowns, if you want to
- * haven them handles as well, use ClockConditionalVariable.
- */
-class ClockWaiter
-{
-private:
-  class ClockWaiterImpl;
-  std::unique_ptr<ClockWaiterImpl> impl_;
-
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(ClockWaiter)
-
-  RCLCPP_PUBLIC
-  explicit ClockWaiter(const rclcpp::Clock::SharedPtr & clock);
-
-  RCLCPP_PUBLIC
-  ~ClockWaiter();
-
-  /**
-   * Calling this function will block the current thread, until abs_time is reached,
-   * or pred returns true.
-   * @param lock A locked lock. The lock must be locked at call time, or this method will throw.
-   *             The lock will be atomically released and this thread will blocked.
-   * @param abs_time The time until which this thread shall be blocked.
-   * @param pred may be called in cased of spurious wakeups, but must be called every time
-   *             notify_one() was called. During the call to pred, the given lock will be locked.
-   *             This method will return, if pred returns true.
-   */
-  RCLCPP_PUBLIC
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock,
-    const rclcpp::Time & abs_time, const std::function<bool ()> & pred);
-
-  /**
-   * Notify the blocked thread, that it should reevaluate the wakeup condition.
-   * The given pred function in wait_until will be reevaluated and wait_until
-   * will return if it evaluates to true.
-   */
-  RCLCPP_PUBLIC
-  void
-  notify_one();
-};
-
-
-/**
- * A synchronization primitive, similar to std::conditional_variable,
- * that works with the rclcpp::Clock.
- *
- * For more information on the API see https://en.cppreference.com/w/cpp/thread/condition_variable.
- *
- * This primitive will wake up if the context was shut down.
- */
-class ClockConditionalVariable
-{
-  class Impl;
-  std::unique_ptr<Impl> impl_;
-
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(ClockConditionalVariable)
-
-  RCLCPP_PUBLIC
-  ClockConditionalVariable(
-    const rclcpp::Clock::SharedPtr & clock,
-    rclcpp::Context::SharedPtr context = rclcpp::contexts::get_global_default_context());
-  RCLCPP_PUBLIC
-  ~ClockConditionalVariable();
-
-  /**
-   * Calling this function will block the current thread, until abs_time is reached,
-   * or pred returns true.
-   * @param lock A locked lock. The lock must be locked at call time, or this method will throw.
-   *             The lock will be atomically released and this thread will blocked.
-   *             The given lock must be created using the mutex returned my mutex().
-   * @param abs_time The time until which this thread shall be blocked.
-   * @param pred may be called in cased of spurious wakeups, but must be called every time
-   *             notify_one() was called. During the call to pred, the given lock will be locked.
-   *             This method will return, if pred returns true.
-   *
-   * @return true if until was reached.
-   */
-  RCLCPP_PUBLIC
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-    const std::function<bool ()> & pred);
-
-  /**
-   * Notify the blocked thread, that is should reevaluate the wakeup condition.
-   * E.g. the given pred function in wait_until shall be reevaluated.
-   */
-  RCLCPP_PUBLIC
-  void
-  notify_one();
-
-  /**
-   * Returns the internal mutex. In order to be race free with the context shutdown,
-   * this mutex must be used for the wait_until call.
-   */
-  RCLCPP_PUBLIC
-  std::mutex &
-  mutex();
-};
-
-
 }  // namespace rclcpp

 #endif  // RCLCPP__CLOCK_HPP_
--- a/rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp
+++ b/rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp
@@ -255,13 +255,9 @@ private:
    std::vector<BufferT> result_vtr;
    result_vtr.reserve(size_);
    for (size_t id = 0; id < size_; ++id) {
-      const auto & elem(ring_buffer_[(read_index_ + id) % capacity_]);
-      if (elem != nullptr) {
-        result_vtr.emplace_back(new typename is_std_unique_ptr<T>::Ptr_type(
-          *elem));
-      } else {
-        result_vtr.emplace_back(nullptr);
-      }
+      result_vtr.emplace_back(
+        new typename is_std_unique_ptr<T>::Ptr_type(
+          *(ring_buffer_[(read_index_ + id) % capacity_])));
    }
    return result_vtr;
  }
--- a/rclcpp/include/rclcpp/node_options.hpp
+++ b/rclcpp/include/rclcpp/node_options.hpp
@@ -146,14 +146,6 @@ public:
    return *this;
  }

-  /// Append a single parameter override, parameter idiom style.
-  NodeOptions &
-  append_parameter_override(const rclcpp::Parameter & param)
-  {
-    this->parameter_overrides().push_back(param);
-    return *this;
-  }
-
  /// Return the use_global_arguments flag.
  RCLCPP_PUBLIC
  bool
--- a/rclcpp/include/rclcpp/parameter_events_filter.hpp
+++ b/rclcpp/include/rclcpp/parameter_events_filter.hpp
@@ -45,7 +45,6 @@ public:
   * \param[in] names A list of parameter names of interest.
   * \param[in] types A list of the types of parameter events of iterest.
   *    EventType NEW, DELETED, or CHANGED
-   * \throws std::invalid_argument if event is NULL.
   *
   * Example Usage:
   *
--- a/rclcpp/include/rclcpp/publisher.hpp
+++ b/rclcpp/include/rclcpp/publisher.hpp
@@ -162,7 +162,8 @@ public:
    const rclcpp::QoS & qos,
    const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options)
  {
-    (void)qos;
+    // Topic is unused for now.
+    (void)topic;
    (void)options;

    // If needed, setup intra process communication.
@@ -170,26 +171,22 @@ public:
      auto context = node_base->get_context();
      // Get the intra process manager instance for this context.
      auto ipm = context->get_sub_context<rclcpp::experimental::IntraProcessManager>();
-      // Check if the QoS is compatible with intra-process.
-      auto qos_profile = get_actual_qos();
-      if (qos_profile.history() != rclcpp::HistoryPolicy::KeepLast) {
+      // Register the publisher with the intra process manager.
+      if (qos.history() != rclcpp::HistoryPolicy::KeepLast) {
        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' allowed only with keep last history qos policy");
+                "intraprocess communication allowed only with keep last history qos policy");
      }
-      if (qos_profile.depth() == 0) {
+      if (qos.depth() == 0) {
        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic +
-                "' is not allowed with a zero qos history depth value");
+                "intraprocess communication is not allowed with a zero qos history depth value");
      }
-      if (qos_profile.durability() == rclcpp::DurabilityPolicy::TransientLocal) {
+      if (qos.durability() == rclcpp::DurabilityPolicy::TransientLocal) {
        buffer_ = rclcpp::experimental::create_intra_process_buffer<
          ROSMessageType, ROSMessageTypeAllocator, ROSMessageTypeDeleter>(
          rclcpp::detail::resolve_intra_process_buffer_type(options_.intra_process_buffer_type),
-          qos_profile,
+          qos,
          std::make_shared<ROSMessageTypeAllocator>(ros_message_type_allocator_));
      }
-      // Register the publisher with the intra process manager.
      uint64_t intra_process_publisher_id = ipm->add_publisher(this->shared_from_this(), buffer_);
      this->setup_intra_process(
        intra_process_publisher_id,
@@ -251,12 +248,8 @@ public:
    // interprocess publish, resulting in lower publish-to-subscribe latency.
    // It's not possible to do that with an unique_ptr,
    // as do_intra_process_publish takes the ownership of the message.
-
-    // When durability is set to TransientLocal (i.e. there is a buffer),
-    // inter process publish should always take place to ensure
-    // late joiners receive past data.
    bool inter_process_publish_needed =
-      get_subscription_count() > get_intra_process_subscription_count() || buffer_;
+      get_subscription_count() > get_intra_process_subscription_count();

    if (inter_process_publish_needed) {
      auto shared_msg =
@@ -333,11 +326,8 @@ public:
      return;
    }

-    // When durability is set to TransientLocal (i.e. there is a buffer),
-    // inter process publish should always take place to ensure
-    // late joiners receive past data.
    bool inter_process_publish_needed =
-      get_subscription_count() > get_intra_process_subscription_count() || buffer_;
+      get_subscription_count() > get_intra_process_subscription_count();

    if (inter_process_publish_needed) {
      auto ros_msg_ptr = std::make_shared<ROSMessageType>();
--- a/rclcpp/include/rclcpp/subscription.hpp
+++ b/rclcpp/include/rclcpp/subscription.hpp
@@ -159,13 +159,11 @@ public:
      auto qos_profile = get_actual_qos();
      if (qos_profile.history() != rclcpp::HistoryPolicy::KeepLast) {
        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic_name +
-                "' allowed only with keep last history qos policy");
+                "intraprocess communication allowed only with keep last history qos policy");
      }
      if (qos_profile.depth() == 0) {
        throw std::invalid_argument(
-                "intraprocess communication on topic '" + topic_name +
-                "' is not allowed with 0 depth qos policy");
+                "intraprocess communication is not allowed with 0 depth qos policy");
      }

      using SubscriptionIntraProcessT = rclcpp::experimental::SubscriptionIntraProcess<
--- a/rclcpp/include/rclcpp/subscription_options.hpp
+++ b/rclcpp/include/rclcpp/subscription_options.hpp
@@ -80,8 +80,7 @@ struct SubscriptionOptionsBase

    // An optional QoS which can provide topic_statistics with a stable QoS separate from
    // the subscription's current QoS settings which could be unstable.
-    // Explicitly set the enough depth to avoid missing the statistics messages.
-    rclcpp::QoS qos = SystemDefaultsQoS().keep_last(10);
+    rclcpp::QoS qos = SystemDefaultsQoS();
  };

  TopicStatisticsOptions topic_stats_options;
--- a/rclcpp/include/rclcpp/time.hpp
+++ b/rclcpp/include/rclcpp/time.hpp
@@ -49,6 +49,7 @@ public:
  /**
   * \param nanoseconds since time epoch
   * \param clock_type clock type
+   * \throws std::runtime_error if nanoseconds are negative
   */
  RCLCPP_PUBLIC
  explicit Time(int64_t nanoseconds = 0, rcl_clock_type_t clock_type = RCL_SYSTEM_TIME);
--- a/rclcpp/include/rclcpp/typesupport_helpers.hpp
+++ b/rclcpp/include/rclcpp/typesupport_helpers.hpp
@@ -28,48 +28,27 @@

 namespace rclcpp
 {
-
-/// \brief Extract the package name, middle module, and type name from a full type string.
-/// \details This function takes a full type string (e.g., "std_msgs/msg/String") and extracts
-/// the package name, middle module (if any), and type name. The middle module is the part
-/// between the package name and the type name, which is typically used for message types.
-/// For example, for "std_msgs/msg/String", it returns ("std_msgs", "msg", "String").
-/// \param[in] full_type
-/// \throws std::runtime_error if the input full type string is malformed or does not follow the
-/// expected format.
-/// \return A tuple containing the package name, middle module (if any), and type name.
-RCLCPP_PUBLIC
-std::tuple<std::string, std::string, std::string>
-extract_type_identifier(const std::string & full_type);
-
-/// \brief Look for the library in the ament prefix paths and return the path to the type support
-/// library.
-/// \param[in] package_name The name of the package containing the type support library,
-/// e.g. "std_msgs".
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \throws std::runtime_error if the library is not found.
-/// \return The path to the type support library.
-RCLCPP_PUBLIC
-std::string get_typesupport_library_path(
-  const std::string & package_name, const std::string & typesupport_identifier);
-
-/// \brief Load the type support library for the given type.
-/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \throws std::runtime_error if the library is not found or cannot be loaded.
-/// \return A shared library
+/// Load the type support library for the given type.
+/**
+ * \param[in] type The topic type, e.g. "std_msgs/msg/String"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \return A shared library
+ */
 RCLCPP_PUBLIC
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier);

-/// \brief Extract the type support handle from the library.
-/// \note The library needs to match the topic type. The shared library must stay loaded for the
-/// lifetime of the result.
-/// \deprecated Use get_message_typesupport_handle() instead
-/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \param[in] library The shared type support library
-/// \return A type support handle
+/// Extract the type support handle from the library.
+/**
+ * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
+ *
+ * \deprecated Use get_message_typesupport_handle() instead
+ *
+ * \param[in] type The topic type, e.g. "std_msgs/msg/String"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \param[in] library The shared type support library
+ * \return A type support handle
+ */
 [[deprecated("Use `get_message_typesupport_handle` instead")]]
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
@@ -78,14 +57,16 @@ get_typesupport_handle(
  const std::string & typesupport_identifier,
  rcpputils::SharedLibrary & library);

-/// \brief Extracts the message type support handle from the library.
-/// \note The library needs to match the topic type. The shared library must stay loaded for the
-/// lifetime of the result.
-/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \param[in] library The shared type support library
-/// \throws std::runtime_error if the symbol of type not found in the library.
-/// \return A message type support handle
+/// Extract the message type support handle from the library.
+/**
+ * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
+ *
+ * \param[in] type The topic type, e.g. "std_msgs/msg/String"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \param[in] library The shared type support library
+ * \throws std::runtime_error if the symbol of type not found in the library.
+ * \return A message type support handle
+ */
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
 get_message_typesupport_handle(
@@ -93,14 +74,16 @@ get_message_typesupport_handle(
  const std::string & typesupport_identifier,
  rcpputils::SharedLibrary & library);

-/// \brief Extracts the service type support handle from the library.
-/// \note The library needs to match the service type. The shared library must stay loaded for the
-/// lifetime of the result.
-/// \param[in] type The service type, e.g. "std_srvs/srv/Empty"
-/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
-/// \param[in] library The shared type support library
-/// \throws std::runtime_error if the symbol of type not found in the library.
-/// \return A service type support handle
+/// Extract the service type support handle from the library.
+/**
+ * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
+ *
+ * \param[in] type The service type, e.g. "std_srvs/srv/Empty"
+ * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+ * \param[in] library The shared type support library
+ * \throws std::runtime_error if the symbol of type not found in the library.
+ * \return A service type support handle
+ */
 RCLCPP_PUBLIC
 const rosidl_service_type_support_t *
 get_service_typesupport_handle(
--- a/rclcpp/include/rclcpp/wait_for_message.hpp
+++ b/rclcpp/include/rclcpp/wait_for_message.hpp
@@ -15,7 +15,6 @@
 #ifndef RCLCPP__WAIT_FOR_MESSAGE_HPP_
 #define RCLCPP__WAIT_FOR_MESSAGE_HPP_

-#include <future>
 #include <memory>
 #include <string>

@@ -24,7 +23,6 @@
 #include "rclcpp/node.hpp"
 #include "rclcpp/visibility_control.hpp"
 #include "rclcpp/wait_set.hpp"
-#include "rclcpp/qos.hpp"

 namespace rclcpp
 {
@@ -81,11 +79,10 @@ bool wait_for_message(
 /**
 * Wait for the next incoming message to arrive on a specified topic before the specified timeout.
 *
- * \param[out] out is the message to be filled when a new message is arriving
+ * \param[out] out is the message to be filled when a new message is arriving.
 * \param[in] node the node pointer to initialize the subscription on.
 * \param[in] topic the topic to wait for messages.
 * \param[in] time_to_wait parameter specifying the timeout before returning.
- * \param[in] qos parameter specifying QoS settings for the subscription.
 * \return true if a message was successfully received, false if message could not
 * be obtained or shutdown was triggered asynchronously on the context.
 */
@@ -94,10 +91,9 @@ bool wait_for_message(
  MsgT & out,
  rclcpp::Node::SharedPtr node,
  const std::string & topic,
-  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1),
-  const rclcpp::QoS & qos = rclcpp::SystemDefaultsQoS())
+  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1))
 {
-  auto sub = node->create_subscription<MsgT>(topic, qos, [](const std::shared_ptr<const MsgT>) {});
+  auto sub = node->create_subscription<MsgT>(topic, 1, [](const std::shared_ptr<const MsgT>) {});
  return wait_for_message<MsgT, Rep, Period>(
    out, sub, node->get_node_options().context(), time_to_wait);
 }
--- a/rclcpp/include/rclcpp/wait_result.hpp
+++ b/rclcpp/include/rclcpp/wait_result.hpp
@@ -176,9 +176,7 @@ public:
      for (; ii < wait_set.size_of_timers(); ++ii) {
        if (rcl_wait_set.timers[ii] != nullptr) {
          ret = wait_set.timers(ii);
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -219,9 +217,7 @@ public:
        if (rcl_wait_set.subscriptions[ii] != nullptr) {
          ret = wait_set.subscriptions(ii);
          rcl_wait_set.subscriptions[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -241,9 +237,7 @@ public:
        if (rcl_wait_set.services[ii] != nullptr) {
          ret = wait_set.services(ii);
          rcl_wait_set.services[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
@@ -263,9 +257,7 @@ public:
        if (rcl_wait_set.clients[ii] != nullptr) {
          ret = wait_set.clients(ii);
          rcl_wait_set.clients[ii] = nullptr;
-          if (ret) {
-            break;
-          }
+          break;
        }
      }
    }
--- a/rclcpp/include/rclcpp/wait_set_policies/dynamic_storage.hpp
+++ b/rclcpp/include/rclcpp/wait_set_policies/dynamic_storage.hpp
@@ -216,11 +216,6 @@ public:
      shared_waitables_
    );

-    if (this->needs_pruning_) {
-      this->storage_prune_deleted_entities();
-      this->needs_pruning_ = false;
-    }
-
    this->storage_release_ownerships();
  }

@@ -460,60 +455,59 @@ public:

  size_t size_of_subscriptions() const
  {
-    return subscriptions_.size();
+    return shared_subscriptions_.size();
  }

  size_t size_of_timers() const
  {
-    return timers_.size();
+    return shared_timers_.size();
  }

  size_t size_of_clients() const
  {
-    return clients_.size();
+    return shared_clients_.size();
  }

  size_t size_of_services() const
  {
-    return services_.size();
+    return shared_services_.size();
  }

  size_t size_of_waitables() const
  {
-    return waitables_.size();
+    return shared_waitables_.size();
  }

  std::shared_ptr<rclcpp::SubscriptionBase>
  subscriptions(size_t ii) const
  {
-    return subscriptions_[ii].lock();
+    return shared_subscriptions_[ii].subscription;
  }

  std::shared_ptr<rclcpp::TimerBase>
  timers(size_t ii) const
  {
-    return timers_[ii].lock();
+    return shared_timers_[ii];
  }

  std::shared_ptr<rclcpp::ClientBase>
  clients(size_t ii) const
  {
-    return clients_[ii].lock();
+    return shared_clients_[ii];
  }

  std::shared_ptr<rclcpp::ServiceBase>
  services(size_t ii) const
  {
-    return services_[ii].lock();
+    return shared_services_[ii];
  }

  std::shared_ptr<rclcpp::Waitable>
  waitables(size_t ii) const
  {
-    return waitables_[ii].lock();
+    return shared_waitables_[ii].waitable;
  }

-private:
  size_t ownership_reference_counter_ = 0;

  SequenceOfWeakSubscriptions subscriptions_;
--- a/rclcpp/include/rclcpp/wait_set_policies/static_storage.hpp
+++ b/rclcpp/include/rclcpp/wait_set_policies/static_storage.hpp
@@ -160,15 +160,6 @@ public:
      services_,
      waitables_
    );
-
-    if(this->needs_pruning_) {
-      // we need to throw here, as the indexing of the rcl_waitset is broken,
-      // in case of invalid entries
-
-      throw std::runtime_error(
-            "StaticStorage::storage_rebuild_rcl_wait_set(): entity weak_ptr "
-            "unexpectedly expired in static entity storage");
-    }
  }

  // storage_add_subscription() explicitly not declared here
--- a/rclcpp/include/rclcpp/wait_set_template.hpp
+++ b/rclcpp/include/rclcpp/wait_set_template.hpp
@@ -734,6 +734,8 @@ private:
    wait_result_dirty_ = false;
    // this method comes from the SynchronizationPolicy
    this->sync_wait_result_acquire();
+    // this method comes from the StoragePolicy
+    this->storage_acquire_ownerships();
  }

  /// Called by the WaitResult's destructor to release resources.
@@ -750,6 +752,8 @@ private:
    }
    wait_result_holding_ = false;
    wait_result_dirty_ = false;
+    // this method comes from the StoragePolicy
+    this->storage_release_ownerships();
    // this method comes from the SynchronizationPolicy
    this->sync_wait_result_release();
  }
--- a/rclcpp/package.xml
+++ b/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>28.1.13</version>
+  <version>28.3.0</version>
  <description>The ROS client library in C++.</description>

  <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
--- a/rclcpp/resource/logging.hpp.em
+++ b/rclcpp/resource/logging.hpp.em
@@ -124,7 +124,8 @@ def get_rclcpp_suffix_from_features(features):
 ) \
  do { \
    static_assert( \
-      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
+      ::std::is_same<typename std::remove_cv_t<typename std::remove_reference_t<decltype(logger)>>, \
+      typename ::rclcpp::Logger>::value, \
      "First argument to logging macros must be an rclcpp::Logger"); \
@[ if 'throttle' in feature_combination]@ \
    auto get_time_point = [&c=clock](rcutils_time_point_value_t * time_point) -> rcutils_ret_t { \
--- a/rclcpp/src/rclcpp/clock.cpp
+++ b/rclcpp/src/rclcpp/clock.cpp
@@ -118,7 +118,7 @@ Clock::sleep_until(
    });
  // No longer need the shutdown callback when this function exits
  auto callback_remover = rcpputils::scope_exit(
-    [&context, &shutdown_cb_handle]() {
+    [context, &shutdown_cb_handle]() {
      context->remove_on_shutdown_callback(shutdown_cb_handle);
    });

@@ -367,245 +367,4 @@ Clock::create_jump_callback(
  // *INDENT-ON*
 }

-class ClockWaiter::ClockWaiterImpl
-{
-private:
-  std::condition_variable cv_;
-
-  rclcpp::Clock::SharedPtr clock_;
-  bool time_source_changed_ = false;
-  std::function<void(const rcl_time_jump_t &)> post_time_jump_callback;
-
-  bool
-  wait_until_system_time(
-    std::unique_lock<std::mutex> & lock,
-    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
-  {
-    auto system_time = std::chrono::system_clock::time_point(
-    // Cast because system clock resolution is too big for nanoseconds on some systems
-    std::chrono::duration_cast<std::chrono::system_clock::duration>(
-        std::chrono::nanoseconds(abs_time.nanoseconds())));
-
-    return cv_.wait_until(lock, system_time, pred);
-  }
-
-  bool
-  wait_until_steady_time(
-    std::unique_lock<std::mutex> & lock,
-    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
-  {
-    // Synchronize because RCL steady clock epoch might differ from chrono::steady_clock epoch
-    const rclcpp::Time rcl_entry = clock_->now();
-    const std::chrono::steady_clock::time_point chrono_entry = std::chrono::steady_clock::now();
-    const rclcpp::Duration delta_t = abs_time - rcl_entry;
-    const std::chrono::steady_clock::time_point chrono_until =
-      chrono_entry + std::chrono::nanoseconds(delta_t.nanoseconds());
-
-    return cv_.wait_until(lock, chrono_until, pred);
-  }
-
-
-  bool
-  wait_until_ros_time(
-    std::unique_lock<std::mutex> & lock,
-    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
-  {
-    // Install jump handler for any amount of time change, for two purposes:
-    // - if ROS time is active, check if time reached on each new clock sample
-    // - Trigger via on_clock_change to detect if time source changes, to invalidate sleep
-    rcl_jump_threshold_t threshold;
-    threshold.on_clock_change = true;
-    // 0 is disable, so -1 and 1 are smallest possible time changes
-    threshold.min_backward.nanoseconds = -1;
-    threshold.min_forward.nanoseconds = 1;
-
-    time_source_changed_ = false;
-
-    post_time_jump_callback = [this, &lock] (const rcl_time_jump_t & jump)
-      {
-        if (jump.clock_change != RCL_ROS_TIME_NO_CHANGE) {
-          std::lock_guard<std::mutex> lk(*lock.mutex());
-          time_source_changed_ = true;
-        }
-        cv_.notify_one();
-      };
-
-    // Note this is a trade-off. Adding the callback for every call
-    // is expensive for high frequency calls. For low frequency waits
-    // its more overhead to have the callback being called all the time.
-    // As we expect the use case to be low frequency calls to wait_until
-    // with relative big pauses between the calls, we install it on demand.
-    auto clock_handler = clock_->create_jump_callback(
-      nullptr,
-      post_time_jump_callback,
-      threshold);
-
-    if (!clock_->ros_time_is_active()) {
-      auto system_time = std::chrono::system_clock::time_point(
-        // Cast because system clock resolution is too big for nanoseconds on some systems
-        std::chrono::duration_cast<std::chrono::system_clock::duration>(
-          std::chrono::nanoseconds(abs_time.nanoseconds())));
-
-      return cv_.wait_until(lock, system_time, [this, &pred] () {
-                 return time_source_changed_ || pred();
-      });
-    }
-
-    // RCL_ROS_TIME with ros_time_is_active.
-    // Just wait without "until" because installed
-    // jump callbacks wake the cv on every new sample.
-    cv_.wait(lock, [this, &pred, &abs_time] () {
-        return clock_->now() >= abs_time || time_source_changed_ || pred();
-    });
-
-    return clock_->now() < abs_time;
-  }
-
-public:
-  explicit ClockWaiterImpl(const rclcpp::Clock::SharedPtr & clock)
-  :clock_(clock)
-  {
-  }
-
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock,
-    const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
-  {
-    switch(clock_->get_clock_type()) {
-      case RCL_CLOCK_UNINITIALIZED:
-        throw std::runtime_error("Error, wait on uninitialized clock called");
-      case RCL_ROS_TIME:
-        return wait_until_ros_time(lock, abs_time, pred);
-        break;
-      case RCL_STEADY_TIME:
-        return wait_until_steady_time(lock, abs_time, pred);
-        break;
-      case RCL_SYSTEM_TIME:
-        return wait_until_system_time(lock, abs_time, pred);
-        break;
-    }
-
-    return false;
-  }
-
-  void
-  notify_one()
-  {
-    cv_.notify_one();
-  }
-};
-
-ClockWaiter::ClockWaiter(const rclcpp::Clock::SharedPtr & clock)
-:impl_(std::make_unique<ClockWaiterImpl>(clock))
-{
-}
-
-ClockWaiter::~ClockWaiter() = default;
-
-bool
-ClockWaiter::wait_until(
-  std::unique_lock<std::mutex> & lock,
-  const rclcpp::Time & abs_time, const std::function<bool ()> & pred)
-{
-  return impl_->wait_until(lock, abs_time, pred);
-}
-
-void
-ClockWaiter::notify_one()
-{
-  impl_->notify_one();
-}
-
-class ClockConditionalVariable::Impl
-{
-  std::mutex pred_mutex_;
-  bool shutdown_ = false;
-  rclcpp::Context::SharedPtr context_;
-  rclcpp::OnShutdownCallbackHandle shutdown_cb_handle_;
-  ClockWaiter::UniquePtr clock_;
-
-public:
-  Impl(const rclcpp::Clock::SharedPtr & clock, rclcpp::Context::SharedPtr context)
-  :context_(context),
-    clock_(std::make_unique<ClockWaiter>(clock))
-  {
-    if (!context_ || !context_->is_valid()) {
-      throw std::runtime_error("context cannot be slept with because it's invalid");
-    }
-    // Wake this thread if the context is shutdown
-    shutdown_cb_handle_ = context_->add_on_shutdown_callback(
-      [this]() {
-        {
-          std::unique_lock lock(pred_mutex_);
-          shutdown_ = true;
-        }
-        clock_->notify_one();
-    });
-  }
-
-  ~Impl()
-  {
-    context_->remove_on_shutdown_callback(shutdown_cb_handle_);
-  }
-
-  bool
-  wait_until(
-    std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-    const std::function<bool ()> & pred)
-  {
-    if(lock.mutex() != &pred_mutex_) {
-      throw std::runtime_error(
-          "ClockConditionalVariable::wait_until: Internal error, given lock does not use"
-          " mutex returned by this->mutex()");
-    }
-
-    clock_->wait_until(lock, until, [this, &pred] () -> bool {
-        return shutdown_ || pred();
-      });
-    return true;
-  }
-
-  void
-  notify_one()
-  {
-    clock_->notify_one();
-  }
-
-  std::mutex &
-  mutex()
-  {
-    return pred_mutex_;
-  }
-};
-
-ClockConditionalVariable::ClockConditionalVariable(
-  const rclcpp::Clock::SharedPtr & clock,
-  rclcpp::Context::SharedPtr context)
-:impl_(std::make_unique<Impl>(clock, context))
-{
-}
-
-ClockConditionalVariable::~ClockConditionalVariable() = default;
-
-void
-ClockConditionalVariable::notify_one()
-{
-  impl_->notify_one();
-}
-
-bool
-ClockConditionalVariable::wait_until(
-  std::unique_lock<std::mutex> & lock, rclcpp::Time until,
-  const std::function<bool ()> & pred)
-{
-  return impl_->wait_until(lock, until, pred);
-}
-
-std::mutex &
-ClockConditionalVariable::mutex()
-{
-  return impl_->mutex();
-}
-
 }  // namespace rclcpp
--- a/rclcpp/src/rclcpp/context.cpp
+++ b/rclcpp/src/rclcpp/context.cpp
@@ -14,7 +14,6 @@

 #include "rclcpp/context.hpp"

-#include <map>
 #include <memory>
 #include <mutex>
 #include <sstream>
@@ -143,52 +142,11 @@ rclcpp_logging_output_handler(
 }
 }  // extern "C"

-/**
- * Global storage for pre and post shutdown recursive mutexes.
- * Note, this is a ABI compatibility hack.
- */
-class MutexLookup
-{
-  std::mutex m;
-
-  struct MutexHolder
-  {
-    std::recursive_mutex on_shutdown_callbacks_mutex_;
-    std::recursive_mutex pre_shutdown_callbacks_mutex_;
-  };
-
-  std::map<const Context *, std::unique_ptr<MutexHolder>> mutexMap;
-
-public:
-  MutexHolder & getMutexes(const Context *forContext)
-  {
-    auto it = mutexMap.find(forContext);
-    if(it == mutexMap.end()) {
-      it = mutexMap.emplace(forContext, std::make_unique<MutexHolder>()).first;
-    }
-
-    return *(it->second);
-  }
-
-  /**
-   * Only supposed to be called on deletion of context
-   */
-  void removeMutexes(const Context *forContext)
-  {
-    mutexMap.erase(forContext);
-  }
-};
-
-MutexLookup mutexStorage;
-
 Context::Context()
 : rcl_context_(nullptr),
  shutdown_reason_(""),
  logging_mutex_(nullptr)
-{
-  // allocate mutexes
-  mutexStorage.getMutexes(this);
-}
+{}

 Context::~Context()
 {
@@ -207,9 +165,6 @@ Context::~Context()
  } catch (...) {
    RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "unhandled exception in ~Context()");
  }
-
-  // delete mutexes
-  mutexStorage.removeMutexes(this);
 }

 RCLCPP_LOCAL
@@ -356,17 +311,9 @@ Context::shutdown(const std::string & reason)

  // call each pre-shutdown callback
  {
-    std::lock_guard<std::recursive_mutex> lock{mutexStorage.getMutexes(
-        this).pre_shutdown_callbacks_mutex_};
-    // callbacks may delete other callbacks during the execution,
-    // therefore we need to save a copy and check before execution
-    // if the next callback is still present
-    auto cpy = pre_shutdown_callbacks_;
-    for (const auto & callback : cpy) {
-      auto it = std::find(pre_shutdown_callbacks_.begin(), pre_shutdown_callbacks_.end(), callback);
-      if(it != pre_shutdown_callbacks_.end()) {
-        (*callback)();
-      }
+    std::lock_guard<std::mutex> lock{pre_shutdown_callbacks_mutex_};
+    for (const auto & callback : pre_shutdown_callbacks_) {
+      (*callback)();
    }
  }

@@ -379,17 +326,9 @@ Context::shutdown(const std::string & reason)
  shutdown_reason_ = reason;
  // call each shutdown callback
  {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).on_shutdown_callbacks_mutex_);
-    // callbacks may delete other callbacks during the execution,
-    // therefore we need to save a copy and check before execution
-    // if the next callback is still present
-    auto cpy = on_shutdown_callbacks_;
-    for (const auto & callback : cpy) {
-      auto it = std::find(on_shutdown_callbacks_.begin(), on_shutdown_callbacks_.end(), callback);
-      if(it != on_shutdown_callbacks_.end()) {
-        (*callback)();
-      }
+    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
+    for (const auto & callback : on_shutdown_callbacks_) {
+      (*callback)();
    }
  }

@@ -460,12 +399,10 @@ Context::add_shutdown_callback(
    shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);

  if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).pre_shutdown_callbacks_mutex_);
+    std::lock_guard<std::mutex> lock(pre_shutdown_callbacks_mutex_);
    pre_shutdown_callbacks_.emplace_back(callback_shared_ptr);
  } else {
-    std::lock_guard<std::recursive_mutex> lock(mutexStorage.getMutexes(
-      this).on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
    on_shutdown_callbacks_.emplace_back(callback_shared_ptr);
  }

@@ -485,7 +422,7 @@ Context::remove_shutdown_callback(
  }

  const auto remove_callback = [&callback_shared_ptr](auto & mutex, auto & callback_vector) {
-      const std::lock_guard<std::recursive_mutex> lock(mutex);
+      const std::lock_guard<std::mutex> lock(mutex);
      auto iter = callback_vector.begin();
      for (; iter != callback_vector.end(); iter++) {
        if ((*iter).get() == callback_shared_ptr.get()) {
@@ -496,7 +433,6 @@ Context::remove_shutdown_callback(
        return false;
      }
      callback_vector.erase(iter);
-
      return true;
    };

@@ -504,11 +440,9 @@ Context::remove_shutdown_callback(
    shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);

  if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return remove_callback(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return remove_callback(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
  } else {
-    return remove_callback(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return remove_callback(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
  }
 }

@@ -529,7 +463,7 @@ std::vector<rclcpp::Context::ShutdownCallback>
 Context::get_shutdown_callback() const
 {
  const auto get_callback_vector = [](auto & mutex, auto & callback_set) {
-      const std::lock_guard<std::recursive_mutex> lock(mutex);
+      const std::lock_guard<std::mutex> lock(mutex);
      std::vector<rclcpp::Context::ShutdownCallback> callbacks;
      for (auto & callback : callback_set) {
        callbacks.push_back(*callback);
@@ -541,11 +475,9 @@ Context::get_shutdown_callback() const
    shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);

  if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    return get_callback_vector(mutexStorage.getMutexes(this).pre_shutdown_callbacks_mutex_,
-      pre_shutdown_callbacks_);
+    return get_callback_vector(pre_shutdown_callbacks_mutex_, pre_shutdown_callbacks_);
  } else {
-    return get_callback_vector(mutexStorage.getMutexes(this).on_shutdown_callbacks_mutex_,
-      on_shutdown_callbacks_);
+    return get_callback_vector(on_shutdown_callbacks_mutex_, on_shutdown_callbacks_);
  }
 }

--- a/rclcpp/src/rclcpp/executor.cpp
+++ b/rclcpp/src/rclcpp/executor.cpp
@@ -84,9 +84,7 @@ Executor::Executor(const rclcpp::ExecutorOptions & options)
  notify_waitable_->add_guard_condition(interrupt_guard_condition_);
  notify_waitable_->add_guard_condition(shutdown_guard_condition_);

-  // we need to initially rebuild the collection,
-  // so that the notify_waitable_ is added
-  collect_entities();
+  wait_set_.add_waitable(notify_waitable_);
 }

 Executor::~Executor()
@@ -277,7 +275,7 @@ Executor::spin_until_future_complete_impl(
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin_until_future_complete() called while already spinning");
  }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
  while (rclcpp::ok(this->context_) && spinning.load()) {
    // Do one item of work.
    spin_once_impl(timeout_left);
@@ -366,21 +364,14 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin_some() called while already spinning");
  }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );

  // clear the wait result and wait for work without blocking to collect the work
  // for the first time
  // both spin_some and spin_all wait for work at the beginning
  wait_result_.reset();
  wait_for_work(std::chrono::milliseconds(0));
-  bool entity_states_fully_polled = true;
-
-  if (entities_need_rebuild_) {
-    // if the last wait triggered a collection rebuild, we need to call
-    // wait_for_work once more, in order to do a collection rebuild and collect
-    // events from the just added entities
-    entity_states_fully_polled = false;
-  }
+  bool just_waited = true;

  // The logic of this while loop is as follows:
  //
@@ -402,14 +393,12 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
    AnyExecutable any_exec;
    if (get_next_ready_executable(any_exec)) {
      execute_any_executable(any_exec);
-      // during the execution some entity might got ready therefore we need
-      // to repoll the states of all entities
-      entity_states_fully_polled = false;
+      just_waited = false;
    } else {
      // if nothing is ready, reset the result to clear it
      wait_result_.reset();

-      if (entity_states_fully_polled) {
+      if (just_waited) {
        // there was no work after just waiting, always exit in this case
        // before the exhaustive condition can be checked
        break;
@@ -419,13 +408,7 @@ Executor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
        // if exhaustive, wait for work again
        // this only happens for spin_all; spin_some only waits at the start
        wait_for_work(std::chrono::milliseconds(0));
-        entity_states_fully_polled = true;
-        if (entities_need_rebuild_) {
-          // if the last wait triggered a collection rebuild, we need to call
-          // wait_for_work once more, in order to do a collection rebuild and
-          // collect events from the just added entities
-          entity_states_fully_polled = false;
-        }
+        just_waited = true;
      } else {
        break;
      }
@@ -448,7 +431,7 @@ Executor::spin_once(std::chrono::nanoseconds timeout)
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin_once() called while already spinning");
  }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
  spin_once_impl(timeout);
 }

@@ -746,33 +729,13 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
  // Clear any previous wait result
  this->wait_result_.reset();

-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
  {
    std::lock_guard<std::mutex> guard(mutex_);
-
    if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
      this->collect_entities();
    }
-
-    auto callback_groups = this->collector_.get_all_callback_groups();
-    cbgs.resize(callback_groups.size());
-    for(const auto & w_ptr : callback_groups) {
-      auto shr_ptr = w_ptr.lock();
-      if(shr_ptr) {
-        cbgs.push_back(std::move(shr_ptr));
-      }
-    }
  }
-
  this->wait_result_.emplace(wait_set_.wait(timeout));
-
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
  if (!this->wait_result_ || this->wait_result_->kind() == WaitResultKind::Empty) {
    RCUTILS_LOG_WARN_NAMED(
      "rclcpp",
--- a/rclcpp/src/rclcpp/executors/multi_threaded_executor.cpp
+++ b/rclcpp/src/rclcpp/executors/multi_threaded_executor.cpp
@@ -55,7 +55,7 @@ MultiThreadedExecutor::spin()
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin() called while already spinning");
  }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false););
  std::vector<std::thread> threads;
  size_t thread_id = 0;
  {
--- a/rclcpp/src/rclcpp/executors/single_threaded_executor.cpp
+++ b/rclcpp/src/rclcpp/executors/single_threaded_executor.cpp
@@ -30,7 +30,7 @@ SingleThreadedExecutor::spin()
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin() called while already spinning");
  }
-  RCPPUTILS_SCOPE_EXIT(wait_result_.reset();this->spinning.store(false););
+  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );

  // Clear any previous result and rebuild the waitset
  this->wait_result_.reset();
--- a/rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp
+++ b/rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp
@@ -110,29 +110,10 @@ StaticSingleThreadedExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
 std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
 StaticSingleThreadedExecutor::collect_and_wait(std::chrono::nanoseconds timeout)
 {
-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
  if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
    this->collect_entities();
  }
-
-  auto callback_groups = this->collector_.get_all_callback_groups();
-  cbgs.resize(callback_groups.size());
-  for(const auto & w_ptr : callback_groups) {
-    auto shr_ptr = w_ptr.lock();
-    if(shr_ptr) {
-      cbgs.push_back(std::move(shr_ptr));
-    }
-  }
-
  auto wait_result = wait_set_.wait(std::chrono::nanoseconds(timeout));
-
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
  if (wait_result.kind() == WaitResultKind::Empty) {
    RCUTILS_LOG_WARN_NAMED(
      "rclcpp",
--- a/rclcpp/src/rclcpp/experimental/executors/events_executor/events_executor.cpp
+++ b/rclcpp/src/rclcpp/experimental/executors/events_executor/events_executor.cpp
@@ -62,6 +62,7 @@ EventsExecutor::EventsExecutor(
      //    ---> we need to wake up the executor so that it can terminate
      // - a node or callback group guard condition is triggered:
      //    ---> the entities collection is changed, we need to update callbacks
+      notify_waitable_event_pushed_ = false;
      this->refresh_current_collection_from_callback_groups();
    });

@@ -163,14 +164,6 @@ EventsExecutor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhau
      return false;
    };

-  // If this spin is not exhaustive (e.g. spin_some), we need to explicitly check
-  // if entities need to be rebuilt here rather than letting the notify waitable event do it.
-  // A non-exhaustive spin would not check for work a second time, thus delaying the execution
-  // of some entities to the next invocation of spin.
-  if (!exhaustive) {
-    this->refresh_current_collection_from_callback_groups();
-  }
-
  // Get the number of events and timers ready at start
  const size_t ready_events_at_start = events_queue_->size();
  size_t executed_events = 0;
@@ -410,16 +403,6 @@ EventsExecutor::get_automatically_added_callback_groups_from_nodes()
 void
 EventsExecutor::refresh_current_collection_from_callback_groups()
 {
-  // Do not rebuild if we don't need to.
-  // A rebuild event could be generated, but then
-  // this function could end up being called from somewhere else
-  // before that event gets processed, for example if
-  // a node or callback group is manually added to the executor.
-  const bool notify_waitable_triggered = notify_waitable_event_pushed_.exchange(false);
-  if (!notify_waitable_triggered && !this->entities_collector_->has_pending()) {
-    return;
-  }
-
  // Build the new collection
  this->entities_collector_->update_collections();
  auto callback_groups = this->entities_collector_->get_all_callback_groups();
--- a/rclcpp/src/rclcpp/experimental/timers_manager.cpp
+++ b/rclcpp/src/rclcpp/experimental/timers_manager.cpp
@@ -273,22 +273,20 @@ void TimersManager::run_timers()
    if (!time_to_sleep.has_value() || (time_to_sleep.value() == std::chrono::nanoseconds::max()) ) {
      // Wait until notification that timers have been updated
      timers_cv_.wait(lock, [this]() {return timers_updated_;});
+
+      // Re-heap in case ordering changed due to a cancelled timer
+      // re-activating.
+      TimersHeap locked_heap = weak_timers_heap_.validate_and_lock();
+      locked_heap.heapify();
+      weak_timers_heap_.store(locked_heap);
    } else if (time_to_sleep.value() != std::chrono::nanoseconds::zero()) {
      // If time_to_sleep is zero, we immediately execute. Otherwise, wait
      // until timeout or notification that timers have been updated
      timers_cv_.wait_for(lock, time_to_sleep.value(), [this]() {return timers_updated_;});
    }

-    if (timers_updated_) {
-      // Re-heap in case ordering changed due to a cancelled timer
-      // re-activating.
-      TimersHeap locked_heap = weak_timers_heap_.validate_and_lock();
-      locked_heap.heapify();
-      weak_timers_heap_.store(locked_heap);
-
-      // Reset timers updated flag
-      timers_updated_ = false;
-    }
+    // Reset timers updated flag
+    timers_updated_ = false;

    // Execute timers
    this->execute_ready_timers_unsafe();
--- a/rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp
+++ b/rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp
@@ -65,11 +65,11 @@ public:
  : logger_(node_logging->get_logger()),
    node_base_(node_base)
  {
-    rclcpp::ParameterValue enable_param;
    const std::string enable_param_name = "start_type_description_service";

-    if (!node_parameters->has_parameter(enable_param_name)) {
-      enable_param = node_parameters->declare_parameter(
+    bool enabled = false;
+    try {
+      auto enable_param = node_parameters->declare_parameter(
        enable_param_name,
        rclcpp::ParameterValue(true),
        rcl_interfaces::msg::ParameterDescriptor()
@@ -77,21 +77,13 @@ public:
        .set__type(rclcpp::PARAMETER_BOOL)
        .set__description("Start the ~/get_type_description service for this node.")
        .set__read_only(true));
-    } else {
-      enable_param = node_parameters->get_parameter(enable_param_name).get_parameter_value();
-    }
-    if (enable_param.get_type() != rclcpp::PARAMETER_BOOL) {
-      RCLCPP_ERROR(
-        logger_,
-            "Invalid type '%s' for parameter 'start_type_description_service', should be 'bool'",
-        rclcpp::to_string(enable_param.get_type()).c_str());
-      std::ostringstream ss;
-      ss << "Wrong parameter type, parameter {" << enable_param_name << "} is of type {bool}, "
-         << "setting it to {" << to_string(enable_param.get_type()) << "} is not allowed.";
-      throw rclcpp::exceptions::InvalidParameterTypeException(enable_param_name, ss.str());
+      enabled = enable_param.get<bool>();
+    } catch (const rclcpp::exceptions::InvalidParameterTypeException & exc) {
+      RCLCPP_ERROR(logger_, "%s", exc.what());
+      throw;
    }

-    if (enable_param.get<bool>()) {
+    if (enabled) {
      auto * rcl_node = node_base->get_rcl_node_handle();
      std::shared_ptr<rcl_service_t> rcl_srv(
        new rcl_service_t,
--- a/rclcpp/src/rclcpp/node_options.cpp
+++ b/rclcpp/src/rclcpp/node_options.cpp
@@ -80,7 +80,6 @@ NodeOptions::operator=(const NodeOptions & other)
    this->clock_type_ = other.clock_type_;
    this->clock_qos_ = other.clock_qos_;
    this->use_clock_thread_ = other.use_clock_thread_;
-    this->enable_logger_service_ = other.enable_logger_service_;
    this->parameter_event_qos_ = other.parameter_event_qos_;
    this->rosout_qos_ = other.rosout_qos_;
    this->parameter_event_publisher_options_ = other.parameter_event_publisher_options_;
--- a/rclcpp/src/rclcpp/parameter_events_filter.cpp
+++ b/rclcpp/src/rclcpp/parameter_events_filter.cpp
@@ -28,9 +28,6 @@ ParameterEventsFilter::ParameterEventsFilter(
  const std::vector<EventType> & types)
 : event_(event)
 {
-  if (!event) {
-    throw std::invalid_argument("event cannot be null");
-  }
  if (std::find(types.begin(), types.end(), EventType::NEW) != types.end()) {
    for (auto & new_parameter : event->new_parameters) {
      if (std::find(names.begin(), names.end(), new_parameter.name) != names.end()) {
--- a/rclcpp/src/rclcpp/parameter_map.cpp
+++ b/rclcpp/src/rclcpp/parameter_map.cpp
@@ -81,15 +81,7 @@ rclcpp::parameter_map_from(const rcl_params_t * const c_params, const char * nod
        throw InvalidParametersException(message);
      }
      const rcl_variant_t * const c_param_value = &(c_params_node->parameter_values[p]);
-      ParameterValue value;
-      try {
-        value = parameter_value_from(c_param_value);
-      } catch (const InvalidParameterValueException & e) {
-        throw InvalidParameterValueException(
-          std::string("parameter_value_from failed for parameter '") +
-          c_param_name + "': " + e.what());
-      }
-      params_node.emplace_back(c_param_name, value);
+      params_node.emplace_back(c_param_name, parameter_value_from(c_param_value));
    }
  }

--- a/rclcpp/src/rclcpp/qos.cpp
+++ b/rclcpp/src/rclcpp/qos.cpp
@@ -69,10 +69,8 @@ QoSInitialization::from_rmw(const rmw_qos_profile_t & rmw_qos)
      return KeepLast(rmw_qos.depth, false);
    case RMW_QOS_POLICY_HISTORY_KEEP_LAST:
    case RMW_QOS_POLICY_HISTORY_UNKNOWN:
-      return KeepLast(rmw_qos.depth);
    default:
-      throw std::invalid_argument(
-        "Invalid history policy enum value passed to QoSInitialization::from_rmw");
+      return KeepLast(rmw_qos.depth);
  }
 }

--- a/rclcpp/src/rclcpp/serialization.cpp
+++ b/rclcpp/src/rclcpp/serialization.cpp
@@ -36,6 +36,7 @@ SerializationBase::SerializationBase(const rosidl_message_type_support_t * type_
 void SerializationBase::serialize_message(
  const void * ros_message, SerializedMessage * serialized_message) const
 {
+  rcpputils::check_true(nullptr != type_support_, "Typesupport is nullpointer.");
  rcpputils::check_true(nullptr != ros_message, "ROS message is nullpointer.");
  rcpputils::check_true(nullptr != serialized_message, "Serialized message is nullpointer.");

@@ -51,6 +52,7 @@ void SerializationBase::serialize_message(
 void SerializationBase::deserialize_message(
  const SerializedMessage * serialized_message, void * ros_message) const
 {
+  rcpputils::check_true(nullptr != type_support_, "Typesupport is nullpointer.");
  rcpputils::check_true(nullptr != serialized_message, "Serialized message is nullpointer.");
  rcpputils::check_true(
    0u != serialized_message->capacity(),
--- a/rclcpp/src/rclcpp/serialized_message.cpp
+++ b/rclcpp/src/rclcpp/serialized_message.cpp
@@ -26,13 +26,8 @@ namespace rclcpp

 inline void copy_rcl_message(const rcl_serialized_message_t & from, rcl_serialized_message_t & to)
 {
-  auto ret = RCL_RET_ERROR;
-  if (nullptr == to.buffer) {
-    ret = rmw_serialized_message_init(&to, from.buffer_capacity, &from.allocator);
-  } else {
-    ret = rmw_serialized_message_resize(&to, from.buffer_capacity);
-  }
-
+  const auto ret = rmw_serialized_message_init(
+    &to, from.buffer_capacity, &from.allocator);
  if (RCL_RET_OK != ret) {
    rclcpp::exceptions::throw_from_rcl_error(ret);
  }
@@ -83,6 +78,7 @@ SerializedMessage::SerializedMessage(rcl_serialized_message_t && other)
 SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other)
 {
  if (this != &other) {
+    serialized_message_ = rmw_get_zero_initialized_serialized_message();
    copy_rcl_message(other.serialized_message_, serialized_message_);
  }

@@ -92,6 +88,7 @@ SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other
 SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t & other)
 {
  if (&serialized_message_ != &other) {
+    serialized_message_ = rmw_get_zero_initialized_serialized_message();
    copy_rcl_message(other, serialized_message_);
  }

@@ -101,14 +98,6 @@ SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t
 SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 {
  if (this != &other) {
-    if (nullptr != serialized_message_.buffer) {
-      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
-      if (RCL_RET_OK != fini_ret) {
-        RCLCPP_ERROR(
-          get_logger("rclcpp"),
-          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
-      }
-    }
    serialized_message_ =
      std::exchange(other.serialized_message_, rmw_get_zero_initialized_serialized_message());
  }
@@ -119,14 +108,6 @@ SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 SerializedMessage & SerializedMessage::operator=(rcl_serialized_message_t && other)
 {
  if (&serialized_message_ != &other) {
-    if (nullptr != serialized_message_.buffer) {
-      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
-      if (RCL_RET_OK != fini_ret) {
-        RCLCPP_ERROR(
-          get_logger("rclcpp"),
-          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
-      }
-    }
    serialized_message_ =
      std::exchange(other, rmw_get_zero_initialized_serialized_message());
  }
--- a/rclcpp/src/rclcpp/time.cpp
+++ b/rclcpp/src/rclcpp/time.cpp
@@ -60,6 +60,10 @@ Time::Time(int32_t seconds, uint32_t nanoseconds, rcl_clock_type_t clock_type)
 Time::Time(int64_t nanoseconds, rcl_clock_type_t clock_type)
 : rcl_time_(init_time_point(clock_type))
 {
+  if (nanoseconds < 0) {
+    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
+  }
+
  rcl_time_.nanoseconds = nanoseconds;
 }

@@ -249,6 +253,9 @@ Time::operator+=(const rclcpp::Duration & rhs)
  }

  rcl_time_.nanoseconds += rhs.nanoseconds();
+  if (rcl_time_.nanoseconds < 0) {
+    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
+  }

  return *this;
 }
@@ -264,6 +271,9 @@ Time::operator-=(const rclcpp::Duration & rhs)
  }

  rcl_time_.nanoseconds -= rhs.nanoseconds();
+  if (rcl_time_.nanoseconds < 0) {
+    throw std::runtime_error("cannot store a negative time point in rclcpp::Time");
+  }

  return *this;
 }
--- a/rclcpp/src/rclcpp/typesupport_helpers.cpp
+++ b/rclcpp/src/rclcpp/typesupport_helpers.cpp
@@ -35,6 +35,62 @@ namespace rclcpp
 namespace
 {

+// Look for the library in the ament prefix paths.
+std::string get_typesupport_library_path(
+  const std::string & package_name, const std::string & typesupport_identifier)
+{
+  const char * dynamic_library_folder;
+#ifdef _WIN32
+  dynamic_library_folder = "/bin/";
+#elif __APPLE__
+  dynamic_library_folder = "/lib/";
+#else
+  dynamic_library_folder = "/lib/";
+#endif
+
+  std::string package_prefix;
+  try {
+    package_prefix = ament_index_cpp::get_package_prefix(package_name);
+  } catch (ament_index_cpp::PackageNotFoundError & e) {
+    throw std::runtime_error(e.what());
+  }
+
+  const std::string library_path = rcpputils::path_for_library(
+    package_prefix + dynamic_library_folder,
+    package_name + "__" + typesupport_identifier);
+  if (library_path.empty()) {
+    throw std::runtime_error(
+            "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
+            "'.");
+  }
+  return library_path;
+}
+
+std::tuple<std::string, std::string, std::string>
+extract_type_identifier(const std::string & full_type)
+{
+  char type_separator = '/';
+  auto sep_position_back = full_type.find_last_of(type_separator);
+  auto sep_position_front = full_type.find_first_of(type_separator);
+  if (sep_position_back == std::string::npos ||
+    sep_position_back == 0 ||
+    sep_position_back == full_type.length() - 1)
+  {
+    throw std::runtime_error(
+            "Message type is not of the form package/type and cannot be processed");
+  }
+
+  std::string package_name = full_type.substr(0, sep_position_front);
+  std::string middle_module = "";
+  if (sep_position_back - sep_position_front > 0) {
+    middle_module =
+      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
+  }
+  std::string type_name = full_type.substr(sep_position_back + 1);
+
+  return std::make_tuple(package_name, middle_module, type_name);
+}
+
 const void * get_typesupport_handle_impl(
  const std::string & type,
  const std::string & typesupport_identifier,
@@ -75,61 +131,6 @@ const void * get_typesupport_handle_impl(

 }  // anonymous namespace

-std::tuple<std::string, std::string, std::string>
-extract_type_identifier(const std::string & full_type)
-{
-  char type_separator = '/';
-  auto sep_position_back = full_type.find_last_of(type_separator);
-  auto sep_position_front = full_type.find_first_of(type_separator);
-  if (sep_position_back == std::string::npos ||
-    sep_position_back == 0 ||
-    sep_position_back == full_type.length() - 1)
-  {
-    throw std::runtime_error(
-      "Message type is not of the form package/type and cannot be processed");
-  }
-
-  std::string package_name = full_type.substr(0, sep_position_front);
-  std::string middle_module = "";
-  if (sep_position_back - sep_position_front > 0) {
-    middle_module =
-      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
-  }
-  std::string type_name = full_type.substr(sep_position_back + 1);
-
-  return std::make_tuple(package_name, middle_module, type_name);
-}
-
-std::string get_typesupport_library_path(
-  const std::string & package_name, const std::string & typesupport_identifier)
-{
-  const char * dynamic_library_folder;
-#ifdef _WIN32
-  dynamic_library_folder = "/bin/";
-#elif __APPLE__
-  dynamic_library_folder = "/lib/";
-#else
-  dynamic_library_folder = "/lib/";
-#endif
-
-  std::string package_prefix;
-  try {
-    package_prefix = ament_index_cpp::get_package_prefix(package_name);
-  } catch (ament_index_cpp::PackageNotFoundError & e) {
-    throw std::runtime_error(e.what());
-  }
-
-  const std::string library_path = rcpputils::path_for_library(
-    package_prefix + dynamic_library_folder,
-    package_name + "__" + typesupport_identifier);
-  if (library_path.empty()) {
-    throw std::runtime_error(
-      "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
-        "'.");
-  }
-  return library_path;
-}
-
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier)
 {
--- a/rclcpp/test/benchmark/benchmark_executor.cpp
+++ b/rclcpp/test/benchmark/benchmark_executor.cpp
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include <chrono>
 #include <memory>
 #include <string>
 #include <utility>
--- a/rclcpp/test/rclcpp/CMakeLists.txt
+++ b/rclcpp/test/rclcpp/CMakeLists.txt
@@ -31,6 +31,7 @@ endif()
 ament_add_gtest(
  test_exceptions
  exceptions/test_exceptions.cpp)
+ament_add_test_label(test_exceptions mimick)
 if(TARGET test_exceptions)
  target_link_libraries(test_exceptions ${PROJECT_NAME} mimick)
 endif()
@@ -52,18 +53,15 @@ if(TARGET test_any_subscription_callback)
  target_link_libraries(test_any_subscription_callback ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_client test_client.cpp)
+ament_add_test_label(test_client mimick)
 if(TARGET test_client)
  target_link_libraries(test_client ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_clock test_clock.cpp)
+ament_add_test_label(test_clock mimick)
 if(TARGET test_clock)
  target_link_libraries(test_clock ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
 endif()
-ament_add_gtest(test_clock_conditional test_clock_conditional.cpp)
-ament_add_test_label(test_clock_conditional mimick)
-if(TARGET test_clock_conditional)
-  target_link_libraries(test_clock_conditional ${PROJECT_NAME} mimick ${rcl_interfaces_TARGETS} ${test_msgs_TARGETS})
-endif()
 ament_add_gtest(test_copy_all_parameter_values test_copy_all_parameter_values.cpp)
 if(TARGET test_copy_all_parameter_values)
  target_link_libraries(test_copy_all_parameter_values ${PROJECT_NAME})
@@ -74,6 +72,7 @@ if(TARGET test_create_timer)
  target_include_directories(test_create_timer PRIVATE ./)
 endif()
 ament_add_gtest(test_generic_client test_generic_client.cpp)
+ament_add_test_label(test_generic_client mimick)
 if(TARGET test_generic_client)
  target_link_libraries(test_generic_client ${PROJECT_NAME}
    mimick
@@ -85,6 +84,7 @@ if(TARGET test_generic_client)
  )
 endif()
 ament_add_gtest(test_client_common test_client_common.cpp)
+ament_add_test_label(test_client_common mimick)
 if(TARGET test_client_common)
  target_link_libraries(test_client_common ${PROJECT_NAME}
    mimick
@@ -111,6 +111,7 @@ function(test_add_callback_groups_to_executor_for_rmw_implementation)
 endfunction()
 call_for_each_rmw_implementation(test_add_callback_groups_to_executor_for_rmw_implementation)
 ament_add_gtest(test_expand_topic_or_service_name test_expand_topic_or_service_name.cpp)
+ament_add_test_label(test_expand_topic_or_service_name mimick)
 if(TARGET test_expand_topic_or_service_name)
  target_link_libraries(test_expand_topic_or_service_name ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
 endif()
@@ -142,6 +143,7 @@ if(TARGET test_intra_process_buffer)
 endif()

 ament_add_gtest(test_loaned_message test_loaned_message.cpp)
+ament_add_test_label(test_loaned_message mimick)
 target_link_libraries(test_loaned_message ${PROJECT_NAME} mimick ${test_msgs_TARGETS})

 ament_add_gtest(test_memory_strategy test_memory_strategy.cpp)
@@ -151,6 +153,7 @@ ament_add_gtest(test_message_memory_strategy test_message_memory_strategy.cpp)
 target_link_libraries(test_message_memory_strategy ${PROJECT_NAME} ${test_msgs_TARGETS})

 ament_add_gtest(test_node test_node.cpp TIMEOUT 240)
+ament_add_test_label(test_node mimick)
 if(TARGET test_node)
  target_link_libraries(test_node ${PROJECT_NAME} mimick rcpputils::rcpputils rmw::rmw ${test_msgs_TARGETS})
 endif()
@@ -162,6 +165,7 @@ if(TARGET test_node_interfaces__get_node_interfaces)
 endif()
 ament_add_gtest(test_node_interfaces__node_base
  node_interfaces/test_node_base.cpp)
+ament_add_test_label(test_node_interfaces__node_base mimick)
 if(TARGET test_node_interfaces__node_base)
  target_link_libraries(test_node_interfaces__node_base ${PROJECT_NAME} mimick rcl::rcl rmw::rmw)
 endif()
@@ -173,6 +177,7 @@ endif()
 ament_add_gtest(test_node_interfaces__node_graph
  node_interfaces/test_node_graph.cpp
  TIMEOUT 120)
+ament_add_test_label(test_node_interfaces__node_graph mimick)
 if(TARGET test_node_interfaces__node_graph)
  target_link_libraries(test_node_interfaces__node_graph ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -183,21 +188,25 @@ if(TARGET test_node_interfaces__node_interfaces)
 endif()
 ament_add_gtest(test_node_interfaces__node_parameters
  node_interfaces/test_node_parameters.cpp)
+ament_add_test_label(test_node_interfaces__node_parameters mimick)
 if(TARGET test_node_interfaces__node_parameters)
  target_link_libraries(test_node_interfaces__node_parameters ${PROJECT_NAME} mimick rcpputils::rcpputils)
 endif()
 ament_add_gtest(test_node_interfaces__node_services
  node_interfaces/test_node_services.cpp)
+ament_add_test_label(test_node_interfaces__node_services mimick)
 if(TARGET test_node_interfaces__node_services)
  target_link_libraries(test_node_interfaces__node_services ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_node_interfaces__node_timers
  node_interfaces/test_node_timers.cpp)
+ament_add_test_label(test_node_interfaces__node_timers mimick)
 if(TARGET test_node_interfaces__node_timers)
  target_link_libraries(test_node_interfaces__node_timers ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_node_interfaces__node_topics
  node_interfaces/test_node_topics.cpp)
+ament_add_test_label(test_node_interfaces__node_topics mimick)
 if(TARGET test_node_interfaces__node_topics)
  target_link_libraries(test_node_interfaces__node_topics ${PROJECT_NAME} mimick rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -208,6 +217,7 @@ if(TARGET test_node_interfaces__node_type_descriptions)
 endif()
 ament_add_gtest(test_node_interfaces__node_waitables
  node_interfaces/test_node_waitables.cpp)
+ament_add_test_label(test_node_interfaces__node_waitables mimick)
 if(TARGET test_node_interfaces__node_waitables)
  target_link_libraries(test_node_interfaces__node_waitables ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -243,10 +253,12 @@ if(TARGET test_node_global_args)
  target_link_libraries(test_node_global_args ${PROJECT_NAME})
 endif()
 ament_add_gtest(test_node_options test_node_options.cpp)
+ament_add_test_label(test_node_options mimick)
 if(TARGET test_node_options)
  target_link_libraries(test_node_options ${PROJECT_NAME} mimick rcl::rcl)
 endif()
 ament_add_gtest(test_init_options test_init_options.cpp)
+ament_add_test_label(test_init_options mimick)
 if(TARGET test_init_options)
  target_link_libraries(test_init_options ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -275,6 +287,7 @@ if(TARGET test_parameter_map)
  target_link_libraries(test_parameter_map ${PROJECT_NAME} rcl::rcl rcl_yaml_param_parser::rcl_yaml_param_parser rcutils::rcutils)
 endif()
 ament_add_gtest(test_publisher test_publisher.cpp TIMEOUT 120)
+ament_add_test_label(test_publisher mimick)
 if(TARGET test_publisher)
  target_link_libraries(test_publisher ${PROJECT_NAME} mimick rcl::rcl rcutils::rcutils ${test_msgs_TARGETS})
 endif()
@@ -340,6 +353,7 @@ function(test_qos_event_for_rmw_implementation)
  ament_add_gmock(test_qos_event${target_suffix} test_qos_event.cpp
    ENV ${rmw_implementation_env_var}
  )
+  ament_add_test_label(test_qos_event${target_suffix} mimick)
  if(TARGET test_qos_event${target_suffix})
    target_link_libraries(test_qos_event${target_suffix} ${PROJECT_NAME} mimick rcutils::rcutils rmw::rmw ${test_msgs_TARGETS})
  endif()
@@ -367,15 +381,18 @@ if(TARGET test_serialized_message)
  target_link_libraries(test_serialized_message ${PROJECT_NAME} rcpputils::rcpputils ${test_msgs_TARGETS})
 endif()
 ament_add_gtest(test_service test_service.cpp)
+ament_add_test_label(test_service mimick)
 if(TARGET test_service)
  target_link_libraries(test_service ${PROJECT_NAME} mimick ${rcl_interfaces_TARGES} ${test_msgs_TARGETS})
 endif()
 ament_add_gmock(test_service_introspection test_service_introspection.cpp)
+ament_add_test_label(test_service_introspection mimick)
 if(TARGET test_service_introspection)
  target_link_libraries(test_service_introspection ${PROJECT_NAME} mimick ${service_msgs_TARGETS} ${test_msgs_TARGETS})
 endif()
 # Creating and destroying nodes is slow with Connext, so this needs larger timeout.
 ament_add_gtest(test_subscription test_subscription.cpp TIMEOUT 120)
+ament_add_test_label(test_subscription mimick)
 if(TARGET test_subscription)
  target_link_libraries(test_subscription ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -426,6 +443,7 @@ endif()

 ament_add_gtest(test_timer test_timer.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}")
+ament_add_test_label(test_timer mimick)
 if(TARGET test_timer)
  target_link_libraries(test_timer ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -444,6 +462,7 @@ endif()

 ament_add_gtest(test_utilities test_utilities.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}")
+ament_add_test_label(test_utilities mimick)
 if(TARGET test_utilities)
  target_link_libraries(test_utilities ${PROJECT_NAME} mimick rcl::rcl)
 endif()
@@ -467,12 +486,8 @@ endif()
 ament_add_gtest(
  test_executors
  executors/test_executors.cpp
-  executors/test_waitable.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}"
  TIMEOUT 180)
-if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND MSVC)
-  target_compile_options(test_executors PRIVATE "/bigobj")
-endif()
 if(TARGET test_executors)
  target_link_libraries(test_executors ${PROJECT_NAME} rcl::rcl ${test_msgs_TARGETS})
 endif()
@@ -504,28 +519,9 @@ if(TARGET test_executors)
  target_link_libraries(test_executors_intraprocess ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()

-ament_add_gtest(
-  test_executors_busy_waiting
-  executors/test_executors_busy_waiting.cpp
-  executors/test_waitable.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors_busy_waiting)
-  target_link_libraries(test_executors_busy_waiting ${PROJECT_NAME})
-endif()
-
-ament_add_gtest(
-  test_executors_warmup
-  executors/test_executors_warmup.cpp
-  executors/test_waitable.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}"
-  TIMEOUT 180)
-if(TARGET test_executors_warmup)
-  target_link_libraries(test_executors_warmup ${PROJECT_NAME} ${test_msgs_TARGETS})
-endif()
-
 ament_add_gtest(test_static_single_threaded_executor executors/test_static_single_threaded_executor.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}")
+ament_add_test_label(test_static_single_threaded_executor mimick)
 if(TARGET test_static_single_threaded_executor)
  target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -544,6 +540,7 @@ endif()

 ament_add_gtest(test_executor_notify_waitable executors/test_executor_notify_waitable.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}" TIMEOUT 120)
+ament_add_test_label(test_executor_notify_waitable mimick)
 if(TARGET test_executor_notify_waitable)
  target_link_libraries(test_executor_notify_waitable ${PROJECT_NAME} mimick rcpputils::rcpputils)
 endif()
@@ -561,6 +558,7 @@ endif()

 ament_add_gtest(test_guard_condition test_guard_condition.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}")
+ament_add_test_label(test_guard_condition mimick)
 if(TARGET test_guard_condition)
  target_link_libraries(test_guard_condition ${PROJECT_NAME} mimick)
 endif()
@@ -594,6 +592,7 @@ if(TARGET test_dynamic_storage)
 endif()

 ament_add_gtest(test_storage_policy_common wait_set_policies/test_storage_policy_common.cpp)
+ament_add_test_label(test_storage_policy_common mimick)
 if(TARGET test_storage_policy_common)
  target_link_libraries(test_storage_policy_common ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
 endif()
@@ -626,11 +625,13 @@ endif()
 ament_add_gtest(test_executor test_executor.cpp
  APPEND_LIBRARY_DIRS "${append_library_dirs}"
  TIMEOUT 120)
+ament_add_test_label(test_executor mimick)
 if(TARGET test_executor)
-  target_link_libraries(test_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
+  target_link_libraries(test_executor ${PROJECT_NAME} mimick)
 endif()

 ament_add_gtest(test_graph_listener test_graph_listener.cpp)
+ament_add_test_label(test_graph_listener mimick)
 if(TARGET test_graph_listener)
  target_link_libraries(test_graph_listener ${PROJECT_NAME} mimick)
 endif()
@@ -642,6 +643,7 @@ function(test_subscription_content_filter_for_rmw_implementation)
    ENV ${rmw_implementation_env_var}
    TIMEOUT 120
  )
+  ament_add_test_label(test_subscription_content_filter${target_suffix} mimick)
  if(TARGET test_subscription_content_filter${target_suffix})
    target_link_libraries(test_subscription_content_filter${target_suffix} ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
  endif()
--- a/rclcpp/test/rclcpp/executors/test_events_queue.cpp
+++ b/rclcpp/test/rclcpp/executors/test_events_queue.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <memory>

 #include "rclcpp/experimental/executors/events_executor/events_executor_event_types.hpp"
--- a/rclcpp/test/rclcpp/executors/test_executor_notify_waitable.cpp
+++ b/rclcpp/test/rclcpp/executors/test_executor_notify_waitable.cpp
@@ -76,7 +76,8 @@ TEST_F(TestExecutorNotifyWaitable, wait) {
    std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(on_execute_callback);

  auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");
-  auto notify_guard_condition = std::make_shared<rclcpp::GuardCondition>();
+  auto notify_guard_condition =
+    node->get_node_base_interface()->get_shared_notify_guard_condition();
  EXPECT_NO_THROW(waitable->add_guard_condition(notify_guard_condition));

  auto default_cbg = node->get_node_base_interface()->get_default_callback_group();
@@ -85,15 +86,12 @@ TEST_F(TestExecutorNotifyWaitable, wait) {
  auto waitables = node->get_node_waitables_interface();
  waitables->add_waitable(std::static_pointer_cast<rclcpp::Waitable>(waitable), default_cbg);

-  // notify the guard condition, this should trigger the on_execute_callback
-  notify_guard_condition->trigger();
-
  rclcpp::executors::SingleThreadedExecutor executor;
  executor.add_node(node);
  executor.spin_all(std::chrono::seconds(1));
  EXPECT_EQ(1u, on_execute_calls);

-  // no further trigger, therefore no further callback
+  // on_execute_callback doesn't change if the topology doesn't change
  executor.spin_all(std::chrono::seconds(1));
  EXPECT_EQ(1u, on_execute_calls);
 }
--- a/rclcpp/test/rclcpp/executors/test_executors.cpp
+++ b/rclcpp/test/rclcpp/executors/test_executors.cpp
@@ -39,10 +39,8 @@
 #include "rclcpp/time_source.hpp"

 #include "test_msgs/msg/empty.hpp"
-#include "test_msgs/srv/empty.hpp"

 #include "./executor_types.hpp"
-#include "./test_waitable.hpp"

 using namespace std::chrono_literals;

@@ -333,6 +331,114 @@ TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteWithTimeout)
  spinner.join();
 }

+class TestWaitable : public rclcpp::Waitable
+{
+public:
+  TestWaitable() = default;
+
+  void
+  add_to_wait_set(rcl_wait_set_t & wait_set) override
+  {
+    if (trigger_count_ > 0) {
+      // Keep the gc triggered until the trigger count is reduced back to zero.
+      // This is necessary if trigger() results in the wait set waking, but not
+      // executing this waitable, in which case it needs to be re-triggered.
+      gc_.trigger();
+    }
+    rclcpp::detail::add_guard_condition_to_rcl_wait_set(wait_set, gc_);
+  }
+
+  void trigger()
+  {
+    trigger_count_++;
+    gc_.trigger();
+  }
+
+  bool
+  is_ready(const rcl_wait_set_t & wait_set) override
+  {
+    is_ready_count_++;
+    for (size_t i = 0; i < wait_set.size_of_guard_conditions; ++i) {
+      auto rcl_guard_condition = wait_set.guard_conditions[i];
+      if (&gc_.get_rcl_guard_condition() == rcl_guard_condition) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  std::shared_ptr<void>
+  take_data() override
+  {
+    return nullptr;
+  }
+
+  std::shared_ptr<void>
+  take_data_by_entity_id(size_t id) override
+  {
+    (void) id;
+    return nullptr;
+  }
+
+  void
+  execute(const std::shared_ptr<void> &) override
+  {
+    trigger_count_--;
+    count_++;
+    if (nullptr != on_execute_callback_) {
+      on_execute_callback_();
+    } else {
+      // TODO(wjwwood): I don't know why this was here, but probably it should
+      //   not be there, or test cases where that is important should use the
+      //   on_execute_callback?
+      std::this_thread::sleep_for(3ms);
+    }
+  }
+
+  void
+  set_on_execute_callback(std::function<void()> on_execute_callback)
+  {
+    on_execute_callback_ = on_execute_callback;
+  }
+
+  void
+  set_on_ready_callback(std::function<void(size_t, int)> callback) override
+  {
+    auto gc_callback = [callback](size_t count) {
+        callback(count, 0);
+      };
+    gc_.set_on_trigger_callback(gc_callback);
+  }
+
+  void
+  clear_on_ready_callback() override
+  {
+    gc_.set_on_trigger_callback(nullptr);
+  }
+
+  size_t
+  get_number_of_ready_guard_conditions() override {return 1;}
+
+  size_t
+  get_count() const
+  {
+    return count_;
+  }
+
+  size_t
+  get_is_ready_call_count() const
+  {
+    return is_ready_count_;
+  }
+
+private:
+  std::atomic<size_t> trigger_count_ = 0;
+  std::atomic<size_t> is_ready_count_ = 0;
+  std::atomic<size_t> count_ = 0;
+  rclcpp::GuardCondition gc_;
+  std::function<void()> on_execute_callback_ = nullptr;
+};
+
 TYPED_TEST(TestExecutors, spinAll)
 {
  using ExecutorType = TypeParam;
@@ -388,7 +494,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, spinSome)
+TYPED_TEST(TestExecutors, spin_some)
 {
  using ExecutorType = TypeParam;

@@ -480,7 +586,7 @@ TYPED_TEST(TestExecutors, spinSome)

 // The purpose of this test is to check that the ExecutorT.spin_some() method:
 //   - does not continue executing after max_duration has elapsed
-TYPED_TEST(TestExecutors, spinSomeMaxDuration)
+TYPED_TEST(TestExecutors, spin_some_max_duration)
 {
  using ExecutorType = TypeParam;

@@ -647,6 +753,13 @@ TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteInterrupted)
 TYPED_TEST(TestExecutors, testRaceConditionAddNode)
 {
  using ExecutorType = TypeParam;
+  // rmw_connextdds doesn't support events-executor
+  if (
+    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
+    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
+  {
+    GTEST_SKIP();
+  }

  // Spawn some threads to do some heavy work
  std::atomic<bool> should_cancel = false;
@@ -765,332 +878,154 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
  rclcpp::shutdown(non_default_context);
 }

-TYPED_TEST(TestExecutors, releaseOwnershipEntityAfterSpinningCancel)
+template<typename T>
+class TestBusyWaiting : public ::testing::Test
 {
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
+public:
+  void SetUp() override
+  {
+    rclcpp::init(0, nullptr);

-  auto future = std::async(std::launch::async, [&executor] {executor.spin();});
+    const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
+    std::stringstream test_name;
+    test_name << test_info->test_case_name() << "_" << test_info->name();
+    node = std::make_shared<rclcpp::Node>("node", test_name.str());
+    callback_group = node->create_callback_group(
+      rclcpp::CallbackGroupType::MutuallyExclusive,
+      /* automatically_add_to_executor_with_node =*/ false);

-  auto node = std::make_shared<rclcpp::Node>("test_node");
-  auto callback = [](
-    const test_msgs::srv::Empty::Request::SharedPtr, test_msgs::srv::Empty::Response::SharedPtr) {
-    };
-  auto server = node->create_service<test_msgs::srv::Empty>("test_service", callback);
-  while (!executor.is_spinning()) {
-    std::this_thread::sleep_for(50ms);
+    auto waitable_interfaces = node->get_node_waitables_interface();
+    waitable = std::make_shared<TestWaitable>();
+    waitable_interfaces->add_waitable(waitable, callback_group);
+
+    executor = std::make_shared<T>();
+    executor->add_callback_group(callback_group, node->get_node_base_interface());
  }
-  executor.add_node(node);
-  std::this_thread::sleep_for(50ms);
-  executor.cancel();
-  std::future_status future_status = future.wait_for(1s);
-  EXPECT_EQ(future_status, std::future_status::ready);

-  EXPECT_EQ(server.use_count(), 1);
+  void TearDown() override
+  {
+    rclcpp::shutdown();
+  }
+
+  void
+  set_up_and_trigger_waitable(std::function<void()> extra_callback = nullptr)
+  {
+    this->has_executed = false;
+    this->waitable->set_on_execute_callback([this, extra_callback]() {
+        if (!this->has_executed) {
+        // trigger once to see if the second trigger is handled or not
+        // this follow up trigger simulates new entities becoming ready while
+        // the executor is executing something else, e.g. subscription got data
+        // or a timer expired, etc.
+        // spin_some would not handle this second trigger, since it collects
+        // work only once, whereas spin_all should handle it since it
+        // collects work multiple times
+          this->waitable->trigger();
+          this->has_executed = true;
+        }
+        if (nullptr != extra_callback) {
+          extra_callback();
+        }
+    });
+    this->waitable->trigger();
+  }
+
+  void
+  check_for_busy_waits(std::chrono::steady_clock::time_point start_time)
+  {
+    // rough time based check, since the work to be done was very small it
+    // should be safe to check that we didn't use more than half the
+    // max duration, which itself is much larger than necessary
+    // however, it could still produce a false-positive
+    EXPECT_LT(
+      std::chrono::steady_clock::now() - start_time,
+      max_duration / 2)
+      << "executor took a long time to execute when it should have done "
+      << "nothing and should not have blocked either, but this could be a "
+      << "false negative if the computer is really slow";
+
+    // this check is making some assumptions about the implementation of the
+    // executors, but it should be safe to say that a busy wait may result in
+    // hundreds or thousands of calls to is_ready(), but "normal" executor
+    // behavior should be within an order of magnitude of the number of
+    // times that the waitable was executed
+    ASSERT_LT(waitable->get_is_ready_call_count(), 10u * this->waitable->get_count());
+  }
+
+  static constexpr auto max_duration = 10s;
+
+  rclcpp::Node::SharedPtr node;
+  rclcpp::CallbackGroup::SharedPtr callback_group;
+  std::shared_ptr<TestWaitable> waitable;
+  std::chrono::steady_clock::time_point start_time;
+  std::shared_ptr<T> executor;
+  bool has_executed;
+};
+
+TYPED_TEST_SUITE(TestBusyWaiting, ExecutorTypes, ExecutorTypeNames);
+
+TYPED_TEST(TestBusyWaiting, test_spin_all)
+{
+  this->set_up_and_trigger_waitable();
+
+  auto start_time = std::chrono::steady_clock::now();
+  this->executor->spin_all(this->max_duration);
+  this->check_for_busy_waits(start_time);
+  // this should get the initial trigger, and the follow up from in the callback
+  ASSERT_EQ(this->waitable->get_count(), 2u);
 }

-TYPED_TEST(TestExecutors, testRaceDropCallbackGroupFromSecondThread)
+TYPED_TEST(TestBusyWaiting, test_spin_some)
 {
-  using ExecutorType = TypeParam;
+  this->set_up_and_trigger_waitable();

-  // Create an executor
-  ExecutorType executor;
-  executor.add_node(this->node);
+  auto start_time = std::chrono::steady_clock::now();
+  this->executor->spin_some(this->max_duration);
+  this->check_for_busy_waits(start_time);
+  // this should get the inital trigger, but not the follow up in the callback
+  ASSERT_EQ(this->waitable->get_count(), 1u);
+}

-  // Start spinning
-  auto executor_thread = std::thread(
-    [&executor]() {
-      executor.spin();
+TYPED_TEST(TestBusyWaiting, test_spin)
+{
+  std::condition_variable cv;
+  std::mutex cv_m;
+  bool first_check_passed = false;
+
+  this->set_up_and_trigger_waitable([&cv, &cv_m, &first_check_passed]() {
+      cv.notify_one();
+      if (!first_check_passed) {
+        std::unique_lock<std::mutex> lk(cv_m);
+        cv.wait_for(lk, 1s, [&]() {return first_check_passed;});
+      }
+  });
+
+  auto start_time = std::chrono::steady_clock::now();
+  std::thread t([this]() {
+      this->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);
-    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
-    std::this_thread::sleep_for(5ms);
-
-    // At this point the callbackgroup should be used within the waitset of the executor
-    // as we leave the scope, the reference to cg will be dropped.
-    // If the executor has a race, we will experience a segfault at this point.
+  // wait until thread has started (first execute of waitable)
+  {
+    std::unique_lock<std::mutex> lk(cv_m);
+    cv.wait_for(lk, 10s);
  }
+  EXPECT_GT(this->waitable->get_count(), 0u);

-  executor.cancel();
-  executor_thread.join();
-}
-
-TYPED_TEST(TestExecutors, dropSomeTimer)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-  auto node = std::make_shared<rclcpp::Node>("test_node");
-
-  bool timer1_works = false;
-  bool timer2_works = false;
-
-  auto timer1 = node->create_timer(std::chrono::milliseconds(10), [&timer1_works]() {
-        timer1_works = true;
-  });
-  auto timer2 = node->create_timer(std::chrono::milliseconds(10), [&timer2_works]() {
-        timer2_works = true;
-  });
-
-  executor.add_node(node);
-
-  // first let's make sure that both timers work
-  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!timer1_works || !timer2_works) {
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  // delete timer 2. Note, the executor uses an unordered map internally, to order
-  // the entities added to the rcl waitset therefore the order is kind of undefined,
-  // and this test may be flaky. In case it triggers, something is most likely
-  // really broken.
-  timer2.reset();
-
-  timer1_works = false;
-  timer2_works = false;
-  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!timer1_works && !timer2_works) {
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  ASSERT_TRUE(timer1_works || timer2_works);
-}
-
-TYPED_TEST(TestExecutors, dropSomeNodeWithTimer)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-  auto node1 = std::make_shared<rclcpp::Node>("test_node_1");
-  auto node2 = std::make_shared<rclcpp::Node>("test_node_2");
-
-  bool timer1_works = false;
-  bool timer2_works = false;
-
-  auto timer1 = node1->create_timer(std::chrono::milliseconds(10), [&timer1_works]() {
-        timer1_works = true;
-  });
-  auto timer2 = node2->create_timer(std::chrono::milliseconds(10), [&timer2_works]() {
-        timer2_works = true;
-  });
-
-  executor.add_node(node1);
-  executor.add_node(node2);
-
-  // first let's make sure that both timers work
-  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!timer1_works || !timer2_works) {
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  // delete node 1.
-  node1 = nullptr;
-
-  timer2_works = false;
-  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!timer2_works) {
-    // let the executor pick up the node and the timer
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  ASSERT_TRUE(timer2_works);
-}
-
-TYPED_TEST(TestExecutors, dropSomeSubscription)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-  auto node = std::make_shared<rclcpp::Node>("test_node");
-
-  bool sub1_works = false;
-  bool sub2_works = false;
-
-  auto sub1 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub1_works](const test_msgs::msg::Empty &) {
-        sub1_works = true;
-  });
-  auto sub2 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub2_works](const test_msgs::msg::Empty &) {
-        sub2_works = true;
-  });
-
-  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
-
-  executor.add_node(node);
-
-  // first let's make sure that both timers work
-  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!sub1_works || !sub2_works) {
-    pub->publish(test_msgs::msg::Empty());
-
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  // delete subscription 2. Note, the executor uses an unordered map internally, to order
-  // the entities added to the rcl waitset therefore the order is kind of undefined,
-  // and this test may be flaky. In case it triggers, something is most likely
-  // really broken.
-  sub2.reset();
-
-  sub1_works = false;
-  sub2_works = false;
-  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!sub1_works && !sub2_works) {
-    pub->publish(test_msgs::msg::Empty());
-
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  ASSERT_TRUE(sub1_works || sub2_works);
-}
-
-TYPED_TEST(TestExecutors, dropSomeNodesWithSubscription)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-  auto node = std::make_shared<rclcpp::Node>("test_node");
-  auto node1 = std::make_shared<rclcpp::Node>("test_node_1");
-  auto node2 = std::make_shared<rclcpp::Node>("test_node_2");
-
-  bool sub1_works = false;
-  bool sub2_works = false;
-
-  auto sub1 = node1->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub1_works](const test_msgs::msg::Empty &) {
-        sub1_works = true;
-  });
-  auto sub2 = node2->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub2_works](const test_msgs::msg::Empty &) {
-        sub2_works = true;
-  });
-
-  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
-
-  executor.add_node(node);
-  executor.add_node(node1);
-  executor.add_node(node2);
-
-  // first let's make sure that both subscribers work
-  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!sub1_works || !sub2_works) {
-    pub->publish(test_msgs::msg::Empty());
-
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  // delete node 2.
-  node2 = nullptr;
-
-  sub1_works = false;
-  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while(!sub1_works) {
-    pub->publish(test_msgs::msg::Empty());
-
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  ASSERT_TRUE(sub1_works);
-}
-
-TYPED_TEST(TestExecutors, dropSubscriptionDuringCallback)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-
-  auto node = std::make_shared<rclcpp::Node>("test_node");
-
-  bool sub1_works = false;
-  bool sub2_works = false;
-
-  auto cbg = node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive, true);
-  rclcpp::SubscriptionOptions sub_ops;
-  sub_ops.callback_group = cbg;
-
-  rclcpp::SubscriptionBase::SharedPtr sub1;
-  rclcpp::SubscriptionBase::SharedPtr sub2;
-
-  // Note, the executor uses an unordered map internally, to order
-  // the entities added to the rcl waitset therefore the order of the subscriptions
-  // is kind of undefined. Therefore each sub deletes the other one.
-  sub1 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub1_works, &sub2](const test_msgs::msg::Empty &) {
-        sub1_works = true;
-        // delete the other subscriber
-        sub2.reset();
-  }, sub_ops);
-  sub2 = node->create_subscription<test_msgs::msg::Empty>("/test_drop", 10,
-      [&sub2_works, &sub1](const test_msgs::msg::Empty &) {
-        sub2_works = true;
-        // delete the other subscriber
-        sub1.reset();
-  }, sub_ops);
-
-  auto pub = node->create_publisher<test_msgs::msg::Empty>("/test_drop", 10);
-
-  // wait for both subs to be connected
-  auto max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(1500);
-  while ((sub1->get_publisher_count() == 0) || (sub2->get_publisher_count() == 0)) {
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  executor.add_node(node);
-
-  // publish some messages, until one subscriber fired. As both subscribers are
-  // connected to the same topic, they should fire in the same wait.
-  max_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
-  while (!sub1_works && !sub2_works) {
-    pub->publish(test_msgs::msg::Empty());
-
-    // let the executor pick up the node and the timers
-    executor.spin_all(std::chrono::milliseconds(10));
-
-    const auto cur_time = std::chrono::steady_clock::now();
-    ASSERT_LT(cur_time, max_end_time);
-  }
-
-  // only one subscriber must have worked, as the other
-  // one was deleted during the callback
-  ASSERT_TRUE(!sub1_works || !sub2_works);
+  first_check_passed = true;
+  cv.notify_one();
+
+  // wait until the executor has finished (second execute of waitable)
+  {
+    std::unique_lock<std::mutex> lk(cv_m);
+    cv.wait_for(lk, 10s);
+  }
+  EXPECT_EQ(this->waitable->get_count(), 2u);
+
+  this->executor->cancel();
+  t.join();
+
+  this->check_for_busy_waits(start_time);
+  // this should get the initial trigger, and the follow up from in the callback
+  ASSERT_EQ(this->waitable->get_count(), 2u);
 }
--- a/rclcpp/test/rclcpp/executors/test_executors_busy_waiting.cpp
+++ b/rclcpp/test/rclcpp/executors/test_executors_busy_waiting.cpp
@@ -1,181 +0,0 @@
-// Copyright 2024 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 <gtest/gtest.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <sstream>
-#include <thread>
-
-#include "rclcpp/rclcpp.hpp"
-
-#include "./executor_types.hpp"
-#include "./test_waitable.hpp"
-
-using namespace std::chrono_literals;
-
-template<typename T>
-class TestBusyWaiting : public ::testing::Test
-{
-public:
-  void SetUp() override
-  {
-    rclcpp::init(0, nullptr);
-
-    const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
-    std::stringstream test_name;
-    test_name << test_info->test_case_name() << "_" << test_info->name();
-    node = std::make_shared<rclcpp::Node>("node", test_name.str());
-    callback_group = node->create_callback_group(
-      rclcpp::CallbackGroupType::MutuallyExclusive,
-      /* automatically_add_to_executor_with_node =*/ false);
-
-    auto waitable_interfaces = node->get_node_waitables_interface();
-    waitable = std::make_shared<TestWaitable>();
-    waitable_interfaces->add_waitable(waitable, callback_group);
-
-    executor = std::make_shared<T>();
-    executor->add_callback_group(callback_group, node->get_node_base_interface());
-  }
-
-  void TearDown() override
-  {
-    rclcpp::shutdown();
-  }
-
-  void
-  set_up_and_trigger_waitable(std::function<void()> extra_callback = nullptr)
-  {
-    this->has_executed = false;
-    this->waitable->set_on_execute_callback([this, extra_callback]() {
-        if (!this->has_executed) {
-        // trigger once to see if the second trigger is handled or not
-        // this follow up trigger simulates new entities becoming ready while
-        // the executor is executing something else, e.g. subscription got data
-        // or a timer expired, etc.
-        // spin_some would not handle this second trigger, since it collects
-        // work only once, whereas spin_all should handle it since it
-        // collects work multiple times
-          this->waitable->trigger();
-          this->has_executed = true;
-        }
-        if (nullptr != extra_callback) {
-          extra_callback();
-        }
-    });
-    this->waitable->trigger();
-  }
-
-  void
-  check_for_busy_waits(std::chrono::steady_clock::time_point start_time)
-  {
-    // rough time based check, since the work to be done was very small it
-    // should be safe to check that we didn't use more than half the
-    // max duration, which itself is much larger than necessary
-    // however, it could still produce a false-positive
-    EXPECT_LT(
-      std::chrono::steady_clock::now() - start_time,
-      max_duration / 2)
-      << "executor took a long time to execute when it should have done "
-      << "nothing and should not have blocked either, but this could be a "
-      << "false negative if the computer is really slow";
-
-    // this check is making some assumptions about the implementation of the
-    // executors, but it should be safe to say that a busy wait may result in
-    // hundreds or thousands of calls to is_ready(), but "normal" executor
-    // behavior should be within an order of magnitude of the number of
-    // times that the waitable was executed
-    ASSERT_LT(waitable->get_is_ready_call_count(), 10u * this->waitable->get_count());
-  }
-
-  static constexpr auto max_duration = 10s;
-
-  rclcpp::Node::SharedPtr node;
-  rclcpp::CallbackGroup::SharedPtr callback_group;
-  std::shared_ptr<TestWaitable> waitable;
-  std::chrono::steady_clock::time_point start_time;
-  std::shared_ptr<T> executor;
-  bool has_executed;
-};
-
-TYPED_TEST_SUITE(TestBusyWaiting, ExecutorTypes, ExecutorTypeNames);
-
-TYPED_TEST(TestBusyWaiting, test_spin_all)
-{
-  this->set_up_and_trigger_waitable();
-
-  auto start_time = std::chrono::steady_clock::now();
-  this->executor->spin_all(this->max_duration);
-  this->check_for_busy_waits(start_time);
-  // this should get the initial trigger, and the follow up from in the callback
-  ASSERT_EQ(this->waitable->get_count(), 2u);
-}
-
-TYPED_TEST(TestBusyWaiting, test_spin_some)
-{
-  this->set_up_and_trigger_waitable();
-
-  auto start_time = std::chrono::steady_clock::now();
-  this->executor->spin_some(this->max_duration);
-  this->check_for_busy_waits(start_time);
-  // this should get the inital trigger, but not the follow up in the callback
-  ASSERT_EQ(this->waitable->get_count(), 1u);
-}
-
-TYPED_TEST(TestBusyWaiting, test_spin)
-{
-  std::condition_variable cv;
-  std::mutex cv_m;
-  bool first_check_passed = false;
-
-  this->set_up_and_trigger_waitable([&cv, &cv_m, &first_check_passed]() {
-      cv.notify_one();
-      if (!first_check_passed) {
-        std::unique_lock<std::mutex> lk(cv_m);
-        cv.wait_for(lk, 1s, [&]() {return first_check_passed;});
-      }
-  });
-
-  auto start_time = std::chrono::steady_clock::now();
-  std::thread t([this]() {
-      this->executor->spin();
-    });
-
-  // wait until thread has started (first execute of waitable)
-  {
-    std::unique_lock<std::mutex> lk(cv_m);
-    cv.wait_for(lk, 10s);
-  }
-  EXPECT_GT(this->waitable->get_count(), 0u);
-
-  first_check_passed = true;
-  cv.notify_one();
-
-  // wait until the executor has finished (second execute of waitable)
-  {
-    std::unique_lock<std::mutex> lk(cv_m);
-    cv.wait_for(lk, 10s);
-  }
-  EXPECT_EQ(this->waitable->get_count(), 2u);
-
-  this->executor->cancel();
-  t.join();
-
-  this->check_for_busy_waits(start_time);
-  // this should get the initial trigger, and the follow up from in the callback
-  ASSERT_EQ(this->waitable->get_count(), 2u);
-}
--- a/rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp
+++ b/rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp
@@ -267,15 +267,12 @@ public:

  void TearDown()
  {
-    executor.cancel();
+    node.reset();

    // Clean up thread object
    if (standalone_thread.joinable()) {
      standalone_thread.join();
    }
-
-    node.reset();
-    sim_clock_node.reset();
  }

  std::shared_ptr<TimerNode> node;
@@ -305,6 +302,7 @@ TYPED_TEST(TestTimerCancelBehavior, testTimer1CancelledWithExecutorSpin) {
  this->sim_clock_node->sleep_for(50ms);
  this->node->CancelTimer1();
  this->sim_clock_node->sleep_for(150ms);
+  this->executor.cancel();

  int t1_runs = this->node->GetTimer1Cnt();
  int t2_runs = this->node->GetTimer2Cnt();
@@ -322,6 +320,7 @@ TYPED_TEST(TestTimerCancelBehavior, testTimer2CancelledWithExecutorSpin) {
  this->sim_clock_node->sleep_for(50ms);
  this->node->CancelTimer2();
  this->sim_clock_node->sleep_for(150ms);
+  this->executor.cancel();

  int t1_runs = this->node->GetTimer1Cnt();
  int t2_runs = this->node->GetTimer2Cnt();
@@ -348,6 +347,8 @@ TYPED_TEST(TestTimerCancelBehavior, testHeadTimerCancelThenResetBehavior) {
  int t1_runs_final = this->node->GetTimer1Cnt();
  int t2_runs_final = this->node->GetTimer2Cnt();

+  this->executor.cancel();
+
  // T1 should have been restarted, and execute about 15 additional times.
  // Check 10 greater than initial, to account for some timing jitter.
  EXPECT_LT(t1_runs_initial + 50, t1_runs_final);
@@ -375,6 +376,8 @@ TYPED_TEST(TestTimerCancelBehavior, testBackTimerCancelThenResetBehavior) {
  int t1_runs_final = this->node->GetTimer1Cnt();
  int t2_runs_final = this->node->GetTimer2Cnt();

+  this->executor.cancel();
+
  // T2 should have been restarted, and execute about 15 additional times.
  // Check 10 greater than initial, to account for some timing jitter.
  EXPECT_LT(t2_runs_initial + 50, t2_runs_final);
@@ -408,6 +411,8 @@ TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT1Behavior) {
  int t1_runs_final = this->node->GetTimer1Cnt();
  int t2_runs_final = this->node->GetTimer2Cnt();

+  this->executor.cancel();
+
  // T1 and T2 should have the same initial count.
  EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);

@@ -445,6 +450,8 @@ TYPED_TEST(TestTimerCancelBehavior, testBothTimerCancelThenResetT2Behavior) {
  int t1_runs_final = this->node->GetTimer1Cnt();
  int t2_runs_final = this->node->GetTimer2Cnt();

+  this->executor.cancel();
+
  // T1 and T2 should have the same initial count.
  EXPECT_LE(std::abs(t1_runs_initial - t2_runs_initial), 1);

--- a/rclcpp/test/rclcpp/executors/test_executors_warmup.cpp
+++ b/rclcpp/test/rclcpp/executors/test_executors_warmup.cpp
@@ -1,236 +0,0 @@
-// Copyright 2024 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.
-
-/**
- * This test checks all implementations of rclcpp::executor to check they pass they basic API
- * tests. Anything specific to any executor in particular should go in a separate test file.
- */
-
-#include <gtest/gtest.h>
-
-#include <chrono>
-#include <cstddef>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "rclcpp/rclcpp.hpp"
-
-#include "test_msgs/msg/empty.hpp"
-
-#include "./executor_types.hpp"
-
-using namespace std::chrono_literals;
-
-template<typename T>
-class TestExecutorsWarmup : public ::testing::Test
-{
-public:
-  void SetUp()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  void TearDown()
-  {
-    rclcpp::shutdown();
-  }
-};
-
-TYPED_TEST_SUITE(TestExecutorsWarmup, ExecutorTypes, ExecutorTypeNames);
-
-// This test verifies that spin_all is correctly collecting work multiple times
-// even when one of the items of work is a notifier waitable event and thus results in
-// rebuilding the entities collection.
-// When spin_all goes back to collect more work, it should see the ready items from
-// the new added entities
-TYPED_TEST(TestExecutorsWarmup, spin_all_doesnt_require_warmup)
-{
-  using ExecutorType = TypeParam;
-  ExecutorType executor;
-
-  // Enable intra-process to guarantee deterministic and synchronous delivery of the message / event
-  auto node_options = rclcpp::NodeOptions().use_intra_process_comms(true);
-  auto node = std::make_shared<rclcpp::Node>("test_node", node_options);
-
-  // Add node to the executor before creating the entities
-  executor.add_node(node);
-
-  // Create entities, this will produce a notifier waitable event, telling the executor to refresh
-  // the entities collection
-  auto publisher = node->create_publisher<test_msgs::msg::Empty>("test_topic", rclcpp::QoS(10));
-  size_t callback_count = 0;
-  auto callback = [&callback_count](test_msgs::msg::Empty::ConstSharedPtr) {callback_count++;};
-  auto subscription =
-    node->create_subscription<test_msgs::msg::Empty>(
-    "test_topic", rclcpp::QoS(10), std::move(callback));
-
-  ASSERT_EQ(callback_count, 0u);
-
-  // Publish a message so that the new entities (i.e. the subscriber) already have work to do
-  publisher->publish(test_msgs::msg::Empty());
-
-  // We need to select a duration that is greater than
-  // the time taken to refresh the entities collection and rebuild the waitset.
-  // spin-all is expected to process the notifier waitable event, rebuild the collection,
-  // and then collect more work, finding the subscription message event.
-  // This duration has been selected empirically.
-  executor.spin_all(std::chrono::milliseconds(500));
-
-  // Verify that the callback is called as part of the spin above
-  EXPECT_EQ(callback_count, 1u);
-}
-
-// Same test as `spin_all_doesnt_require_warmup`, but uses a callback group
-// This test reproduces the bug reported by https://github.com/ros2/rclcpp/issues/2589
-TYPED_TEST(TestExecutorsWarmup, spin_all_doesnt_require_warmup_with_cbgroup)
-{
-  using ExecutorType = TypeParam;
-
-  ExecutorType executor;
-
-  // Enable intra-process to guarantee deterministic and synchronous delivery of the message / event
-  auto node_options = rclcpp::NodeOptions().use_intra_process_comms(true);
-  auto node = std::make_shared<rclcpp::Node>("test_node", node_options);
-
-  auto callback_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive,
-    false);
-
-  // Add callback group to the executor before creating the entities
-  executor.add_callback_group(callback_group, node->get_node_base_interface());
-
-  // Create entities, this will produce a notifier waitable event, telling the executor to refresh
-  // the entities collection
-  auto publisher = node->create_publisher<test_msgs::msg::Empty>("test_topic", rclcpp::QoS(10));
-  size_t callback_count = 0;
-  auto callback = [&callback_count](test_msgs::msg::Empty::ConstSharedPtr) {callback_count++;};
-  rclcpp::SubscriptionOptions sub_options;
-  sub_options.callback_group = callback_group;
-  auto subscription =
-    node->create_subscription<test_msgs::msg::Empty>(
-    "test_topic", rclcpp::QoS(10), std::move(callback), sub_options);
-
-  ASSERT_EQ(callback_count, 0u);
-
-  // Publish a message so that the new entities (i.e. the subscriber) already have work to do
-  publisher->publish(test_msgs::msg::Empty());
-
-  // We need to select a duration that is greater than
-  // the time taken to refresh the entities collection and rebuild the waitset.
-  // spin-all is expected to process the notifier waitable event, rebuild the collection,
-  // and then collect more work, finding the subscription message event.
-  // This duration has been selected empirically.
-  executor.spin_all(std::chrono::milliseconds(500));
-
-  // Verify that the callback is called as part of the spin above
-  EXPECT_EQ(callback_count, 1u);
-}
-
-TYPED_TEST(TestExecutorsWarmup, spin_some_doesnt_require_warmup)
-{
-  using ExecutorType = TypeParam;
-
-  // TODO(alsora): currently only the events-executor passes this test.
-  // Enable single-threaded and multi-threaded executors
-  // when https://github.com/ros2/rclcpp/pull/2595 gets merged
-  if (
-    !std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>())
-  {
-    GTEST_SKIP();
-  }
-
-  ExecutorType executor;
-
-  // Enable intra-process to guarantee deterministic and synchronous delivery of the message / event
-  auto node_options = rclcpp::NodeOptions().use_intra_process_comms(true);
-  auto node = std::make_shared<rclcpp::Node>("test_node", node_options);
-
-  // Add node to the executor before creating the entities
-  executor.add_node(node);
-
-  // Create entities, this will produce a notifier waitable event, telling the executor to refresh
-  // the entities collection
-  auto publisher = node->create_publisher<test_msgs::msg::Empty>("test_topic", rclcpp::QoS(10));
-  size_t callback_count = 0;
-  auto callback = [&callback_count](test_msgs::msg::Empty::ConstSharedPtr) {callback_count++;};
-  auto subscription =
-    node->create_subscription<test_msgs::msg::Empty>(
-    "test_topic", rclcpp::QoS(10), std::move(callback));
-
-  ASSERT_EQ(callback_count, 0u);
-
-  // Publish a message so that the new entities (i.e. the subscriber) already have work to do
-  publisher->publish(test_msgs::msg::Empty());
-
-  // NOTE: intra-process communication is enabled, so the subscription will immediately see
-  // the new message, no risk of race conditions where spin_some gets called before the
-  // message has been delivered.
-  executor.spin_some();
-
-  // Verify that the callback is called as part of the spin above
-  EXPECT_EQ(callback_count, 1u);
-}
-
-TYPED_TEST(TestExecutorsWarmup, spin_some_doesnt_require_warmup_with_cbgroup)
-{
-  using ExecutorType = TypeParam;
-
-  // TODO(alsora): currently only the events-executor passes this test.
-  // Enable single-threaded and multi-threaded executors
-  // when https://github.com/ros2/rclcpp/pull/2595 gets merged
-  if (
-    !std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>())
-  {
-    GTEST_SKIP();
-  }
-
-  ExecutorType executor;
-
-  // Enable intra-process to guarantee deterministic and synchronous delivery of the message / event
-  auto node_options = rclcpp::NodeOptions().use_intra_process_comms(true);
-  auto node = std::make_shared<rclcpp::Node>("test_node", node_options);
-
-  auto callback_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive,
-    false);
-
-  // Add callback group to the executor before creating the entities
-  executor.add_callback_group(callback_group, node->get_node_base_interface());
-
-  // Create entities, this will produce a notifier waitable event, telling the executor to refresh
-  // the entities collection
-  auto publisher = node->create_publisher<test_msgs::msg::Empty>("test_topic", rclcpp::QoS(10));
-  size_t callback_count = 0;
-  auto callback = [&callback_count](test_msgs::msg::Empty::ConstSharedPtr) {callback_count++;};
-  rclcpp::SubscriptionOptions sub_options;
-  sub_options.callback_group = callback_group;
-  auto subscription =
-    node->create_subscription<test_msgs::msg::Empty>(
-    "test_topic", rclcpp::QoS(10), std::move(callback), sub_options);
-
-  ASSERT_EQ(callback_count, 0u);
-
-  // Publish a message so that the new entities (i.e. the subscriber) already have work to do
-  publisher->publish(test_msgs::msg::Empty());
-
-  // NOTE: intra-process communication is enabled, so the subscription will immediately see
-  // the new message, no risk of race conditions where spin_some gets called before the
-  // message has been delivered.
-  executor.spin_some();
-
-  // Verify that the callback is called as part of the spin above
-  EXPECT_EQ(callback_count, 1u);
-}
--- a/rclcpp/test/rclcpp/executors/test_waitable.cpp
+++ b/rclcpp/test/rclcpp/executors/test_waitable.cpp
@@ -1,126 +0,0 @@
-// Copyright 2024 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 <atomic>
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <thread>
-
-#include "rclcpp/detail/add_guard_condition_to_rcl_wait_set.hpp"
-#include "rclcpp/waitable.hpp"
-
-#include "rcl/wait.h"
-
-#include "test_waitable.hpp"
-
-using namespace std::chrono_literals;
-
-void
-TestWaitable::add_to_wait_set(rcl_wait_set_t & wait_set)
-{
-  if (trigger_count_ > 0) {
-    // Keep the gc triggered until the trigger count is reduced back to zero.
-    // This is necessary if trigger() results in the wait set waking, but not
-    // executing this waitable, in which case it needs to be re-triggered.
-    gc_.trigger();
-  }
-  rclcpp::detail::add_guard_condition_to_rcl_wait_set(wait_set, gc_);
-}
-
-void TestWaitable::trigger()
-{
-  trigger_count_++;
-  gc_.trigger();
-}
-
-bool
-TestWaitable::is_ready(const rcl_wait_set_t & wait_set)
-{
-  is_ready_count_++;
-  for (size_t i = 0; i < wait_set.size_of_guard_conditions; ++i) {
-    auto rcl_guard_condition = wait_set.guard_conditions[i];
-    if (&gc_.get_rcl_guard_condition() == rcl_guard_condition) {
-      return true;
-    }
-  }
-  return false;
-}
-
-std::shared_ptr<void>
-TestWaitable::take_data()
-{
-  return nullptr;
-}
-
-std::shared_ptr<void>
-TestWaitable::take_data_by_entity_id(size_t id)
-{
-  (void) id;
-  return nullptr;
-}
-
-void
-TestWaitable::execute(const std::shared_ptr<void> &)
-{
-  trigger_count_--;
-  count_++;
-  if (nullptr != on_execute_callback_) {
-    on_execute_callback_();
-  } else {
-    // TODO(wjwwood): I don't know why this was here, but probably it should
-    //   not be there, or test cases where that is important should use the
-    //   on_execute_callback?
-    std::this_thread::sleep_for(3ms);
-  }
-}
-
-void
-TestWaitable::set_on_execute_callback(std::function<void()> on_execute_callback)
-{
-  on_execute_callback_ = on_execute_callback;
-}
-
-void
-TestWaitable::set_on_ready_callback(std::function<void(size_t, int)> callback)
-{
-  auto gc_callback = [callback](size_t count) {
-      callback(count, 0);
-    };
-  gc_.set_on_trigger_callback(gc_callback);
-}
-
-void
-TestWaitable::clear_on_ready_callback()
-{
-  gc_.set_on_trigger_callback(nullptr);
-}
-
-size_t
-TestWaitable::get_number_of_ready_guard_conditions()
-{
-  return 1;
-}
-
-size_t
-TestWaitable::get_count() const
-{
-  return count_;
-}
-
-size_t
-TestWaitable::get_is_ready_call_count() const
-{
-  return is_ready_count_;
-}
--- a/rclcpp/test/rclcpp/executors/test_waitable.hpp
+++ b/rclcpp/test/rclcpp/executors/test_waitable.hpp
@@ -1,75 +0,0 @@
-// Copyright 2024 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.
-
-#ifndef RCLCPP__EXECUTORS__TEST_WAITABLE_HPP_
-#define RCLCPP__EXECUTORS__TEST_WAITABLE_HPP_
-
-#include <atomic>
-#include <functional>
-#include <memory>
-
-#include "rclcpp/waitable.hpp"
-#include "rclcpp/guard_condition.hpp"
-
-#include "rcl/wait.h"
-
-class TestWaitable : public rclcpp::Waitable
-{
-public:
-  TestWaitable() = default;
-
-  void
-  add_to_wait_set(rcl_wait_set_t & wait_set) override;
-
-  void trigger();
-
-  bool
-  is_ready(const rcl_wait_set_t & wait_set) override;
-
-  std::shared_ptr<void>
-  take_data() override;
-
-  std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) override;
-
-  void
-  execute(const std::shared_ptr<void> &) override;
-
-  void
-  set_on_execute_callback(std::function<void()> on_execute_callback);
-
-  void
-  set_on_ready_callback(std::function<void(size_t, int)> callback) override;
-
-  void
-  clear_on_ready_callback() override;
-
-  size_t
-  get_number_of_ready_guard_conditions() override;
-
-  size_t
-  get_count() const;
-
-  size_t
-  get_is_ready_call_count() const;
-
-private:
-  std::atomic<size_t> trigger_count_ = 0;
-  std::atomic<size_t> is_ready_count_ = 0;
-  std::atomic<size_t> count_ = 0;
-  rclcpp::GuardCondition gc_;
-  std::function<void()> on_execute_callback_ = nullptr;
-};
-
-#endif  // RCLCPP__EXECUTORS__TEST_WAITABLE_HPP_
--- a/rclcpp/test/rclcpp/node_interfaces/test_node_parameters.cpp
+++ b/rclcpp/test/rclcpp/node_interfaces/test_node_parameters.cpp
@@ -125,7 +125,7 @@ TEST_F(TestNodeParameters, list_parameters)
    list_result5.names.end());
 }

-TEST_F(TestNodeParameters, parameter_overrides_with_value)
+TEST_F(TestNodeParameters, parameter_overrides)
 {
  rclcpp::NodeOptions node_options;
  node_options.automatically_declare_parameters_from_overrides(true);
@@ -143,24 +143,6 @@ TEST_F(TestNodeParameters, parameter_overrides_with_value)
  EXPECT_EQ(2u, parameter_overrides.size());
 }

-TEST_F(TestNodeParameters, parameter_overrides_with_parameter)
-{
-  rclcpp::NodeOptions node_options;
-  node_options.automatically_declare_parameters_from_overrides(true);
-  node_options.append_parameter_override(rclcpp::Parameter("param1", true));
-  node_options.append_parameter_override(rclcpp::Parameter("param2", 42));
-
-  std::shared_ptr<rclcpp::Node> node2 = std::make_shared<rclcpp::Node>("node2", "ns", node_options);
-
-  auto * node_parameters_interface =
-    dynamic_cast<rclcpp::node_interfaces::NodeParameters *>(
-    node2->get_node_parameters_interface().get());
-  ASSERT_NE(nullptr, node_parameters_interface);
-
-  const auto & parameter_overrides = node_parameters_interface->get_parameter_overrides();
-  EXPECT_EQ(2u, parameter_overrides.size());
-}
-
 TEST_F(TestNodeParameters, set_parameters) {
  rclcpp::NodeOptions node_options;
  node_options.allow_undeclared_parameters(true);
--- a/rclcpp/test/rclcpp/node_interfaces/test_node_type_descriptions.cpp
+++ b/rclcpp/test/rclcpp/node_interfaces/test_node_type_descriptions.cpp
@@ -37,38 +37,6 @@ TEST_F(TestNodeTypeDescriptions, interface_created)
  ASSERT_NE(nullptr, node.get_node_type_descriptions_interface());
 }

-TEST_F(TestNodeTypeDescriptions, automatically_declare_parameters_from_overrides)
-{
-  rclcpp::NodeOptions node_options;
-  node_options.automatically_declare_parameters_from_overrides(true);
-  node_options.append_parameter_override("start_type_description_service", false);
-  ASSERT_NO_THROW(
-  {
-    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
-    (void) node;
-  });
-}
-
-TEST_F(TestNodeTypeDescriptions, bad_parameter_type)
-{
-  rclcpp::NodeOptions node_options;
-  node_options.append_parameter_override("start_type_description_service", "unexpected_type");
-
-  ASSERT_THROW(
-  {
-    node_options.automatically_declare_parameters_from_overrides(false);
-    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
-    (void) node;
-  }, rclcpp::exceptions::InvalidParameterTypeException);
-
-  ASSERT_THROW(
-  {
-    node_options.automatically_declare_parameters_from_overrides(true);
-    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
-    (void) node;
-  }, rclcpp::exceptions::InvalidParameterTypeException);
-}
-
 TEST_F(TestNodeTypeDescriptions, disabled_no_service)
 {
  rclcpp::NodeOptions node_options;
--- a/rclcpp/test/rclcpp/test_client_common.cpp
+++ b/rclcpp/test/rclcpp/test_client_common.cpp
@@ -431,7 +431,7 @@ TYPED_TEST(TestAllClientTypesWithServer, client_qos)

  rclcpp::ServicesQoS qos_profile;
  qos_profile.liveliness(rclcpp::LivelinessPolicy::Automatic);
-  rclcpp::Duration duration(std::chrono::milliseconds(1));
+  rclcpp::Duration duration(std::chrono::nanoseconds(1));
  qos_profile.deadline(duration);
  qos_profile.lifespan(duration);
  qos_profile.liveliness_lease_duration(duration);
--- a/rclcpp/test/rclcpp/test_clock.cpp
+++ b/rclcpp/test/rclcpp/test_clock.cpp
@@ -178,10 +178,7 @@ TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
 TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);

-  std::vector<std::atomic_bool> thread_finished(10);
-  for (std::atomic_bool & finished : thread_finished) {
-    finished = false;
-  }
+  std::vector<bool> thread_finished(10, false);

  std::vector<std::thread> threads;

@@ -199,7 +196,7 @@ TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
  // wait a bit so all threads can execute the sleep_until
  std::this_thread::sleep_for(std::chrono::milliseconds(500));

-  for (const std::atomic_bool & finished : thread_finished) {
+  for (const bool & finished : thread_finished) {
    EXPECT_FALSE(finished);
  }

@@ -210,7 +207,7 @@ TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
  bool threads_finished = false;
  while (!threads_finished && start_time + std::chrono::seconds(1) > cur_time) {
    threads_finished = true;
-    for (const std::atomic_bool & finished : thread_finished) {
+    for (const bool finished : thread_finished) {
      if (!finished) {
        threads_finished = false;
      }
@@ -220,7 +217,7 @@ TEST_F(TestClockWakeup, multiple_threads_wait_on_one_clock) {
    cur_time = std::chrono::steady_clock::now();
  }

-  for (const std::atomic_bool & finished : thread_finished) {
+  for (const bool finished : thread_finished) {
    EXPECT_TRUE(finished);
  }

--- a/rclcpp/test/rclcpp/test_clock_conditional.cpp
+++ b/rclcpp/test/rclcpp/test_clock_conditional.cpp
@@ -1,246 +0,0 @@
-// Copyright 2025 Cellumation GmbH
-//
-// 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 <gtest/gtest.h>
-
-#include <chrono>
-
-#include "rcl/error_handling.h"
-#include "rcl/time.h"
-#include "rclcpp/clock.hpp"
-#include "rclcpp/rclcpp.hpp"
-#include "rclcpp/time_source.hpp"
-
-#include "../utils/rclcpp_gtest_macros.hpp"
-
-using namespace std::chrono_literals;
-
-class TestClockWakeup : public ::testing::TestWithParam<rcl_clock_type_e>
-{
-public:
-  void test_wakeup_before_sleep(const rclcpp::Clock::SharedPtr & clock)
-  {
-    std::atomic_bool thread_finished = false;
-    rclcpp::ClockConditionalVariable cond(clock);
-
-    bool stopSleeping = false;
-
-    std::thread wait_thread = std::thread(
-      [&cond, &clock, &stopSleeping, &thread_finished]()
-      {
-        // make sure the thread starts sleeping late
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        std::unique_lock lk(cond.mutex());
-        cond.wait_until(lk, clock->now() + std::chrono::seconds(3),
-        [&stopSleeping] () {return stopSleeping;});
-        thread_finished = true;
-      });
-
-    {
-      std::lock_guard lk(cond.mutex());
-      // stop sleeping after next notification
-      stopSleeping = true;
-    }
-    // notify the conditional, to recheck it pred
-    cond.notify_one();
-
-    auto start_time = std::chrono::steady_clock::now();
-    auto cur_time = start_time;
-    while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      cur_time = std::chrono::steady_clock::now();
-    }
-
-    wait_thread.join();
-
-    EXPECT_TRUE(thread_finished);
-    EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-  }
-
-  void test_wakeup_after_sleep(const rclcpp::Clock::SharedPtr & clock)
-  {
-    std::atomic_bool thread_finished = false;
-    rclcpp::ClockConditionalVariable cond(clock);
-
-    bool stopSleeping = false;
-
-    std::thread wait_thread = std::thread(
-      [&cond, &clock, &stopSleeping, &thread_finished]()
-      {
-        std::unique_lock lk(cond.mutex());
-        cond.wait_until(lk, clock->now() + std::chrono::seconds(3),
-        [&stopSleeping] () {return stopSleeping;});
-        thread_finished = true;
-      });
-
-    // make sure the thread is already sleeping before we send the cancel
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-
-    {
-      std::lock_guard lk(cond.mutex());
-      // stop sleeping after next notification
-      stopSleeping = true;
-    }
-    // notify the conditional, to recheck it pred
-    cond.notify_one();
-
-    auto start_time = std::chrono::steady_clock::now();
-    auto cur_time = start_time;
-    while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      cur_time = std::chrono::steady_clock::now();
-    }
-
-    wait_thread.join();
-
-    EXPECT_TRUE(thread_finished);
-    EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-  }
-
-protected:
-  static void SetUpTestCase()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  static void TearDownTestCase()
-  {
-    rclcpp::shutdown();
-  }
-
-  void SetUp()
-  {
-    node = std::make_shared<rclcpp::Node>("my_node");
-  }
-
-  void TearDown()
-  {
-    node.reset();
-  }
-
-  rclcpp::Node::SharedPtr node;
-};
-
-INSTANTIATE_TEST_SUITE_P(
-  ClockConditionalVariable,
-  TestClockWakeup,
-  ::testing::Values(
-    RCL_SYSTEM_TIME, RCL_ROS_TIME, RCL_STEADY_TIME
-));
-
-TEST_P(TestClockWakeup, wakeup_sleep) {
-  auto clock = std::make_shared<rclcpp::Clock>(GetParam());
-  test_wakeup_after_sleep(clock);
-  test_wakeup_before_sleep(clock);
-}
-
-TEST_F(TestClockWakeup, wakeup_sleep_ros_time_active) {
-  node->set_parameter({"use_sim_time", true});
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-  rclcpp::TimeSource time_source(node);
-  time_source.attachClock(clock);
-
-  EXPECT_TRUE(clock->ros_time_is_active());
-
-  test_wakeup_after_sleep(clock);
-  test_wakeup_before_sleep(clock);
-}
-
-TEST_F(TestClockWakeup, no_wakeup_on_sim_time) {
-  node->set_parameter({"use_sim_time", true});
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-  EXPECT_FALSE(clock->ros_time_is_active());
-
-  rclcpp::TimeSource time_source(node);
-  time_source.attachClock(clock);
-  EXPECT_TRUE(clock->ros_time_is_active());
-
-  std::atomic_bool thread_finished = false;
-  rclcpp::ClockConditionalVariable cond(clock);
-
-  bool stopSleeping = false;
-
-  std::thread wait_thread = std::thread(
-    [&cond, &clock, &stopSleeping, &thread_finished]()
-    {
-      std::unique_lock lk(cond.mutex());
-      // only sleep for an short period
-      cond.wait_until(lk, clock->now() + std::chrono::milliseconds(10),
-      [&stopSleeping] () {return stopSleeping;});
-      thread_finished = true;
-    });
-
-  // make sure, that the sim time clock does not wakeup, as no clock is provided
-  std::this_thread::sleep_for(std::chrono::milliseconds(500));
-  EXPECT_FALSE(thread_finished);
-
-  {
-    std::lock_guard lk(cond.mutex());
-    // stop sleeping after next notification
-    stopSleeping = true;
-  }
-  // notify the conditional, to recheck it pred
-  cond.notify_one();
-
-  auto start_time = std::chrono::steady_clock::now();
-  auto cur_time = start_time;
-  while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    cur_time = std::chrono::steady_clock::now();
-  }
-
-  wait_thread.join();
-
-  EXPECT_TRUE(thread_finished);
-  EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-}
-
-TEST_F(TestClockWakeup, wakeup_on_ros_shutdown) {
-  auto clock = std::make_shared<rclcpp::Clock>(RCL_ROS_TIME);
-
-  std::atomic_bool thread_finished = false;
-  rclcpp::ClockConditionalVariable cond(clock);
-
-  bool stopSleeping = false;
-
-  std::thread wait_thread = std::thread(
-    [&cond, &clock, &stopSleeping, &thread_finished]()
-    {
-      std::unique_lock lk(cond.mutex());
-      // only sleep for an short period
-      cond.wait_until(lk, clock->now() + std::chrono::seconds(10),
-      [&stopSleeping] () {return stopSleeping;});
-      thread_finished = true;
-    });
-
-  // wait a bit to be sure the thread is sleeping
-  std::this_thread::sleep_for(std::chrono::milliseconds(500));
-
-  EXPECT_FALSE(thread_finished);
-
-  rclcpp::shutdown();
-
-  auto start_time = std::chrono::steady_clock::now();
-  auto cur_time = start_time;
-  while (!thread_finished && start_time + std::chrono::seconds(1) > cur_time) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    cur_time = std::chrono::steady_clock::now();
-  }
-
-  EXPECT_TRUE(thread_finished);
-
-  wait_thread.join();
-
-  EXPECT_LT(cur_time, start_time + std::chrono::seconds(1));
-}
--- a/rclcpp/test/rclcpp/test_create_subscription.cpp
+++ b/rclcpp/test/rclcpp/test_create_subscription.cpp
@@ -93,19 +93,3 @@ TEST_F(TestCreateSubscription, create_with_statistics) {
  ASSERT_NE(nullptr, subscription);
  EXPECT_STREQ("/ns/topic_name", subscription->get_topic_name());
 }
-
-TEST_F(TestCreateSubscription, create_with_intra_process_com) {
-  auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");
-  auto options = rclcpp::SubscriptionOptions();
-  options.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-
-  auto callback = [](test_msgs::msg::Empty::ConstSharedPtr) {};
-  rclcpp::Subscription<test_msgs::msg::Empty>::SharedPtr subscription;
-  ASSERT_NO_THROW(
-  {
-    subscription = rclcpp::create_subscription<test_msgs::msg::Empty>(
-      node, "topic_name", rclcpp::SystemDefaultsQoS(), callback, options);
-  });
-  ASSERT_NE(nullptr, subscription);
-  EXPECT_STREQ("/ns/topic_name", subscription->get_topic_name());
-}
--- a/rclcpp/test/rclcpp/test_generic_pubsub.cpp
+++ b/rclcpp/test/rclcpp/test_generic_pubsub.cpp
@@ -15,7 +15,6 @@

 #include <gmock/gmock.h>

-#include <chrono>
 #include <future>
 #include <memory>
 #include <string>
--- a/rclcpp/test/rclcpp/test_logger_service.cpp
+++ b/rclcpp/test/rclcpp/test_logger_service.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>
--- a/rclcpp/test/rclcpp/test_logging.cpp
+++ b/rclcpp/test/rclcpp/test_logging.cpp
@@ -253,19 +253,9 @@ bool log_function_const_ref(const rclcpp::Logger & logger)
  return true;
 }

-class DerivedLogger : public rclcpp::Logger
-{
-public:
-  explicit DerivedLogger(const rclcpp::Logger & logger)
-  : rclcpp::Logger(logger) {}
-};
-
 TEST_F(TestLoggingMacros, test_log_from_node) {
  auto logger = rclcpp::get_logger("test_logging_logger");
  EXPECT_TRUE(log_function(logger));
  EXPECT_TRUE(log_function_const(logger));
  EXPECT_TRUE(log_function_const_ref(logger));
-
-  DerivedLogger derived_logger(logger);
-  RCLCPP_INFO(derived_logger, "successful log from derived logger");
 }
--- a/rclcpp/test/rclcpp/test_node_options.cpp
+++ b/rclcpp/test/rclcpp/test_node_options.cpp
@@ -200,57 +200,6 @@ TEST(TestNodeOptions, copy) {
      rcl_arguments_get_count_unparsed(&other_rcl_options->arguments),
      rcl_arguments_get_count_unparsed(&rcl_options->arguments));
  }
-
-  {
-    // The following scope test is missing:
-    //    "arguments" because it is already tested in the above scopes
-    //    "parameter_event_publisher_options" because it can not be directly compared with EXPECT_EQ
-    //    "allocator" because it can not be directly compared with EXPECT_EQ
-
-    // We separate attribute modification from variable initialisation (copy assignment operator)
-    // to be sure the "non_default_options"'s properties are correctly set before testing the
-    // assignment operator.
-    auto non_default_options = rclcpp::NodeOptions();
-    non_default_options
-    .parameter_overrides({rclcpp::Parameter("foo", 0), rclcpp::Parameter("bar", "1")})
-    .use_global_arguments(false)
-    .enable_rosout(false)
-    .use_intra_process_comms(true)
-    .enable_topic_statistics(true)
-    .start_parameter_services(false)
-    .enable_logger_service(true)
-    .start_parameter_event_publisher(false)
-    .clock_type(RCL_SYSTEM_TIME)
-    .clock_qos(rclcpp::SensorDataQoS())
-    .use_clock_thread(false)
-    .parameter_event_qos(rclcpp::ClockQoS())
-    .rosout_qos(rclcpp::ParameterEventsQoS())
-    .allow_undeclared_parameters(true)
-    .automatically_declare_parameters_from_overrides(true);
-
-    auto copied_options = non_default_options;
-    EXPECT_EQ(non_default_options.parameter_overrides(), copied_options.parameter_overrides());
-    EXPECT_EQ(non_default_options.use_global_arguments(), copied_options.use_global_arguments());
-    EXPECT_EQ(non_default_options.enable_rosout(), copied_options.enable_rosout());
-    EXPECT_EQ(non_default_options.use_intra_process_comms(),
-      copied_options.use_intra_process_comms());
-    EXPECT_EQ(non_default_options.enable_topic_statistics(),
-      copied_options.enable_topic_statistics());
-    EXPECT_EQ(non_default_options.start_parameter_services(),
-      copied_options.start_parameter_services());
-    EXPECT_EQ(non_default_options.enable_logger_service(), copied_options.enable_logger_service());
-    EXPECT_EQ(non_default_options.start_parameter_event_publisher(),
-      copied_options.start_parameter_event_publisher());
-    EXPECT_EQ(non_default_options.clock_type(), copied_options.clock_type());
-    EXPECT_EQ(non_default_options.clock_qos(), copied_options.clock_qos());
-    EXPECT_EQ(non_default_options.use_clock_thread(), copied_options.use_clock_thread());
-    EXPECT_EQ(non_default_options.parameter_event_qos(), copied_options.parameter_event_qos());
-    EXPECT_EQ(non_default_options.rosout_qos(), copied_options.rosout_qos());
-    EXPECT_EQ(non_default_options.allow_undeclared_parameters(),
-      copied_options.allow_undeclared_parameters());
-    EXPECT_EQ(non_default_options.automatically_declare_parameters_from_overrides(),
-      copied_options.automatically_declare_parameters_from_overrides());
-  }
 }

 TEST(TestNodeOptions, append_parameter_override) {
@@ -258,10 +207,8 @@ TEST(TestNodeOptions, append_parameter_override) {
  auto options = rclcpp::NodeOptions().arguments(expected_args).use_global_arguments(false);
  rclcpp::Parameter parameter("some_parameter", 10);
  options.append_parameter_override("some_parameter", 10);
-  options.append_parameter_override(parameter);
-  EXPECT_EQ(2u, options.parameter_overrides().size());
+  EXPECT_EQ(1u, options.parameter_overrides().size());
  EXPECT_EQ(std::string("some_parameter"), options.parameter_overrides()[0].get_name());
-  EXPECT_EQ(std::string("some_parameter"), options.parameter_overrides()[1].get_name());
 }

 TEST(TestNodeOptions, rcl_node_options_fini_error) {
--- a/rclcpp/test/rclcpp/test_parameter_events_filter.cpp
+++ b/rclcpp/test/rclcpp/test_parameter_events_filter.cpp
@@ -72,13 +72,6 @@ protected:
 /*
   Testing filters.
 */
-TEST_F(TestParameterEventFilter, invalide_arguments) {
-  EXPECT_THROW(
-    rclcpp::ParameterEventsFilter(nullptr, {"new"}, {nt}),
-    std::invalid_argument
-  );
-}
-
 TEST_F(TestParameterEventFilter, full_by_type) {
  auto res = rclcpp::ParameterEventsFilter(
    full,
--- a/rclcpp/test/rclcpp/test_parameter_service.cpp
+++ b/rclcpp/test/rclcpp/test_parameter_service.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <memory>
 #include <string>
 #include <utility>
--- a/rclcpp/test/rclcpp/test_publisher.cpp
+++ b/rclcpp/test/rclcpp/test_publisher.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <future>
 #include <chrono>
 #include <memory>
 #include <string>
@@ -179,21 +178,6 @@ TEST_F(TestPublisher, various_creation_signatures) {
  }
 }

-/*
-   Testing publisher with intraprocess enabled and SystemDefaultQoS
- */
-TEST_F(TestPublisher, test_publisher_with_system_default_qos) {
-  initialize(rclcpp::NodeOptions().use_intra_process_comms(false));
-  // explicitly enable intra-process comm with publisher option
-  auto options = rclcpp::PublisherOptions();
-  options.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-  using test_msgs::msg::Empty;
-  ASSERT_NO_THROW(
-  {
-    auto publisher = node->create_publisher<Empty>("topic", rclcpp::SystemDefaultsQoS(), options);
-  });
-}
-
 /*
   Testing publisher with intraprocess enabled and invalid QoS
 */
@@ -439,10 +423,11 @@ TEST_F(TestPublisher, intra_process_publish_failures) {
          publisher->get_publisher_handle().get(), msg.get()));
    }
  }
-  // a zero depth with KEEP_LAST doesn't make sense,
-  // this will be interpreted as SystemDefaultQoS by rclcpp.
-  EXPECT_NO_THROW(
-    node->create_publisher<test_msgs::msg::Empty>("topic", rclcpp::QoS(0), options));
+  RCLCPP_EXPECT_THROW_EQ(
+    node->create_publisher<test_msgs::msg::Empty>(
+      "topic", rclcpp::QoS(0), options),
+    std::invalid_argument(
+      "intraprocess communication is not allowed with a zero qos history depth value"));
 }

 TEST_F(TestPublisher, inter_process_publish_failures) {
@@ -717,7 +702,11 @@ TEST_F(TestPublisher, intra_process_transient_local) {
  auto do_nothing = [](std::shared_ptr<const test_msgs::msg::Empty>) {};
  struct IntraProcessCallback
  {
-    void callback_fun(size_t) {called = true;}
+    void callback_fun(size_t s)
+    {
+      (void) s;
+      called = true;
+    }
    bool called = false;
  };
  rclcpp::SubscriptionOptions sub_options_ipm_disabled;
@@ -774,44 +763,3 @@ TEST_F(TestPublisher, intra_process_transient_local) {
  EXPECT_FALSE(callback3.called);
  EXPECT_FALSE(callback4.called);
 }
-
-TEST_F(TestPublisher, intra_process_inter_process_mix_transient_local) {
-  constexpr auto history_depth = 10u;
-  initialize(rclcpp::NodeOptions().use_intra_process_comms(true));
-
-  rclcpp::PublisherOptionsWithAllocator<std::allocator<void>> pub_options_ipm_enabled;
-  pub_options_ipm_enabled.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-
-  auto pub_ipm_enabled_transient_local_enabled = node->create_publisher<test_msgs::msg::Empty>(
-    "topic1",
-    rclcpp::QoS(rclcpp::KeepLast(history_depth)).transient_local(), pub_options_ipm_enabled);
-
-  test_msgs::msg::Empty msg;
-  pub_ipm_enabled_transient_local_enabled->publish(msg);
-
-  auto do_nothing = [](std::shared_ptr<const test_msgs::msg::Empty>) {};
-  struct SubscriptionCallback
-  {
-    void callback_fun(size_t) {called.set_value();}
-    std::promise<void> called;
-  };
-  rclcpp::SubscriptionOptions sub_options_ipm_disabled;
-  sub_options_ipm_disabled.use_intra_process_comm = rclcpp::IntraProcessSetting::Disable;
-  SubscriptionCallback intra_callback, inter_callback;
-  std::future<void> intra_callback_future = intra_callback.called.get_future(),
-    inter_callback_future = inter_callback.called.get_future();
-  auto sub_ipm_disabled_transient_local_enabled = node->create_subscription<test_msgs::msg::Empty>(
-    "topic1",
-    rclcpp::QoS(rclcpp::KeepLast(history_depth)).transient_local(),
-    do_nothing, sub_options_ipm_disabled);
-  sub_ipm_disabled_transient_local_enabled->set_on_new_intra_process_message_callback(
-    std::bind(&SubscriptionCallback::callback_fun, &intra_callback, std::placeholders::_1));
-  sub_ipm_disabled_transient_local_enabled->set_on_new_message_callback(
-    std::bind(&SubscriptionCallback::callback_fun, &inter_callback, std::placeholders::_1));
-  rclcpp::executors::SingleThreadedExecutor executor;
-  executor.add_node(node);
-  EXPECT_EQ(executor.spin_until_future_complete(inter_callback_future,
-    std::chrono::milliseconds(100)), rclcpp::FutureReturnCode::SUCCESS);
-  EXPECT_EQ(executor.spin_until_future_complete(intra_callback_future,
-    std::chrono::milliseconds(100)), rclcpp::FutureReturnCode::TIMEOUT);
-}
--- a/rclcpp/test/rclcpp/test_qos.cpp
+++ b/rclcpp/test/rclcpp/test_qos.cpp
@@ -259,15 +259,3 @@ TEST(TestQoS, qos_check_compatible)
    EXPECT_FALSE(ret.reason.empty());
  }
 }
-
-TEST(TestQoS, from_rmw_validity)
-{
-  rmw_qos_profile_t invalid_qos;
-  memset(&invalid_qos, 0, sizeof(invalid_qos));
-  unsigned int n = 999;
-  memcpy(&invalid_qos.history, &n, sizeof(n));
-
-  EXPECT_THROW({
-    rclcpp::QoSInitialization::from_rmw(invalid_qos);
-  }, std::invalid_argument);
-}
--- a/rclcpp/test/rclcpp/test_qos_event.cpp
+++ b/rclcpp/test/rclcpp/test_qos_event.cpp
@@ -70,31 +70,27 @@ TEST_F(TestQosEvent, test_publisher_constructor)
  auto publisher = node->create_publisher<test_msgs::msg::Empty>(
    topic_name, 10, options);

-  if (rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED) &&
-    rmw_event_type_is_supported(RMW_EVENT_LIVELINESS_LOST))
-  {
-    // options arg with one of the callbacks
-    options.event_callbacks.deadline_callback =
-      [node = node.get()](rclcpp::QOSDeadlineOfferedInfo & event) {
-        RCLCPP_INFO(
-          node->get_logger(),
-          "Offered deadline missed - total %d (delta %d)",
-          event.total_count, event.total_count_change);
-      };
-    publisher = node->create_publisher<test_msgs::msg::Empty>(
-      topic_name, 10, options);
+  // options arg with one of the callbacks
+  options.event_callbacks.deadline_callback =
+    [node = node.get()](rclcpp::QOSDeadlineOfferedInfo & event) {
+      RCLCPP_INFO(
+        node->get_logger(),
+        "Offered deadline missed - total %d (delta %d)",
+        event.total_count, event.total_count_change);
+    };
+  publisher = node->create_publisher<test_msgs::msg::Empty>(
+    topic_name, 10, options);

-    // options arg with two of the callbacks
-    options.event_callbacks.liveliness_callback =
-      [node = node.get()](rclcpp::QOSLivelinessLostInfo & event) {
-        RCLCPP_INFO(
-          node->get_logger(),
-          "Liveliness lost - total %d (delta %d)",
-          event.total_count, event.total_count_change);
-      };
-    publisher = node->create_publisher<test_msgs::msg::Empty>(
-      topic_name, 10, options);
-  }
+  // options arg with two of the callbacks
+  options.event_callbacks.liveliness_callback =
+    [node = node.get()](rclcpp::QOSLivelinessLostInfo & event) {
+      RCLCPP_INFO(
+        node->get_logger(),
+        "Liveliness lost - total %d (delta %d)",
+        event.total_count, event.total_count_change);
+    };
+  publisher = node->create_publisher<test_msgs::msg::Empty>(
+    topic_name, 10, options);

  // options arg with three of the callbacks
  options.event_callbacks.incompatible_qos_callback =
@@ -119,32 +115,28 @@ TEST_F(TestQosEvent, test_subscription_constructor)
  auto subscription = node->create_subscription<test_msgs::msg::Empty>(
    topic_name, 10, message_callback, options);

-  if (rmw_event_type_is_supported(RMW_EVENT_REQUESTED_DEADLINE_MISSED) &&
-    rmw_event_type_is_supported(RMW_EVENT_LIVELINESS_CHANGED))
-  {
-    // options arg with one of the callbacks
-    options.event_callbacks.deadline_callback =
-      [node = node.get()](rclcpp::QOSDeadlineRequestedInfo & event) {
-        RCLCPP_INFO(
-          node->get_logger(),
-          "Requested deadline missed - total %d (delta %d)",
-          event.total_count, event.total_count_change);
-      };
-    subscription = node->create_subscription<test_msgs::msg::Empty>(
-      topic_name, 10, message_callback, options);
+  // options arg with one of the callbacks
+  options.event_callbacks.deadline_callback =
+    [node = node.get()](rclcpp::QOSDeadlineRequestedInfo & event) {
+      RCLCPP_INFO(
+        node->get_logger(),
+        "Requested deadline missed - total %d (delta %d)",
+        event.total_count, event.total_count_change);
+    };
+  subscription = node->create_subscription<test_msgs::msg::Empty>(
+    topic_name, 10, message_callback, options);

-    // options arg with two of the callbacks
-    options.event_callbacks.liveliness_callback =
-      [node = node.get()](rclcpp::QOSLivelinessChangedInfo & event) {
-        RCLCPP_INFO(
-          node->get_logger(),
-          "Liveliness changed - alive %d (delta %d), not alive %d (delta %d)",
-          event.alive_count, event.alive_count_change,
-          event.not_alive_count, event.not_alive_count_change);
-      };
-    subscription = node->create_subscription<test_msgs::msg::Empty>(
-      topic_name, 10, message_callback, options);
-  }
+  // options arg with two of the callbacks
+  options.event_callbacks.liveliness_callback =
+    [node = node.get()](rclcpp::QOSLivelinessChangedInfo & event) {
+      RCLCPP_INFO(
+        node->get_logger(),
+        "Liveliness changed - alive %d (delta %d), not alive %d (delta %d)",
+        event.alive_count, event.alive_count_change,
+        event.not_alive_count, event.not_alive_count_change);
+    };
+  subscription = node->create_subscription<test_msgs::msg::Empty>(
+    topic_name, 10, message_callback, options);

  // options arg with three of the callbacks
  options.event_callbacks.incompatible_qos_callback =
@@ -212,18 +204,14 @@ TEST_F(TestQosEvent, test_default_incompatible_qos_callbacks)
  const auto timeout = std::chrono::seconds(10);
  ex.spin_until_future_complete(log_msgs_future, timeout);

-  if (qos_check_compatible(qos_profile_publisher,
-    qos_profile_subscription).compatibility != rclcpp::QoSCompatibility::Ok)
-  {
-    EXPECT_EQ(
-      "New subscription discovered on topic '/ns/test_topic', requesting incompatible QoS. "
-      "No messages will be sent to it. Last incompatible policy: DURABILITY_QOS_POLICY",
-      pub_log_msg);
-    EXPECT_EQ(
-      "New publisher discovered on topic '/ns/test_topic', offering incompatible QoS. "
-      "No messages will be sent to it. Last incompatible policy: DURABILITY_QOS_POLICY",
-      sub_log_msg);
-  }
+  EXPECT_EQ(
+    "New subscription discovered on topic '/ns/test_topic', requesting incompatible QoS. "
+    "No messages will be sent to it. Last incompatible policy: DURABILITY_QOS_POLICY",
+    pub_log_msg);
+  EXPECT_EQ(
+    "New publisher discovered on topic '/ns/test_topic', offering incompatible QoS. "
+    "No messages will be sent to it. Last incompatible policy: DURABILITY_QOS_POLICY",
+    sub_log_msg);

  rcutils_logging_set_output_handler(original_output_handler);
 }
@@ -235,9 +223,7 @@ TEST_F(TestQosEvent, construct_destruct_rcl_error) {

  // This callback requires some type of parameter, but it could be anything
  auto callback = [](int) {};
-  const rcl_publisher_event_type_t event_type =
-    !rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED) ?
-    RCL_PUBLISHER_MATCHED : RCL_PUBLISHER_OFFERED_DEADLINE_MISSED;
+  const rcl_publisher_event_type_t event_type = RCL_PUBLISHER_OFFERED_DEADLINE_MISSED;

  {
    // Logs error and returns
@@ -274,10 +260,6 @@ TEST_F(TestQosEvent, construct_destruct_rcl_error) {
 }

 TEST_F(TestQosEvent, execute) {
-  if (!rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED)) {
-    GTEST_SKIP();
-  }
-
  auto publisher = node->create_publisher<test_msgs::msg::Empty>(topic_name, 10);
  auto rcl_handle = publisher->get_publisher_handle();

@@ -310,10 +292,7 @@ TEST_F(TestQosEvent, add_to_wait_set) {
  // This callback requires some type of parameter, but it could be anything
  auto callback = [](int) {};

-  const rcl_publisher_event_type_t event_type =
-    !rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED) ?
-    RCL_PUBLISHER_MATCHED : RCL_PUBLISHER_OFFERED_DEADLINE_MISSED;
-
+  rcl_publisher_event_type_t event_type = RCL_PUBLISHER_OFFERED_DEADLINE_MISSED;
  rclcpp::EventHandler<decltype(callback), decltype(rcl_handle)> handler(
    callback, rcl_publisher_event_init, rcl_handle, event_type);

@@ -335,12 +314,6 @@ TEST_F(TestQosEvent, add_to_wait_set) {

 TEST_F(TestQosEvent, test_on_new_event_callback)
 {
-  if (!rmw_event_type_is_supported(RMW_EVENT_REQUESTED_DEADLINE_MISSED) ||
-    !rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED))
-  {
-    GTEST_SKIP();
-  }
-
  auto offered_deadline = rclcpp::Duration(std::chrono::milliseconds(1));
  auto requested_deadline = rclcpp::Duration(std::chrono::milliseconds(2));

@@ -386,21 +359,17 @@ TEST_F(TestQosEvent, test_invalid_on_new_event_callback)
  auto sub = node->create_subscription<test_msgs::msg::Empty>(topic_name, 10, message_callback);
  auto dummy_cb = [](size_t count_events) {(void)count_events;};

-  if (rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED) &&
-    rmw_event_type_is_supported(RMW_EVENT_LIVELINESS_LOST))
-  {
-    EXPECT_NO_THROW(
-      pub->set_on_new_qos_event_callback(dummy_cb, RCL_PUBLISHER_OFFERED_DEADLINE_MISSED));
+  EXPECT_NO_THROW(
+    pub->set_on_new_qos_event_callback(dummy_cb, RCL_PUBLISHER_OFFERED_DEADLINE_MISSED));

-    EXPECT_NO_THROW(
-      pub->clear_on_new_qos_event_callback(RCL_PUBLISHER_OFFERED_DEADLINE_MISSED));
+  EXPECT_NO_THROW(
+    pub->clear_on_new_qos_event_callback(RCL_PUBLISHER_OFFERED_DEADLINE_MISSED));

-    EXPECT_NO_THROW(
-      pub->set_on_new_qos_event_callback(dummy_cb, RCL_PUBLISHER_LIVELINESS_LOST));
+  EXPECT_NO_THROW(
+    pub->set_on_new_qos_event_callback(dummy_cb, RCL_PUBLISHER_LIVELINESS_LOST));

-    EXPECT_NO_THROW(
-      pub->clear_on_new_qos_event_callback(RCL_PUBLISHER_LIVELINESS_LOST));
-  }
+  EXPECT_NO_THROW(
+    pub->clear_on_new_qos_event_callback(RCL_PUBLISHER_LIVELINESS_LOST));

  EXPECT_NO_THROW(
    pub->set_on_new_qos_event_callback(dummy_cb, RCL_PUBLISHER_OFFERED_INCOMPATIBLE_QOS));
@@ -414,15 +383,11 @@ TEST_F(TestQosEvent, test_invalid_on_new_event_callback)
  EXPECT_NO_THROW(
    pub->clear_on_new_qos_event_callback(RCL_PUBLISHER_MATCHED));

-  if (rmw_event_type_is_supported(RMW_EVENT_REQUESTED_DEADLINE_MISSED) &&
-    rmw_event_type_is_supported(RMW_EVENT_LIVELINESS_CHANGED))
-  {
-    EXPECT_NO_THROW(
-      sub->set_on_new_qos_event_callback(dummy_cb, RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED));
+  EXPECT_NO_THROW(
+    sub->set_on_new_qos_event_callback(dummy_cb, RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED));

-    EXPECT_NO_THROW(
-      sub->clear_on_new_qos_event_callback(RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED));
-  }
+  EXPECT_NO_THROW(
+    sub->clear_on_new_qos_event_callback(RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED));

  EXPECT_NO_THROW(
    sub->set_on_new_qos_event_callback(dummy_cb, RCL_SUBSCRIPTION_LIVELINESS_CHANGED));
@@ -442,28 +407,24 @@ TEST_F(TestQosEvent, test_invalid_on_new_event_callback)
  EXPECT_NO_THROW(
    sub->clear_on_new_qos_event_callback(RCL_SUBSCRIPTION_MATCHED));

-  if (rmw_event_type_is_supported(RMW_EVENT_REQUESTED_DEADLINE_MISSED) &&
-    rmw_event_type_is_supported(RMW_EVENT_OFFERED_DEADLINE_MISSED))
-  {
-    std::function<void(size_t)> invalid_cb;
+  std::function<void(size_t)> invalid_cb;

-    rclcpp::SubscriptionOptions sub_options;
-    sub_options.event_callbacks.deadline_callback = [](auto) {};
-    sub = node->create_subscription<test_msgs::msg::Empty>(
-      topic_name, 10, message_callback, sub_options);
+  rclcpp::SubscriptionOptions sub_options;
+  sub_options.event_callbacks.deadline_callback = [](auto) {};
+  sub = node->create_subscription<test_msgs::msg::Empty>(
+    topic_name, 10, message_callback, sub_options);

-    EXPECT_THROW(
-      sub->set_on_new_qos_event_callback(invalid_cb, RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED),
-      std::invalid_argument);
+  EXPECT_THROW(
+    sub->set_on_new_qos_event_callback(invalid_cb, RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED),
+    std::invalid_argument);

-    rclcpp::PublisherOptions pub_options;
-    pub_options.event_callbacks.deadline_callback = [](auto) {};
-    pub = node->create_publisher<test_msgs::msg::Empty>(topic_name, 10, pub_options);
+  rclcpp::PublisherOptions pub_options;
+  pub_options.event_callbacks.deadline_callback = [](auto) {};
+  pub = node->create_publisher<test_msgs::msg::Empty>(topic_name, 10, pub_options);

-    EXPECT_THROW(
-      pub->set_on_new_qos_event_callback(invalid_cb, RCL_PUBLISHER_OFFERED_DEADLINE_MISSED),
-      std::invalid_argument);
-  }
+  EXPECT_THROW(
+    pub->set_on_new_qos_event_callback(invalid_cb, RCL_PUBLISHER_OFFERED_DEADLINE_MISSED),
+    std::invalid_argument);
 }

 TEST_F(TestQosEvent, test_pub_matched_event_by_set_event_callback)
--- a/rclcpp/test/rclcpp/test_ring_buffer_implementation.cpp
+++ b/rclcpp/test/rclcpp/test_ring_buffer_implementation.cpp
@@ -139,15 +139,3 @@ TEST(TestRingBufferImplementation, basic_usage_unique_ptr) {
  EXPECT_EQ(false, rb.has_data());
  EXPECT_EQ(false, rb.is_full());
 }
-
-TEST(TestRingBufferImplementation, handle_nullptr_deletion) {
-  rclcpp::experimental::buffers::RingBufferImplementation<std::unique_ptr<int>> rb(3);
-  rb.enqueue(std::make_unique<int>(42));
-  rb.enqueue(nullptr);  // intentionally enqueuing nullptr
-  rb.enqueue(std::make_unique<int>(84));
-  auto all_data = rb.get_all_data();
-  EXPECT_EQ(3u, all_data.size());
-  EXPECT_EQ(42, *(all_data[0]));
-  EXPECT_EQ(nullptr, all_data[1]);
-  EXPECT_EQ(84, *(all_data[2]));
-}
--- a/rclcpp/test/rclcpp/test_service.cpp
+++ b/rclcpp/test/rclcpp/test_service.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <string>
 #include <memory>
 #include <utility>
@@ -124,7 +123,7 @@ TEST_F(TestServiceSub, construction_and_destruction) {
  {
    ASSERT_THROW(
    {
-      auto service = subnode->create_service<rcl_interfaces::srv::ListParameters>(
+      auto service = node->create_service<rcl_interfaces::srv::ListParameters>(
        "invalid_service?", callback);
    }, rclcpp::exceptions::InvalidServiceNameError);
  }
@@ -336,7 +335,7 @@ TEST_F(TestService, rcl_service_request_subscription_get_actual_qos_error) {
 TEST_F(TestService, server_qos) {
  rclcpp::ServicesQoS qos_profile;
  qos_profile.liveliness(rclcpp::LivelinessPolicy::Automatic);
-  rclcpp::Duration duration(std::chrono::milliseconds(1));
+  rclcpp::Duration duration(std::chrono::nanoseconds(1));
  qos_profile.deadline(duration);
  qos_profile.lifespan(duration);
  qos_profile.liveliness_lease_duration(duration);
--- a/rclcpp/test/rclcpp/test_service_introspection.cpp
+++ b/rclcpp/test/rclcpp/test_service_introspection.cpp
@@ -15,7 +15,6 @@
 #include <rcl/service_introspection.h>
 #include <rmw/rmw.h>

-#include <chrono>
 #include <map>
 #include <string>

@@ -93,16 +92,9 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
  request->set__int64_value(42);

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
-
-  // Wait for the introspection to attach to our subscription
-  size_t tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);

  auto future = client->async_send_request(request);
  ASSERT_EQ(
@@ -157,11 +149,9 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
 TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
 {
  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_OFF);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
-
-  ASSERT_EQ(sub->get_publisher_count(), 0);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_OFF);

  auto request = std::make_shared<BasicTypes::Request>();
  request->set__bool_value(true);
@@ -179,16 +169,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
-
-  // Wait for the introspection to attach to our subscription
-  size_t tries = 1000;
-  while (this->sub->get_publisher_count() < 1 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 1u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_OFF);

  future = client->async_send_request(request);
  ASSERT_EQ(
@@ -203,16 +186,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_OFF);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
-
-  // Wait for the introspection to attach to our subscription
-  tries = 1000;
-  while (this->sub->get_publisher_count() < 1 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 1u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);

  future = client->async_send_request(request);
  ASSERT_EQ(
@@ -227,16 +203,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
-
-  // Wait for the introspection to attach to our subscription
-  tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);

  future = client->async_send_request(request);
  ASSERT_EQ(
@@ -252,16 +221,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
 TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_content)
 {
  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
-
-  // Wait for the introspection to attach to our subscription
-  size_t tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);

  auto request = std::make_shared<BasicTypes::Request>();
  request->set__bool_value(true);
@@ -283,16 +245,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
-
-  // Wait for the introspection to attach to our subscription
-  tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);

  future = client->async_send_request(request);
  ASSERT_EQ(
@@ -323,16 +278,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
-
-  // Wait for the introspection to attach to our subscription
-  tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);

  future = client->async_send_request(request);
  ASSERT_EQ(
@@ -363,16 +311,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
  events.clear();

  client->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
  service->configure_introspection(
-    node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);
-
-  // Wait for the introspection to attach to our subscription
-  tries = 1000;
-  while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  ASSERT_EQ(sub->get_publisher_count(), 2u);
+    node->get_clock(), rclcpp::SystemDefaultsQoS(), RCL_SERVICE_INTROSPECTION_CONTENTS);

  future = client->async_send_request(request);
  ASSERT_EQ(
--- a/rclcpp/test/rclcpp/test_subscription_options.cpp
+++ b/rclcpp/test/rclcpp/test_subscription_options.cpp
@@ -60,7 +60,7 @@ TEST_F(TestSubscriptionOptions, topic_statistics_options_default_and_set) {
  EXPECT_EQ(options.topic_stats_options.state, rclcpp::TopicStatisticsState::NodeDefault);
  EXPECT_EQ(options.topic_stats_options.publish_topic, defaultPublishTopic);
  EXPECT_EQ(options.topic_stats_options.publish_period, 1s);
-  EXPECT_EQ(options.topic_stats_options.qos, rclcpp::SystemDefaultsQoS().keep_last(10));
+  EXPECT_EQ(options.topic_stats_options.qos, rclcpp::SystemDefaultsQoS());

  options.topic_stats_options.state = rclcpp::TopicStatisticsState::Enable;
  options.topic_stats_options.publish_topic = "topic_statistics";
--- a/rclcpp/test/rclcpp/test_time.cpp
+++ b/rclcpp/test/rclcpp/test_time.cpp
@@ -138,6 +138,8 @@ TEST_F(TestTime, conversions) {

    EXPECT_ANY_THROW(rclcpp::Time(-1, 1));

+    EXPECT_ANY_THROW(rclcpp::Time(-1));
+
    EXPECT_ANY_THROW(
    {
      rclcpp::Time assignment(1, 2);
@@ -168,48 +170,6 @@ TEST_F(TestTime, conversions) {
    EXPECT_EQ(time_msg.nanosec, HALF_SEC_IN_NS);
    EXPECT_EQ(rclcpp::Time(time_msg).nanoseconds(), ONE_AND_HALF_SEC_IN_NS);
  }
-
-  {
-    // Can rclcpp::Time be negative or not? The following constructor works:
-    rclcpp::Time time(-HALF_SEC_IN_NS);
-    auto time_msg = static_cast<builtin_interfaces::msg::Time>(time);
-    EXPECT_EQ(time_msg.sec, -1);
-    EXPECT_EQ(time_msg.nanosec, HALF_SEC_IN_NS);
-
-    // The opposite conversion throws...
-    EXPECT_ANY_THROW(
-    {
-      rclcpp::Time negative_time(time_msg);
-    });
-  }
-
-  {
-    // Can rclcpp::Time be negative or not? The following constructor works:
-    rclcpp::Time time(-ONE_SEC_IN_NS);
-    auto time_msg = static_cast<builtin_interfaces::msg::Time>(time);
-    EXPECT_EQ(time_msg.sec, -1);
-    EXPECT_EQ(time_msg.nanosec, 0u);
-
-    // The opposite conversion throws...
-    EXPECT_ANY_THROW(
-    {
-      rclcpp::Time negative_time(time_msg);
-    });
-  }
-
-  {
-    // Can rclcpp::Time be negative or not? The following constructor works:
-    rclcpp::Time time(-ONE_AND_HALF_SEC_IN_NS);
-    auto time_msg = static_cast<builtin_interfaces::msg::Time>(time);
-    EXPECT_EQ(time_msg.sec, -2);
-    EXPECT_EQ(time_msg.nanosec, HALF_SEC_IN_NS);
-
-    // The opposite conversion throws...
-    EXPECT_ANY_THROW(
-    {
-      rclcpp::Time negative_time(time_msg);
-    });
-  }
 }

 TEST_F(TestTime, operators) {
@@ -326,31 +286,18 @@ 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);

-  // Cross min/max
+  // Cross max
  EXPECT_THROW(max_time + one, std::overflow_error);
-  EXPECT_THROW(min_time - one, std::underflow_error);
-  EXPECT_THROW(max_time - min_time, std::overflow_error);
-  EXPECT_THROW(min_time - max_time, std::underflow_error);
  EXPECT_THROW(rclcpp::Time(max_time) += one, std::overflow_error);
-  EXPECT_THROW(rclcpp::Time(min_time) -= one, std::underflow_error);
  EXPECT_NO_THROW(max_time - max_time);
-  EXPECT_NO_THROW(min_time - min_time);

-  // Cross zero in both directions
+  // Cross zero
  rclcpp::Time one_time(1);
-  EXPECT_NO_THROW(one_time - two);
-  EXPECT_NO_THROW(rclcpp::Time(one_time) -= two);
-
-  rclcpp::Time minus_one_time(-1);
-  EXPECT_NO_THROW(minus_one_time + two);
-  EXPECT_NO_THROW(rclcpp::Time(minus_one_time) += two);
-
-  EXPECT_NO_THROW(one_time - minus_one_time);
-  EXPECT_NO_THROW(minus_one_time - one_time);
+  EXPECT_THROW(one_time - two, std::runtime_error);
+  EXPECT_THROW(rclcpp::Time(one_time) -= two, std::runtime_error);

  rclcpp::Time two_time(2);
  EXPECT_NO_THROW(one_time - two_time);
@@ -432,41 +379,24 @@ TEST_F(TestTime, test_overflow_underflow_throws) {
  RCLCPP_EXPECT_THROW_EQ(
    test_time = rclcpp::Time(INT64_MAX) + rclcpp::Duration(1ns),
    std::overflow_error("addition leads to int64_t overflow"));
-  RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MIN) + rclcpp::Duration(-1ns),
-    std::underflow_error("addition leads to int64_t underflow"));

  RCLCPP_EXPECT_THROW_EQ(
    test_time = rclcpp::Time(INT64_MAX) - rclcpp::Duration(-1ns),
    std::overflow_error("time subtraction leads to int64_t overflow"));
-  RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Time(INT64_MIN) - rclcpp::Duration(1ns),
-    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),
    std::overflow_error("addition leads to int64_t overflow"));
-  test_time = rclcpp::Time(INT64_MIN);
-  RCLCPP_EXPECT_THROW_EQ(
-    test_time += rclcpp::Duration(-1ns),
-    std::underflow_error("addition leads to int64_t underflow"));

  test_time = rclcpp::Time(INT64_MAX);
  RCLCPP_EXPECT_THROW_EQ(
    test_time -= rclcpp::Duration(-1ns),
    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),
-    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),
    std::overflow_error("addition leads to int64_t overflow"));
-  RCLCPP_EXPECT_THROW_EQ(
-    test_time = rclcpp::Duration::from_nanoseconds(INT64_MIN) + rclcpp::Time(-1),
-    std::underflow_error("addition leads to int64_t underflow"));
 }

 class TestClockSleep : public ::testing::Test
--- a/rclcpp/test/rclcpp/test_wait_for_message.cpp
+++ b/rclcpp/test/rclcpp/test_wait_for_message.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>
@@ -108,29 +107,3 @@ TEST(TestUtilities, wait_for_message_twice_one_sub) {

  rclcpp::shutdown();
 }
-
-TEST(TestUtilities, wait_for_last_message) {
-  rclcpp::init(0, nullptr);
-
-  auto node = std::make_shared<rclcpp::Node>("wait_for_last_message_node");
-  auto qos = rclcpp::QoS(1).reliable().transient_local();
-
-  using MsgT = test_msgs::msg::Strings;
-  auto pub = node->create_publisher<MsgT>("wait_for_last_message_topic", qos);
-  pub->publish(*get_messages_strings()[0]);
-
-  MsgT out;
-  auto received = false;
-  auto wait = std::async(
-    [&]() {
-      auto ret = rclcpp::wait_for_message(out, node, "wait_for_last_message_topic", 5s, qos);
-      EXPECT_TRUE(ret);
-      received = true;
-    });
-
-  ASSERT_NO_THROW(wait.get());
-  ASSERT_TRUE(received);
-  EXPECT_EQ(out, *get_messages_strings()[0]);
-
-  rclcpp::shutdown();
-}
--- a/rclcpp_action/CHANGELOG.rst
+++ b/rclcpp_action/CHANGELOG.rst
@@ -3,62 +3,12 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^


-28.1.13 (2025-10-21)
--------------------
-* it misses the iterator second to lock the weakptr. (`#2958 <https://github.com/ros2/rclcpp/issues/2958>`_) (`#2960 <https://github.com/ros2/rclcpp/issues/2960>`_)
-* Contributors: mergify[bot]
-
-28.1.12 (2025-09-11)
--------------------
-
-28.1.11 (2025-08-06)
--------------------
-
-28.1.10 (2025-06-23)
--------------------
-* Replace std::default_random_engine with std::mt19937 (humble) (`#2847 <https://github.com/ros2/rclcpp/issues/2847>`_) (`#2867 <https://github.com/ros2/rclcpp/issues/2867>`_)
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2856 <https://github.com/ros2/rclcpp/issues/2856>`_)
-* Contributors: mergify[bot]
-
-28.1.9 (2025-04-23)
+28.3.0 (2024-06-17)
 -------------------
-* fix(rclcpp_action): Fix sleep of expire thread in case of canceled timer (`#2800 <https://github.com/ros2/rclcpp/issues/2800>`_)
-  This fixes a bug, that the expire action thread would not sleep as,
-  the sleep duration was not computed correctly.
-  Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com>
-* Contributors: Janosch Machowinski
+* Add 'mimick' label to tests which use Mimick (`#2516 <https://github.com/ros2/rclcpp/issues/2516>`_)
+* Contributors: Scott K Logan

-28.1.8 (2025-04-02)
-------------------
-* Harden rclcpp_action::convert(). (`#2786 <https://github.com/ros2/rclcpp/issues/2786>`_) (`#2789 <https://github.com/ros2/rclcpp/issues/2789>`_)
-  * Harden rclcpp_action::convert().
-  * update docstring.
-  ---------
-  (cherry picked from commit ce86ef7e621d96ce50d6ec1b49e9e1cd4f0a828b)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Contributors: mergify[bot]
-
-28.1.7 (2025-03-26)
-------------------
-* fix: Fixed expiring of goals if events executor is used (`#2674 <https://github.com/ros2/rclcpp/issues/2674>`_)
-* Contributors: Janosch Machowinski
-
-28.1.6 (2024-12-18)
-------------------
-
-28.1.5 (2024-09-19)
-------------------
-
-28.1.4 (2024-09-06)
-------------------
-
-28.1.3 (2024-06-27)
-------------------
-
-28.1.2 (2024-05-13)
-------------------
-
-28.1.1 (2024-04-24)
+28.2.0 (2024-04-26)
 -------------------

 28.1.0 (2024-04-16)
--- a/rclcpp_action/CMakeLists.txt
+++ b/rclcpp_action/CMakeLists.txt
@@ -80,6 +80,7 @@ if(BUILD_TESTING)
  add_subdirectory(test/benchmark)

  ament_add_gtest(test_client test/test_client.cpp TIMEOUT 180)
+  ament_add_test_label(test_client mimick)
  if(TARGET test_client)
    target_link_libraries(test_client
      ${PROJECT_NAME}
@@ -93,6 +94,7 @@ if(BUILD_TESTING)
  endif()

  ament_add_gtest(test_server test/test_server.cpp TIMEOUT 180)
+  ament_add_test_label(test_server mimick)
  if(TARGET test_server)
    target_link_libraries(test_server
      ${PROJECT_NAME}
@@ -104,6 +106,7 @@ if(BUILD_TESTING)
  endif()

  ament_add_gtest(test_server_goal_handle test/test_server_goal_handle.cpp)
+  ament_add_test_label(test_server_goal_handle mimick)
  if(TARGET test_server_goal_handle)
    target_link_libraries(test_server_goal_handle
      ${PROJECT_NAME}
--- a/rclcpp_action/include/rclcpp_action/client.hpp
+++ b/rclcpp_action/include/rclcpp_action/client.hpp
@@ -621,7 +621,7 @@ public:
        return;
      }

-      goal_handle = it->second.lock();
+      goal_handle = it->lock();
    }

    if (goal_handle) {
--- a/rclcpp_action/include/rclcpp_action/types.hpp
+++ b/rclcpp_action/include/rclcpp_action/types.hpp
@@ -39,22 +39,12 @@ RCLCPP_ACTION_PUBLIC
 std::string
 to_string(const GoalUUID & goal_id);

-/// Convert C++ GoalID to rcl_action_goal_info_t
-/**
- * \param[in] goal_id C++ GoalUUID reference to be converted.
- * \param[inout] info rcl_action_goal_info_t structure to be filled.
- * \throws std::runtime_error if info is null.
- */
+// Convert C++ GoalID to rcl_action_goal_info_t
 RCLCPP_ACTION_PUBLIC
 void
 convert(const GoalUUID & goal_id, rcl_action_goal_info_t * info);

-/// Convert rcl_action_goal_info_t to C++ GoalID
-/**
- * \param[in] info rcl_action_goal_info_t reference to be converted.
- * \param[inout] goal_id C++ GoalUUID structure to be filled.
- * \throws std::runtime_error if goal_id is null.
- */
+// Convert rcl_action_goal_info_t to C++ GoalID
 RCLCPP_ACTION_PUBLIC
 void
 convert(const rcl_action_goal_info_t & info, GoalUUID * goal_id);
--- a/rclcpp_action/package.xml
+++ b/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>28.1.13</version>
+  <version>28.3.0</version>
  <description>Adds action APIs for C++.</description>

  <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
--- a/rclcpp_action/src/client.cpp
+++ b/rclcpp_action/src/client.cpp
@@ -181,7 +181,7 @@ public:
  std::mutex cancel_requests_mutex;

  std::independent_bits_engine<
-    std::mt19937, 8, unsigned int> random_bytes_generator;
+    std::default_random_engine, 8, unsigned int> random_bytes_generator;
 };

 ClientBase::ClientBase(
--- a/rclcpp_action/src/server.cpp
+++ b/rclcpp_action/src/server.cpp
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include <inttypes.h>
 #include <memory>
 #include <mutex>
 #include <string>
@@ -82,146 +81,6 @@ public:
  {
  }

-  ~ServerBaseImpl()
-  {
-    stop_expire_thread();
-  }
-
-  std::recursive_mutex expire_thread_reentrant_mutex_;
-  std::thread expire_thread;
-
-  // must be a class member, so keep it in scope
-  std::function<void(size_t)> expire_reset_callback;
-
-  rclcpp::ClockConditionalVariable::SharedPtr expire_cv;
-  std::atomic<bool> expire_time_changed = false;
-  std::atomic<bool> terminate_expire_thread = true;
-
-  void
-  stop_expire_thread()
-  {
-    std::lock_guard<std::recursive_mutex> lock(expire_thread_reentrant_mutex_);
-    if(expire_cv) {
-      {
-        // Note, even though terminate_expire_thread is an atomic, we
-        // need to acquire the mutex, to avoid a race between the wait_until
-        // and the setting of this terminate_expire_thread
-        std::lock_guard<std::mutex> l(expire_cv->mutex());
-        terminate_expire_thread = true;
-      }
-      expire_cv->notify_one();
-      expire_thread.join();
-      expire_reset_callback = std::function<void(size_t)>();
-      expire_cv.reset();
-    }
-  }
-
-  void
-  start_expire_thread(std::function<void(size_t, int)> expire_ready_cb)
-  {
-    {
-      std::lock_guard<std::recursive_mutex> lock(expire_thread_reentrant_mutex_);
-      if(expire_cv) {
-        return;
-      }
-
-      terminate_expire_thread = false;
-      expire_cv = std::make_shared<rclcpp::ClockConditionalVariable>(clock_);
-    }
-
-    rclcpp::Context::SharedPtr context = rclcpp::contexts::get_global_default_context();
-    std::shared_ptr<rcl_context_t> rcl_context = context->get_rcl_context();
-
-    rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();
-    rcl_ret_t ret =
-      rcl_wait_set_init(&wait_set, num_subscriptions_, num_guard_conditions_, num_timers_,
-        num_clients_, num_services_, 0, rcl_context.get(), rcl_get_default_allocator());
-    if(ret != RCL_RET_OK) {
-      throw std::runtime_error("Internal error starting timer thread");
-    }
-
-    ret = rcl_action_wait_set_add_action_server(
-      &wait_set, action_server_.get(), NULL);
-    if (RCL_RET_OK != ret) {
-      rclcpp::exceptions::throw_from_rcl_error(ret, "ServerBase::add_to_wait_set() failed");
-    }
-
-    // extract the timer from the wait set
-    const rcl_timer_t *expire_timer = wait_set.timers[0];
-
-    // don't need the wait set any more
-    ret = rcl_wait_set_fini(&wait_set);
-
-    // the maybe_unused is needed here to satisfy cpplint
-    expire_reset_callback = [this] ([[maybe_unused]] size_t reset_calls)
-      {
-        {
-          std::lock_guard<std::mutex> l(expire_cv->mutex());
-          expire_time_changed = true;
-        }
-        expire_cv->notify_one();
-      };
-
-    rcl_event_callback_t rcl_reset_callback = rclcpp::detail::cpp_callback_trampoline<
-      decltype(expire_reset_callback), const void *, size_t>;
-
-    ret = rcl_timer_set_on_reset_callback(expire_timer, rcl_reset_callback,
-        static_cast<const void *>(&expire_reset_callback));
-    if (ret != RCL_RET_OK) {
-      rclcpp::exceptions::throw_from_rcl_error(ret, "Failed to set timer on reset callback");
-    }
-
-    expire_thread = std::thread([this, expire_timer, expire_ready_callback = expire_ready_cb]() {
-          rcl_clock_type_t clock_type = clock_->get_clock_type();
-
-          while(!terminate_expire_thread) {
-            {
-              std::unique_lock<std::mutex> l(expire_cv->mutex());
-
-              // reset to false, we are handling the time change right now
-              expire_time_changed = false;
-              int64_t time_until_call = 0;
-
-              auto ret2 = rcl_timer_get_time_until_next_call(expire_timer, &time_until_call);
-              if (ret2 == RCL_RET_TIMER_CANCELED) {
-                rclcpp::Duration endless(std::chrono::hours(100));
-                expire_cv->wait_until(l, clock_->now() + endless, [this] () -> bool {
-                  return expire_time_changed || terminate_expire_thread;
-                });
-                continue;
-              }
-
-              if(time_until_call > 0) {
-                rclcpp::Time next_wakeup(clock_->now().nanoseconds() + time_until_call, clock_type);
-                expire_cv->wait_until(l, next_wakeup, [this] () -> bool {
-                  return expire_time_changed || terminate_expire_thread;
-                });
-              }
-            }
-
-            // don't call expire callback if we are terminating
-            if(terminate_expire_thread) {
-              return;
-            }
-
-            bool is_ready = false;
-            if(rcl_timer_is_ready(expire_timer, &is_ready) == RCL_RET_OK && is_ready) {
-              // we need to cancel the timer here, to avoid a endless loop
-              // in case a new goal expires, the timer will be reset.
-              auto ret2 = rcl_timer_cancel(const_cast<rcl_timer_t *>(expire_timer));
-              if(ret2 != RCL_RET_OK) {
-                rclcpp::exceptions::throw_from_rcl_error(ret2, "Failed to cancel timer");
-              }
-
-              std::lock_guard<std::recursive_mutex> lock(expire_thread_reentrant_mutex_);
-              if(expire_ready_callback) {
-                expire_ready_callback(1, static_cast<int>(ServerBase::EntityType::Expired));
-              }
-            }
-          }
-      });
-  }
-
  // Lock for action_server_
  std::recursive_mutex action_server_reentrant_mutex_;

@@ -926,8 +785,6 @@ ServerBase::set_on_ready_callback(std::function<void(size_t, int)> callback)
            "is not callable.");
  }

-  pimpl_->start_expire_thread(callback);
-
  set_callback_to_entity(EntityType::GoalService, callback);
  set_callback_to_entity(EntityType::ResultService, callback);
  set_callback_to_entity(EntityType::CancelService, callback);
@@ -1048,7 +905,6 @@ ServerBase::clear_on_ready_callback()
    set_on_ready_callback(EntityType::GoalService, nullptr, nullptr);
    set_on_ready_callback(EntityType::ResultService, nullptr, nullptr);
    set_on_ready_callback(EntityType::CancelService, nullptr, nullptr);
-    pimpl_->stop_expire_thread();
    on_ready_callback_set_ = false;
  }

--- a/rclcpp_action/src/types.cpp
+++ b/rclcpp_action/src/types.cpp
@@ -41,9 +41,6 @@ to_string(const GoalUUID & goal_id)
 void
 convert(const GoalUUID & goal_id, rcl_action_goal_info_t * info)
 {
-  if (info == nullptr) {
-    throw std::invalid_argument("info is nullptr");
-  }
  for (size_t i = 0; i < UUID_SIZE; ++i) {
    info->goal_id.uuid[i] = goal_id[i];
  }
@@ -52,9 +49,6 @@ convert(const GoalUUID & goal_id, rcl_action_goal_info_t * info)
 void
 convert(const rcl_action_goal_info_t & info, GoalUUID * goal_id)
 {
-  if (goal_id == nullptr) {
-    throw std::invalid_argument("goal_id is nullptr");
-  }
  for (size_t i = 0; i < UUID_SIZE; ++i) {
    (*goal_id)[i] = info.goal_id.uuid[i];
  }
--- a/rclcpp_action/test/test_client.cpp
+++ b/rclcpp_action/test/test_client.cpp
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include <chrono>
 #include <future>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <thread>
+#include <chrono>

 #include "gtest/gtest.h"

--- a/rclcpp_action/test/test_types.cpp
+++ b/rclcpp_action/test/test_types.cpp
@@ -41,7 +41,6 @@ TEST(TestActionTypes, goal_uuid_to_rcl_action_goal_info) {
  for (uint8_t i = 0; i < UUID_SIZE; ++i) {
    goal_id[i] = i;
  }
-  ASSERT_THROW(rclcpp_action::convert(goal_id, nullptr), std::invalid_argument);
  rcl_action_goal_info_t goal_info = rcl_action_get_zero_initialized_goal_info();
  rclcpp_action::convert(goal_id, &goal_info);
  for (uint8_t i = 0; i < UUID_SIZE; ++i) {
@@ -55,7 +54,6 @@ TEST(TestActionTypes, rcl_action_goal_info_to_goal_uuid) {
    goal_info.goal_id.uuid[i] = i;
  }

-  ASSERT_THROW(rclcpp_action::convert(goal_info, nullptr), std::invalid_argument);
  rclcpp_action::GoalUUID goal_id;
  rclcpp_action::convert(goal_info, &goal_id);
  for (uint8_t i = 0; i < UUID_SIZE; ++i) {
--- a/rclcpp_components/CHANGELOG.rst
+++ b/rclcpp_components/CHANGELOG.rst
@@ -2,47 +2,10 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-28.1.13 (2025-10-21)
--------------------
-
-28.1.12 (2025-09-11)
--------------------
-
-28.1.11 (2025-08-06)
--------------------
-
-28.1.10 (2025-06-23)
--------------------
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2856 <https://github.com/ros2/rclcpp/issues/2856>`_)
-* Contributors: mergify[bot]
-
-28.1.9 (2025-04-23)
+28.3.0 (2024-06-17)
 -------------------

-28.1.8 (2025-04-02)
-------------------
-
-28.1.7 (2025-03-26)
-------------------
-* add NO_UNDEFINED_SYMBOLS to rclcpp_components_register_node cmake macro (`#2746 <https://github.com/ros2/rclcpp/issues/2746>`_)
-* Contributors: Jonas Otto
-
-28.1.6 (2024-12-18)
-------------------
-
-28.1.5 (2024-09-19)
-------------------
-
-28.1.4 (2024-09-06)
-------------------
-
-28.1.3 (2024-06-27)
-------------------
-
-28.1.2 (2024-05-13)
-------------------
-
-28.1.1 (2024-04-24)
+28.2.0 (2024-04-26)
 -------------------

 28.1.0 (2024-04-16)
--- a/rclcpp_components/cmake/rclcpp_components_register_node.cmake
+++ b/rclcpp_components/cmake/rclcpp_components_register_node.cmake
@@ -28,11 +28,9 @@
 # :type EXECUTOR: string
 # :param RESOURCE_INDEX: the ament resource index to register the components
 # :type RESOURCE_INDEX: string
-# :param NO_UNDEFINED_SYMBOLS: add linker flags to deny undefined symbols
-# :type NO_UNDEFINED_SYMBOLS: option
 #
 macro(rclcpp_components_register_node target)
-  cmake_parse_arguments(ARGS "NO_UNDEFINED_SYMBOLS" "PLUGIN;EXECUTABLE;EXECUTOR;RESOURCE_INDEX" "" ${ARGN})
+  cmake_parse_arguments(ARGS "" "PLUGIN;EXECUTABLE;EXECUTOR;RESOURCE_INDEX" "" ${ARGN})
  if(ARGS_UNPARSED_ARGUMENTS)
    message(FATAL_ERROR "rclcpp_components_register_node() called with unused "
      "arguments: ${ARGS_UNPARSED_ARGUMENTS}")
@@ -69,26 +67,6 @@ macro(rclcpp_components_register_node target)
    "${_RCLCPP_COMPONENTS_${resource_index}__NODES}${component};${_path}/$<TARGET_FILE_NAME:${target}>\n")
  list(APPEND _RCLCPP_COMPONENTS_PACKAGE_RESOURCE_INDICES ${resource_index})

-  if(ARGS_NO_UNDEFINED_SYMBOLS AND WIN32)
-    message(WARNING "NO_UNDEFINED_SYMBOLS is enabled for target \"${target}\", but this is unsupported on windows.")
-  elseif(ARGS_NO_UNDEFINED_SYMBOLS AND NOT WIN32)
-    check_cxx_compiler_flag("-Wl,--no-undefined" linker_supports_no_undefined)
-    if(linker_supports_no_undefined)
-      target_link_options("${target}" PRIVATE "-Wl,--no-undefined")
-    else()
-      message(WARNING "NO_UNDEFINED_SYMBOLS is enabled for target \"${target}\",\
-                but the linker does not support the \"--no-undefined\" flag.")
-    endif()
-
-    check_cxx_compiler_flag("-Wl,--no-allow-shlib-undefined" linker_supports_no_allow_shlib_undefined)
-    if(linker_supports_no_allow_shlib_undefined)
-      target_link_options("${target}" PRIVATE "-Wl,--no-allow-shlib-undefined")
-    else()
-      message(WARNING "NO_UNDEFINED_SYMBOLS is enabled for target \"${target}\",\
-                but the linker does not support the \"--no-allow-shlib-undefined\" flag.")
-    endif()
-  endif()
-
  configure_file(${rclcpp_components_NODE_TEMPLATE}
    ${PROJECT_BINARY_DIR}/rclcpp_components/node_main_configured_${node}.cpp.in)
  file(GENERATE OUTPUT ${PROJECT_BINARY_DIR}/rclcpp_components/node_main_${node}.cpp
--- a/rclcpp_components/package.xml
+++ b/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>28.1.13</version>
+  <version>28.3.0</version>
  <description>Package containing tools for dynamically loadable components</description>

  <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
--- a/rclcpp_components/test/test_component_manager_api.cpp
+++ b/rclcpp_components/test/test_component_manager_api.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <memory>
 #include <string>

--- a/rclcpp_lifecycle/CHANGELOG.rst
+++ b/rclcpp_lifecycle/CHANGELOG.rst
@@ -3,62 +3,17 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^


-28.1.13 (2025-10-21)
--------------------
-
-28.1.12 (2025-09-11)
--------------------
-* Clearer warning message, the old one lacked information and was perhaps misleading (`#2927 <https://github.com/ros2/rclcpp/issues/2927>`_) (`#2932 <https://github.com/ros2/rclcpp/issues/2932>`_)
-* Contributors: mergify[bot]
-
-28.1.11 (2025-08-06)
--------------------
-
-28.1.10 (2025-06-23)
--------------------
-* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_) (`#2856 <https://github.com/ros2/rclcpp/issues/2856>`_)
-* Contributors: mergify[bot]
-
-28.1.9 (2025-04-23)
+28.3.0 (2024-06-17)
 -------------------
+* revert call shutdown in LifecycleNode destructor (`#2557 <https://github.com/ros2/rclcpp/issues/2557>`_)
+* LifecycleNode shutdown on dtor only with valid context. (`#2545 <https://github.com/ros2/rclcpp/issues/2545>`_)
+* call shutdown in LifecycleNode dtor to avoid leaving the device in unknown state (2nd) (`#2528 <https://github.com/ros2/rclcpp/issues/2528>`_)
+* rclcpp::shutdown should not be called before LifecycleNode dtor. (`#2527 <https://github.com/ros2/rclcpp/issues/2527>`_)
+* Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in un… (`#2450 <https://github.com/ros2/rclcpp/issues/2450>`_)" (`#2522 <https://github.com/ros2/rclcpp/issues/2522>`_)
+* Add 'mimick' label to tests which use Mimick (`#2516 <https://github.com/ros2/rclcpp/issues/2516>`_)
+* Contributors: Chris Lalancette, Scott K Logan, Tomoya Fujita

-28.1.8 (2025-04-02)
-------------------
-* should pull valid transition before trying to change the state. (`#2774 <https://github.com/ros2/rclcpp/issues/2774>`_) (`#2784 <https://github.com/ros2/rclcpp/issues/2784>`_)
-  (cherry picked from commit 7b6ee8a2e7a13d73f9f69368970390a9e0930448)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Contributors: mergify[bot]
-
-28.1.7 (2025-03-26)
-------------------
-
-28.1.6 (2024-12-18)
-------------------
-
-28.1.5 (2024-09-19)
-------------------
-
-28.1.4 (2024-09-06)
-------------------
-
-28.1.3 (2024-06-27)
-------------------
-* Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in unknown state (2nd) (backport `#2528 <https://github.com/ros2/rclcpp/issues/2528>`_) (`#2542 <https://github.com/ros2/rclcpp/issues/2542>`_)" (`#2558 <https://github.com/ros2/rclcpp/issues/2558>`_)
-* call shutdown in LifecycleNode dtor to avoid leaving the device in unknown state (2nd) (backport `#2528 <https://github.com/ros2/rclcpp/issues/2528>`_) (`#2542 <https://github.com/ros2/rclcpp/issues/2542>`_)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* rclcpp::shutdown should not be called before LifecycleNode dtor. (`#2527 <https://github.com/ros2/rclcpp/issues/2527>`_) (`#2540 <https://github.com/ros2/rclcpp/issues/2540>`_)
-  Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>
-* Contributors: Tomoya Fujita, mergify[bot]
-
-28.1.2 (2024-05-13)
-------------------
-* Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in un… (`#2450 <https://github.com/ros2/rclcpp/issues/2450>`_)" (`#2522 <https://github.com/ros2/rclcpp/issues/2522>`_) (`#2524 <https://github.com/ros2/rclcpp/issues/2524>`_)
-  This reverts commit 04ea0bb00293387791522590b7347a2282cda290.
-  (cherry picked from commit 42b0b5775b4e68718c5949308c9e1a059930ded7)
-  Co-authored-by: Chris Lalancette <clalancette@gmail.com>
-* Contributors: mergify[bot]
-
-28.1.1 (2024-04-24)
+28.2.0 (2024-04-26)
 -------------------

 28.1.0 (2024-04-16)
--- a/rclcpp_lifecycle/CMakeLists.txt
+++ b/rclcpp_lifecycle/CMakeLists.txt
@@ -95,6 +95,7 @@ if(BUILD_TESTING)
  endif()

  ament_add_gtest(test_lifecycle_node test/test_lifecycle_node.cpp TIMEOUT 120)
+  ament_add_test_label(test_lifecycle_node mimick)
  if(TARGET test_lifecycle_node)
    target_link_libraries(test_lifecycle_node ${PROJECT_NAME} mimick rcl_lifecycle::rcl_lifecycle rclcpp::rclcpp rcutils::rcutils)
  endif()
@@ -103,6 +104,7 @@ if(BUILD_TESTING)
    target_link_libraries(test_lifecycle_publisher ${PROJECT_NAME} rcl_lifecycle::rcl_lifecycle rclcpp::rclcpp ${test_msgs_TARGETS})
  endif()
  ament_add_gtest(test_lifecycle_service_client test/test_lifecycle_service_client.cpp TIMEOUT 120)
+  ament_add_test_label(test_lifecycle_service_client mimick)
  if(TARGET test_lifecycle_service_client)
    target_link_libraries(test_lifecycle_service_client
      ${PROJECT_NAME}
@@ -113,6 +115,7 @@ if(BUILD_TESTING)
      rcutils::rcutils)
  endif()
  ament_add_gtest(test_client test/test_client.cpp TIMEOUT 120)
+  ament_add_test_label(test_client mimick)
  if(TARGET test_client)
    target_link_libraries(test_client
      ${PROJECT_NAME}
@@ -121,6 +124,7 @@ if(BUILD_TESTING)
      rclcpp::rclcpp)
  endif()
  ament_add_gtest(test_service test/test_service.cpp TIMEOUT 120)
+  ament_add_test_label(test_service mimick)
  if(TARGET test_service)
    target_link_libraries(test_service
      ${PROJECT_NAME}
@@ -145,6 +149,7 @@ if(BUILD_TESTING)
    target_link_libraries(test_state_wrapper ${PROJECT_NAME} rcl_lifecycle::rcl_lifecycle rclcpp::rclcpp)
  endif()
  ament_add_gtest(test_transition_wrapper test/test_transition_wrapper.cpp)
+  ament_add_test_label(test_transition_wrapper mimick)
  if(TARGET test_transition_wrapper)
    target_link_libraries(test_transition_wrapper ${PROJECT_NAME} mimick rcl_lifecycle::rcl_lifecycle rclcpp::rclcpp rcutils::rcutils)
    target_compile_definitions(test_transition_wrapper
--- a/rclcpp_lifecycle/package.xml
+++ b/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>28.1.13</version>
+  <version>28.3.0</version>
  <description>Package containing a prototype for lifecycle implementation</description>

  <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
--- a/rclcpp_lifecycle/src/lifecycle_node_interface_impl.cpp
+++ b/rclcpp_lifecycle/src/lifecycle_node_interface_impl.cpp
@@ -397,7 +397,6 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
  constexpr bool publish_update = true;
  State initial_state;
  unsigned int current_state_id;
-  const rcl_lifecycle_transition_t * original_transition{nullptr};

  {
    std::lock_guard<std::recursive_mutex> lock(state_machine_mutex_);
@@ -412,10 +411,6 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
    // keep the initial state to pass to a transition callback
    initial_state = State(state_machine_.current_state);

-    original_transition =
-      rcl_lifecycle_get_transition_by_id(state_machine_.current_state, transition_id);
-
-
    if (
      rcl_lifecycle_trigger_transition_by_id(
        &state_machine_, transition_id, publish_update) != RCL_RET_OK)
@@ -466,15 +461,12 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
  // Update the internal current_state_
  current_state_ = State(state_machine_.current_state);

-  // error handling
+  // error handling ?!
  // TODO(karsten1987): iterate over possible ret value
  if (cb_return_code == node_interfaces::LifecycleNodeInterface::CallbackReturn::ERROR) {
-    if (original_transition) {
-      RCLCPP_WARN(
-        node_logging_interface_->get_logger(),
-        "Callback returned ERROR during the transition: %s", original_transition->label);
-    }
-
+    RCLCPP_WARN(
+      node_logging_interface_->get_logger(),
+      "Error occurred while doing error handling.");

    auto error_cb_code = execute_callback(current_state_id, initial_state);
    auto error_cb_label = get_label_for_return_code(error_cb_code);
@@ -553,7 +545,9 @@ const State &
 LifecycleNode::LifecycleNodeInterfaceImpl::trigger_transition(uint8_t transition_id)
 {
  node_interfaces::LifecycleNodeInterface::CallbackReturn error;
-  return trigger_transition(transition_id, error);
+  change_state(transition_id, error);
+  (void) error;
+  return get_current_state();
 }

 const State &
@@ -561,16 +555,7 @@ LifecycleNode::LifecycleNodeInterfaceImpl::trigger_transition(
  uint8_t transition_id,
  node_interfaces::LifecycleNodeInterface::CallbackReturn & cb_return_code)
 {
-  const rcl_lifecycle_transition_t * transition;
-  {
-    std::lock_guard<std::recursive_mutex> lock(state_machine_mutex_);
-
-    transition =
-      rcl_lifecycle_get_transition_by_id(state_machine_.current_state, transition_id);
-  }
-  if (transition) {
-    change_state(static_cast<uint8_t>(transition->id), cb_return_code);
-  }
+  change_state(transition_id, cb_return_code);
  return get_current_state();
 }

--- a/rclcpp_lifecycle/test/benchmark/benchmark_lifecycle_client.cpp
+++ b/rclcpp_lifecycle/test/benchmark/benchmark_lifecycle_client.cpp
@@ -14,7 +14,6 @@

 #include <benchmark/benchmark.h>

-#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>
--- a/rclcpp_lifecycle/test/test_lifecycle_node.cpp
+++ b/rclcpp_lifecycle/test/test_lifecycle_node.cpp
@@ -14,7 +14,6 @@


 #include <gtest/gtest.h>
-#include <chrono>
 #include <map>
 #include <memory>
 #include <set>
@@ -299,146 +298,11 @@ TEST_F(TestDefaultStateMachine, trigger_transition) {
  ASSERT_EQ(
    State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
      rclcpp_lifecycle::Transition(Transition::TRANSITION_CLEANUP)).id());
-  // supposed to fail because primary state is NOT active
-  ASSERT_EQ(
-    State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-      rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVE_SHUTDOWN)).id());
-  // supposed to fail because primary state is NOT inactive
-  ASSERT_EQ(
-    State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-      rclcpp_lifecycle::Transition(Transition::TRANSITION_INACTIVE_SHUTDOWN)).id());
  ASSERT_EQ(
    State::PRIMARY_STATE_FINALIZED, test_node->trigger_transition(
      rclcpp_lifecycle::Transition(Transition::TRANSITION_UNCONFIGURED_SHUTDOWN)).id());
 }

-TEST_F(TestDefaultStateMachine, trigger_transition_shutdown_id) {
-  // test Transition::TRANSITION_ACTIVE_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVE_SHUTDOWN)).id());
-  }
-
-  // test Transition::TRANSITION_INACTIVE_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_DEACTIVATE)).id());
-    // supposed to fail because primary state is NOT active
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVE_SHUTDOWN)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_INACTIVE_SHUTDOWN)).id());
-  }
-
-  // test Transition::TRANSITION_UNCONFIGURED_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_DEACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CLEANUP)).id());
-    // supposed to fail because primary state is NOT active
-    ASSERT_EQ(
-      State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVE_SHUTDOWN)).id());
-    // supposed to fail because primary state is NOT inactive
-    ASSERT_EQ(
-      State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_INACTIVE_SHUTDOWN)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_UNCONFIGURED_SHUTDOWN)).id());
-  }
-}
-
-TEST_F(TestDefaultStateMachine, trigger_transition_shutdown_label) {
-  // test Transition::TRANSITION_ACTIVE_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->shutdown().id());
-  }
-
-  // test Transition::TRANSITION_INACTIVE_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_DEACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->shutdown().id());
-  }
-
-  // test Transition::TRANSITION_UNCONFIGURED_SHUTDOWN
-  {
-    auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");
-
-    EXPECT_EQ(State::PRIMARY_STATE_UNCONFIGURED, test_node->get_current_state().id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CONFIGURE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_ACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_ACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_INACTIVE, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_DEACTIVATE)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_UNCONFIGURED, test_node->trigger_transition(
-        rclcpp_lifecycle::Transition(Transition::TRANSITION_CLEANUP)).id());
-    ASSERT_EQ(
-      State::PRIMARY_STATE_FINALIZED, test_node->shutdown().id());
-  }
-}
-
 TEST_F(TestDefaultStateMachine, trigger_transition_rcl_errors) {
  auto test_node = std::make_shared<EmptyLifecycleNode>("testnode");

--- a/rclcpp_lifecycle/test/test_service.cpp
+++ b/rclcpp_lifecycle/test/test_service.cpp
@@ -14,7 +14,6 @@

 #include <gtest/gtest.h>

-#include <chrono>
 #include <string>
 #include <memory>
 #include <utility>
Author	SHA1	Message	Date
Chris Lalancette	5149a095c1	28.3.0	2024-06-17 14:23:03 +00:00
Chris Lalancette	16795dd8bf	Changelog. Signed-off-by: Chris Lalancette <clalancette@gmail.com>	2024-06-17 14:22:56 +00:00
Tomoya Fujita	f4923c6f43	revert call shutdown in LifecycleNode destructor (#2557 ) * Revert "LifecycleNode shutdown on dtor only with valid context. (#2545)" This reverts commit `d8d83a0ee6`. Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com> * Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in unknown state (2nd) (#2528)" This reverts commit `3bc364a10b`. Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com> --------- Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>	2024-06-11 07:41:09 -07:00
Alejandro Hernández Cordero	7c096888ca	Add test creating two content filter topics with the same topic name (#2546 ) (#2549 ) Signed-off-by: Mario-DL <mariodominguez@eprosima.com> Co-authored-by: Mario Domínguez López <116071334+Mario-DL@users.noreply.github.com>	2024-06-04 16:22:38 -07:00
Tomoya Fujita	d8d83a0ee6	LifecycleNode shutdown on dtor only with valid context. (#2545 ) Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>	2024-05-30 14:57:17 -07:00
Tomoya Fujita	3bc364a10b	call shutdown in LifecycleNode dtor to avoid leaving the device in unknown state (2nd) (#2528 ) * Revert "Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in un… (#2450)" (#2522)" This reverts commit `42b0b5775b`. Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com> * lifecycle node dtor shutdown should be called only in primary state. Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com> * adjust warning message if the node is still in transition state in dtor. Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com> --------- Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>	2024-05-29 09:40:49 -07:00
Tomoya Fujita	22df1d593a	rclcpp::shutdown should not be called before LifecycleNode dtor. (#2527 ) Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>	2024-05-23 17:53:35 -07:00
William Woodall	343b29b617	add impl pointer for ExecutorOptions (#2523 ) * add impl pointer for ExecutorOptions Signed-off-by: William Woodall <william@osrfoundation.org>	2024-05-09 16:32:44 -04:00
Chris Lalancette	42b0b5775b	Revert "call shutdown in LifecycleNode dtor to avoid leaving the device in un… (#2450 )" (#2522 ) This reverts commit `04ea0bb002`.	2024-05-09 07:34:04 -04:00
William Woodall	f7185dc129	Fixup Executor::spin_all() regression fix (#2517 ) * test(Executors): Added tests for busy waiting Checks if executors are busy waiting while they should block in spin_some or spin_all. Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> * fix: Reworked spinAll test This test was strange. It looked like, it assumed that spin_all did not return instantly. Also it was racy, as the thread could terminate instantly. Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> * fix(Executor): Fixed spin_all not returning instantly is no work was available Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> * Update rclcpp/test/rclcpp/executors/test_executors.cpp Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com> Signed-off-by: jmachowinski <jmachowinski@users.noreply.github.com> * test(executors): Added test for busy waiting while calling spin Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> * fix(executor): Reset wait_result on every call to spin_some_impl Before, the method would not recollect available work in case of spin_some, spin_all. This would lead to the method behaving differently than to what the documentation states. Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> * restore previous test logic for now Signed-off-by: William Woodall <william@osrfoundation.org> * refactor spin_some_impl's logic and improve busy wait tests Signed-off-by: William Woodall <william@osrfoundation.org> * added some more comments about the implementation Signed-off-by: William Woodall <william@osrfoundation.org> --------- Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com> Signed-off-by: jmachowinski <jmachowinski@users.noreply.github.com> Signed-off-by: William Woodall <william@osrfoundation.org> Co-authored-by: Janosch Machowinski <J.Machowinski@cellumation.com> Co-authored-by: jmachowinski <jmachowinski@users.noreply.github.com> Co-authored-by: Tomoya Fujita <Tomoya.Fujita@sony.com>	2024-05-02 14:06:10 -07:00
Scott K Logan	5f912eb58e	Add 'mimick' label to tests which use Mimick (#2516 ) Signed-off-by: Scott K Logan <logans@cottsay.net>	2024-04-29 16:09:43 -05:00
Marco A. Gutierrez	2cd8900dd2	28.2.0	2024-04-26 16:57:57 +00:00
Marco A. Gutierrez	cf6141330a	Changelog. Signed-off-by: Marco A. Gutierrez <marcogg@marcogg.com>	2024-04-26 16:57:52 +00:00
Sharmin Ramli	de666d2bf4	Check for negative time in rclcpp::Time(int64_t nanoseconds, ...) constructor (#2510 ) Signed-off-by: Nursharmin Ramli <nursharminramli@gmail.com>	2024-04-23 22:47:56 +02:00
Barry Xu	55939613a0	Revise the description of service configure_introspection() (#2511 ) Signed-off-by: Barry Xu <barry.xu@sony.com>	2024-04-23 13:29:46 +02:00