Split test_subscriber into multiple compilation units. (#500)

* Split test_subscriber and test_publisher_subscriber into multiple compilation units.

This should avoid an OOM error when compiling on the buildfarm.

Signed-off-by: Chris Lalancette <[email protected]>

Author: clalancette

test_communication/CMakeLists.txt

@@ -416,9 +416,18 @@ if(BUILD_TESTING)
     endforeach()
   endmacro()
 
+  add_library(subscribe_types STATIC
+    "test/subscribe_array_types.cpp"
+    "test/subscribe_basic_types.cpp"
+    "test/subscribe_string_types.cpp")
+  ament_target_dependencies(subscribe_types
+    "rclcpp"
+    "test_msgs")
+
   # publisher combined with a subscriber
   custom_executable(test_publisher_subscriber_cpp
     "test/test_publisher_subscriber.cpp")
+  target_link_libraries(test_publisher_subscriber_cpp subscribe_types)
   # subcription valid data
   custom_executable(test_subscription_valid_data_cpp
     "test/test_subscription_valid_data.cpp")
@@ -427,6 +436,7 @@ if(BUILD_TESTING)
     "test/test_publisher.cpp")
   custom_executable(test_subscriber_cpp
     "test/test_subscriber.cpp")
+  target_link_libraries(test_subscriber_cpp subscribe_types)
   # executables requester / replier
   custom_executable(test_requester_cpp
     "test/test_requester.cpp")

test_communication/test/subscribe_array_types.cpp

@@ -0,0 +1,87 @@
+// Copyright 2015 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 <string>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+#include "test_msgs/msg/arrays.hpp"
+#include "test_msgs/msg/unbounded_sequences.hpp"
+#include "test_msgs/msg/bounded_plain_sequences.hpp"
+#include "test_msgs/msg/bounded_sequences.hpp"
+#include "test_msgs/msg/multi_nested.hpp"
+#include "test_msgs/msg/nested.hpp"
+
+#include "subscribe_array_types.hpp"
+#include "subscribe_helper.hpp"
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_arrays(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Arrays::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Arrays>(
+    node, message_type, expected_messages, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_unbounded_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::UnboundedSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::UnboundedSequences>(
+    node, message_type, expected_messages, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_bounded_plain_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BoundedPlainSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::BoundedPlainSequences>(
+    node, message_type, expected_messages, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_bounded_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BoundedSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::BoundedSequences>(
+    node, message_type, expected_messages, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_multi_nested(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::MultiNested::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::MultiNested>(
+    node, message_type, expected_messages, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_nested(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Nested::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Nested>(
+    node, message_type, expected_messages, received_messages);
+}

test_communication/test/subscribe_array_types.hpp

@@ -0,0 +1,65 @@
+// Copyright 2015 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 SUBSCRIBE_ARRAY_TYPES_HPP_
+#define SUBSCRIBE_ARRAY_TYPES_HPP_
+
+#include <string>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+#include "test_msgs/msg/arrays.hpp"
+#include "test_msgs/msg/unbounded_sequences.hpp"
+#include "test_msgs/msg/bounded_plain_sequences.hpp"
+#include "test_msgs/msg/bounded_sequences.hpp"
+#include "test_msgs/msg/multi_nested.hpp"
+#include "test_msgs/msg/nested.hpp"
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_arrays(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Arrays::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_unbounded_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::UnboundedSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_bounded_plain_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BoundedPlainSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_bounded_sequences(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BoundedSequences::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_multi_nested(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::MultiNested::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_nested(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Nested::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages);
+
+#endif  // SUBSCRIBE_ARRAY_TYPES_HPP_

test_communication/test/subscribe_basic_types.cpp

@@ -0,0 +1,75 @@
+// Copyright 2015 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 <string>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+#include "test_msgs/msg/empty.hpp"
+#include "test_msgs/msg/basic_types.hpp"
+#include "test_msgs/msg/builtins.hpp"
+#include "test_msgs/msg/constants.hpp"
+#include "test_msgs/msg/defaults.hpp"
+
+#include "subscribe_basic_types.hpp"
+#include "subscribe_helper.hpp"
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_empty(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Empty::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Empty>(node, message_type, messages_expected, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_basic_types(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BasicTypes::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::BasicTypes>(
+    node, message_type, messages_expected, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_builtins(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Builtins::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Builtins>(
+    node, message_type, messages_expected, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_constants(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Constants::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Constants>(
+    node, message_type, messages_expected, received_messages);
+}
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_defaults(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Defaults::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages)
+{
+  return subscribe<test_msgs::msg::Defaults>(
+    node, message_type, messages_expected, received_messages);
+}

test_communication/test/subscribe_basic_types.hpp

@@ -0,0 +1,58 @@
+// Copyright 2015 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 SUBSCRIBE_BASIC_TYPES_HPP_
+#define SUBSCRIBE_BASIC_TYPES_HPP_
+
+#include <string>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+#include "test_msgs/msg/empty.hpp"
+#include "test_msgs/msg/basic_types.hpp"
+#include "test_msgs/msg/builtins.hpp"
+#include "test_msgs/msg/constants.hpp"
+#include "test_msgs/msg/defaults.hpp"
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_empty(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Empty::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_basic_types(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::BasicTypes::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_builtins(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Builtins::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_constants(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Constants::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages);
+
+rclcpp::SubscriptionBase::SharedPtr subscribe_defaults(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<test_msgs::msg::Defaults::SharedPtr> & messages_expected,
+  std::vector<bool> & received_messages);
+
+#endif  // SUBSCRIBE_BASIC_TYPES_HPP_

test_communication/test/subscribe_helper.hpp

@@ -0,0 +1,72 @@
+// Copyright 2015 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 SUBSCRIBE_HELPER_HPP_
+#define SUBSCRIBE_HELPER_HPP_
+
+#include <cstdio>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+
+template<typename T>
+rclcpp::SubscriptionBase::SharedPtr subscribe(
+  rclcpp::Node::SharedPtr node,
+  const std::string & message_type,
+  const std::vector<typename T::SharedPtr> & expected_messages,
+  std::vector<bool> & received_messages)
+{
+  received_messages.assign(expected_messages.size(), false);
+
+  auto callback =
+    [&expected_messages, &received_messages](
+    const typename T::ConstSharedPtr received_message
+    ) -> void
+    {
+      // find received message in vector of expected messages
+      auto received = received_messages.begin();
+      bool known_message = false;
+      size_t index = 0;
+      for (auto expected_message : expected_messages) {
+        if (*received_message == *expected_message) {
+          *received = true;
+          printf("received message #%zu of %zu\n", index + 1, expected_messages.size());
+          known_message = true;
+          break;
+        }
+        ++received;
+        ++index;
+      }
+      if (!known_message) {
+        throw std::runtime_error("received message does not match any expected message");
+      }
+
+      // shutdown node when all expected messages have been received
+      for (auto received_msg : received_messages) {
+        if (!received_msg) {
+          return;
+        }
+      }
+      rclcpp::shutdown();
+    };
+
+  auto qos = rclcpp::QoS(rclcpp::KeepLast(expected_messages.size()));
+
+  return
+    node->create_subscription<T>(std::string("test/message/") + message_type, qos, callback);
+}
+
+#endif  // SUBSCRIBE_HELPER_HPP_