diff --git a/rclcpp/include/rclcpp/publisher.hpp b/rclcpp/include/rclcpp/publisher.hpp
index 407e8266bc..e1a409976e 100644
--- a/rclcpp/include/rclcpp/publisher.hpp
+++ b/rclcpp/include/rclcpp/publisher.hpp
@@ -319,11 +319,6 @@ class Publisher : public PublisherBase
   >
   publish(std::unique_ptr<T, PublishedTypeDeleter> msg)
   {
-    // TODO(wjwwood): later update this to give the unique_ptr to the intra
-    // process manager and let it decide if it needs to be converted or not.
-    // For now, convert it unconditionally and pass it the ROSMessageType
-    // publish function specialization.
-
     // Avoid allocating when not using intra process.
     if (!intra_process_is_enabled_) {
       // In this case we're not using intra process.
@@ -337,6 +332,9 @@ class Publisher : public PublisherBase
 
     if (inter_process_publish_needed) {
       auto shared_msg = this->do_intra_process_publish_and_return_shared(std::move(msg));
+      // TODO(clalancette): This is unnecessarily doing an additional conversion
+      // that may have already been done in do_intra_process_publish_and_return_shared().
+      // We should just reuse that effort.
       ROSMessageType ros_msg;
       rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(*msg, ros_msg);
       this->do_inter_process_publish(ros_msg);
@@ -363,12 +361,7 @@ class Publisher : public PublisherBase
   >
   publish(const T & msg)
   {
-    // TODO(wjwwood): later update this to give the unique_ptr to the intra
-    // process manager and let it decide if it needs to be converted or not.
-    // For now, convert it unconditionally and pass it the ROSMessageType
-    // publish function specialization.
-
-    // Avoid allocating when not using intra process.
+    // Avoid double allocating when not using intra process.
     if (!intra_process_is_enabled_) {
       // Convert to the ROS message equivalent and publish it.
       ROSMessageType ros_msg;
@@ -376,13 +369,12 @@ class Publisher : public PublisherBase
       // In this case we're not using intra process.
       return this->do_inter_process_publish(ros_msg);
     }
-    // Otherwise we have to allocate memory in a unique_ptr, convert it,
-    // and pass it along.
+
+    // Otherwise we have to allocate memory in a unique_ptr and pass it along.
     // As the message is not const, a copy should be made.
     // A shared_ptr<const MessageT> could also be constructed here.
-    auto unique_ros_msg = this->create_ros_message_unique_ptr();
-    rclcpp::TypeAdapter<MessageT>::convert_to_ros_message(msg, *unique_ros_msg);
-    this->publish(std::move(unique_ros_msg));
+    auto unique_msg = this->duplicate_type_adapt_message_as_unique_ptr(msg);
+    this->publish(std::move(unique_msg));
   }
 
   void
@@ -603,6 +595,15 @@ class Publisher : public PublisherBase
     return std::unique_ptr<ROSMessageType, ROSMessageTypeDeleter>(ptr, ros_message_type_deleter_);
   }
 
+  /// Duplicate a given type adapted message as a unique_ptr.
+  std::unique_ptr<PublishedType, PublishedTypeDeleter>
+  duplicate_type_adapt_message_as_unique_ptr(const PublishedType & msg)
+  {
+    auto ptr = PublishedTypeAllocatorTraits::allocate(published_type_allocator_, 1);
+    PublishedTypeAllocatorTraits::construct(published_type_allocator_, ptr, msg);
+    return std::unique_ptr<PublishedType, PublishedTypeDeleter>(ptr, published_type_deleter_);
+  }
+
   /// Copy of original options passed during construction.
   /**
    * It is important to save a copy of this so that the rmw payload which it
diff --git a/rclcpp/test/rclcpp/test_subscription_publisher_with_same_type_adapter.cpp b/rclcpp/test/rclcpp/test_subscription_publisher_with_same_type_adapter.cpp
index 036fa11359..77c4207b43 100644
--- a/rclcpp/test/rclcpp/test_subscription_publisher_with_same_type_adapter.cpp
+++ b/rclcpp/test/rclcpp/test_subscription_publisher_with_same_type_adapter.cpp
@@ -16,63 +16,21 @@
 #include <gtest/gtest.h>
 
 #include <chrono>
-#include <functional>
 #include <memory>
+#include <stdexcept>
 #include <string>
-#include <thread>
+#include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "rclcpp/exceptions.hpp"
-#include "rclcpp/loaned_message.hpp"
 #include "rclcpp/rclcpp.hpp"
 
-#include "../mocking_utils/patch.hpp"
-#include "../utils/rclcpp_gtest_macros.hpp"
-
-#include "test_msgs/msg/empty.hpp"
 #include "rclcpp/msg/string.hpp"
 
-
-#ifdef RMW_IMPLEMENTATION
-# define CLASSNAME_(NAME, SUFFIX) NAME ## __ ## SUFFIX
-# define CLASSNAME(NAME, SUFFIX) CLASSNAME_(NAME, SUFFIX)
-#else
-# define CLASSNAME(NAME, SUFFIX) NAME
-#endif
-
-
-using namespace std::chrono_literals;
-
 static const int g_max_loops = 200;
 static const std::chrono::milliseconds g_sleep_per_loop(10);
 
-
-class TestSubscriptionPublisher : public ::testing::Test
-{
-public:
-  static void SetUpTestCase()
-  {
-    if (!rclcpp::ok()) {
-      rclcpp::init(0, nullptr);
-    }
-  }
-
-protected:
-  void initialize(const rclcpp::NodeOptions & node_options = rclcpp::NodeOptions())
-  {
-    node = std::make_shared<rclcpp::Node>("my_node", "/ns", node_options);
-  }
-
-  void TearDown()
-  {
-    node.reset();
-  }
-
-  rclcpp::Node::SharedPtr node;
-};
-
-class CLASSNAME (test_intra_process_within_one_node, RMW_IMPLEMENTATION) : public ::testing::Test
+class test_intra_process_within_one_node : public ::testing::Test
 {
 public:
   static void SetUpTestCase()
@@ -137,8 +95,9 @@ void wait_for_message_to_be_received(
  * Testing that subscriber receives type adapted types and ROS message types with intra proccess communications.
  */
 TEST_F(
-  CLASSNAME(test_intra_process_within_one_node, RMW_IMPLEMENTATION),
-  check_type_adapted_messages_are_received_by_intra_process_subscription) {
+  test_intra_process_within_one_node,
+  type_adapted_messages_unique_pub_received_by_intra_process_subscription)
+{
   using StringTypeAdapter = rclcpp::TypeAdapter<std::string, rclcpp::msg::String>;
   const std::string message_data = "Message Data";
   const std::string topic_name = "topic_name";
@@ -149,45 +108,409 @@ TEST_F(
 
   auto pub = node->create_publisher<StringTypeAdapter>(topic_name, 1);
 
-  {
-    { // std::unique_ptr<std::string>
-      bool is_received = false;
-      auto callback =
-        [message_data, &is_received](
-        std::unique_ptr<std::string> msg) -> void {
-          is_received = true;
-          ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
-        };
-      auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
-
-      std::cout << "LALA" << std::endl;
-
-      auto pu_message = std::make_unique<std::string>(message_data);
-      pub->publish(std::move(pu_message));
-
-      ASSERT_FALSE(is_received);
-      std::cout << "LALA TO BE RECEIVED" << std::endl;
-      wait_for_message_to_be_received(is_received, node);
-      ASSERT_TRUE(is_received);
-    }
-    { // std::unique_ptr<std::string> with message info
-      bool is_received = false;
-      auto callback =
-        [message_data, &is_received](
-        std::unique_ptr<std::string> msg,
-        const rclcpp::MessageInfo & message_info) -> void {
-          is_received = true;
-          ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
-          ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
-        };
-      auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
-
-      auto pu_message = std::make_unique<std::string>(message_data);
-      pub->publish(std::move(pu_message));
-
-      ASSERT_FALSE(is_received);
-      wait_for_message_to_be_received(is_received, node);
-      ASSERT_TRUE(is_received);
-    }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::string &, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::string & msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), msg.c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::string & with message info, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::string & msg, const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), msg.c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::unique_ptr<std::string>, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::unique_ptr<std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::unique_ptr<std::string> with message info, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::unique_ptr<std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<std::string>, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<std::string> with message info, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<const std::string>, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<const std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<const std::string> with message info, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<const std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::shared_ptr<const std::string> &, publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::shared_ptr<const std::string> & msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::shared_ptr<const std::string> & with message info,
+    // publish with unique_ptr
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::shared_ptr<const std::string> & msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    auto pu_message = std::make_unique<std::string>(message_data);
+    pub->publish(std::move(pu_message));
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+}
+
+TEST_F(
+  test_intra_process_within_one_node,
+  type_adapted_messages_const_ref_pub_received_by_intra_process_subscription)
+{
+  using StringTypeAdapter = rclcpp::TypeAdapter<std::string, rclcpp::msg::String>;
+  const std::string message_data = "Message Data";
+  const std::string topic_name = "topic_name";
+
+  auto node = rclcpp::Node::make_shared(
+    "test_intra_process",
+    rclcpp::NodeOptions().use_intra_process_comms(true));
+
+  auto pub = node->create_publisher<StringTypeAdapter>(topic_name, 1);
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::string &, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::string & msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), msg.c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::string & with message info, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::string & msg, const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), msg.c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::unique_ptr<std::string>, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::unique_ptr<std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::unique_ptr<std::string> with message info, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::unique_ptr<std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<std::string>, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<std::string> with message info, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<const std::string>, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<const std::string> msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback std::shared_ptr<const std::string> with message info,
+    // publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      std::shared_ptr<const std::string> msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::shared_ptr<const std::string> &, publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::shared_ptr<const std::string> & msg) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
+  }
+  { // create_publisher with TypeAdapt struct, create_subscription with TypeAdapt struct,
+    // callback const std::shared_ptr<const std::string> & with message info,
+    // publish with const std::string &
+    bool is_received = false;
+    auto callback =
+      [message_data, &is_received](
+      const std::shared_ptr<const std::string> & msg,
+      const rclcpp::MessageInfo & message_info) -> void {
+        is_received = true;
+        ASSERT_STREQ(message_data.c_str(), (*msg).c_str());
+        ASSERT_TRUE(message_info.get_rmw_message_info().from_intra_process);
+      };
+    auto sub = node->create_subscription<StringTypeAdapter>(topic_name, 1, callback);
+
+    std::string pu_message(message_data);
+    pub->publish(pu_message);
+
+    ASSERT_FALSE(is_received);
+    wait_for_message_to_be_received(is_received, node);
+    ASSERT_TRUE(is_received);
   }
 }