From 5c260ddbbe169b3a7ee189a154542ebe2d14bf80 Mon Sep 17 00:00:00 2001 From: Michel Hidalgo Date: Fri, 18 Sep 2020 17:28:03 -0300 Subject: [PATCH 1/4] Bump graph API test coverage. Test all query APIs with bad arguments. Signed-off-by: Michel Hidalgo --- test_rmw_implementation/CMakeLists.txt | 10 + .../test/test_graph_api.cpp | 808 ++++++++++++++++++ 2 files changed, 818 insertions(+) create mode 100644 test_rmw_implementation/test/test_graph_api.cpp diff --git a/test_rmw_implementation/CMakeLists.txt b/test_rmw_implementation/CMakeLists.txt index f2c6ba36..da42e0f2 100644 --- a/test_rmw_implementation/CMakeLists.txt +++ b/test_rmw_implementation/CMakeLists.txt @@ -87,6 +87,16 @@ if(BUILD_TESTING) ament_target_dependencies(test_serialize_deserialize${target_suffix} rcutils rmw rmw_implementation test_msgs ) + + ament_add_gtest(test_graph_api${target_suffix} + test/test_graph_api.cpp + ENV ${rmw_implementation_env_var} + ) + target_compile_definitions(test_graph_api${target_suffix} + PUBLIC "RMW_IMPLEMENTATION=${rmw_implementation}") + ament_target_dependencies(test_graph_api${target_suffix} + osrf_testing_tools_cpp rcutils rmw rmw_implementation + ) endmacro() call_for_each_rmw_implementation(test_api) diff --git a/test_rmw_implementation/test/test_graph_api.cpp b/test_rmw_implementation/test/test_graph_api.cpp new file mode 100644 index 00000000..4ce5ea0b --- /dev/null +++ b/test_rmw_implementation/test/test_graph_api.cpp @@ -0,0 +1,808 @@ +// Copyright 2020 Open Source Robotics Foundation, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include "osrf_testing_tools_cpp/scope_exit.hpp" + +#include "rcutils/allocator.h" +#include "rcutils/strdup.h" + +#include "rmw/error_handling.h" +#include "rmw/get_node_info_and_types.h" +#include "rmw/get_service_names_and_types.h" +#include "rmw/get_topic_endpoint_info.h" +#include "rmw/get_topic_names_and_types.h" +#include "rmw/rmw.h" +#include "rmw/sanity_checks.h" + +#include "./config.hpp" +#include "./testing_macros.hpp" + +#ifdef RMW_IMPLEMENTATION +# define CLASSNAME_(NAME, SUFFIX) NAME ## __ ## SUFFIX +# define CLASSNAME(NAME, SUFFIX) CLASSNAME_(NAME, SUFFIX) +#else +# define CLASSNAME(NAME, SUFFIX) NAME +#endif + +class CLASSNAME (TestGraphAPI, RMW_IMPLEMENTATION) : public ::testing::Test +{ +protected: + void SetUp() override + { + rmw_init_options_t init_options = rmw_get_zero_initialized_init_options(); + rmw_ret_t ret = rmw_init_options_init(&init_options, rcutils_get_default_allocator()); + ASSERT_EQ(RMW_RET_OK, ret) << rcutils_get_error_string().str; + OSRF_TESTING_TOOLS_CPP_SCOPE_EXIT( + { + rmw_ret_t ret = rmw_init_options_fini(&init_options); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + }); + init_options.enclave = rcutils_strdup("/", rcutils_get_default_allocator()); + ASSERT_STREQ("/", init_options.enclave); + ret = rmw_init(&init_options, &context); + ASSERT_EQ(RMW_RET_OK, ret) << rcutils_get_error_string().str; + node = rmw_create_node(&context, node_name, node_namespace); + ASSERT_NE(nullptr, node) << rcutils_get_error_string().str; + other_node = rmw_create_node(&context, node_name, node_namespace); + ASSERT_NE(nullptr, other_node) << rcutils_get_error_string().str; + } + + void TearDown() override + { + rmw_ret_t ret = rmw_destroy_node(other_node); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_destroy_node(node); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_shutdown(&context); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_context_fini(&context); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + } + + rmw_context_t context{rmw_get_zero_initialized_context()}; + rmw_node_t * node{nullptr}; + const char * const node_name = "my_test_node"; + const char * const node_namespace = "/my_test_ns"; + rmw_node_t * other_node{nullptr}; + const char * const other_node_name = "my_other_test_node"; + const char * const other_node_namespace = "/my_other_test_ns"; +}; + +TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), get_node_names_with_bad_arguments) { + rcutils_string_array_t node_names = rcutils_get_zero_initialized_string_array(); + rcutils_string_array_t node_namespaces = rcutils_get_zero_initialized_string_array(); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(nullptr, &node_names, &node_namespaces)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, nullptr, &node_namespaces)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, nullptr)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, + rmw_get_node_names(node, &node_names, &node_namespaces)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_names, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, &node_namespaces)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_names)) << rmw_get_error_string().str; + + ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_namespaces, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, &node_namespaces)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_namespaces)) << rmw_get_error_string().str; +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_node_names_with_enclaves_with_bad_arguments) { + rcutils_string_array_t node_names = rcutils_get_zero_initialized_string_array(); + rcutils_string_array_t node_namespaces = rcutils_get_zero_initialized_string_array(); + rcutils_string_array_t enclaves = rcutils_get_zero_initialized_string_array(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + nullptr, &node_names, &node_namespaces, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, nullptr, &node_namespaces, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, &node_names, nullptr, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, &node_names, &node_namespaces, nullptr)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_node_names_with_enclaves( + node, &node_names, &node_namespaces, &enclaves)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_names, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, &node_names, &node_namespaces, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_names)) << rmw_get_error_string().str; + + ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_namespaces, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, &node_names, &node_namespaces, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); + EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_namespaces)) << rmw_get_error_string().str; + + ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&enclaves, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( + node, &node_names, &node_namespaces, &enclaves)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); + EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&enclaves)) << rmw_get_error_string().str; +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_topic_names_and_types_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); + bool no_demangle = false; + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + nullptr, &allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, nullptr, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, &invalid_allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, &allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << + rmw_get_error_string().str; + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_topic_names_and_types( + node, &allocator, no_demangle, &topic_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_service_names_and_types_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); + bool no_demangle = false; + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + nullptr, &allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, nullptr, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, &invalid_allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( + node, &allocator, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << + rmw_get_error_string().str; + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_topic_names_and_types( + node, &allocator, no_demangle, &topic_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_subscriber_names_and_types_by_node_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); + bool no_demangle = false; + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + rmw_reset_error(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + constexpr char invalid_node_name[] = "not a not valid node name !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + rmw_reset_error(); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << + rmw_get_error_string().str; + + constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; + EXPECT_EQ( + RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_subscriber_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_publisher_names_and_types_by_node_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); + bool no_demangle = false; + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + rmw_reset_error(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + constexpr char invalid_node_name[] = "not a not valid node name !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, no_demangle, &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + rmw_reset_error(); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << + rmw_get_error_string().str; + + constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; + EXPECT_EQ( + RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_publisher_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, no_demangle, + &topic_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_service_names_and_types_by_node_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, nullptr)); + rmw_reset_error(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + constexpr char invalid_node_name[] = "not a not valid node name !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, nullptr)); + rmw_reset_error(); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << + rmw_get_error_string().str; + + constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; + EXPECT_EQ( + RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_service_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_client_names_and_types_by_node_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, nullptr)); + rmw_reset_error(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + constexpr char invalid_node_name[] = "not a not valid node name !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, nullptr)); + rmw_reset_error(); + + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << + rmw_get_error_string().str; + + constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; + EXPECT_EQ( + RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_client_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + &service_names_and_types)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_publishers_info_by_topic_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + constexpr char topic_name[] = "/test_topic"; + bool no_mangle = false; + rmw_topic_endpoint_info_array_t publishers_info = + rmw_get_zero_initialized_topic_endpoint_info_array(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + nullptr, &allocator, topic_name, no_mangle, &publishers_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_publishers_info_by_topic( + node, &allocator, topic_name, no_mangle, &publishers_info)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + node, nullptr, topic_name, no_mangle, &publishers_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + node, &invalid_allocator, topic_name, no_mangle, &publishers_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + node, &allocator, nullptr, no_mangle, &publishers_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + node, &allocator, topic_name, no_mangle, nullptr)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + + ASSERT_EQ( + RMW_RET_OK, + rmw_topic_endpoint_info_array_init_with_size(&publishers_info, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( + node, &allocator, topic_name, no_mangle, &publishers_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_fini(&publishers_info, &allocator)) << + rmw_get_error_string().str; +} + +TEST_F( + CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), + get_subscriptions_info_by_topic_with_bad_arguments) { + rcutils_allocator_t allocator = rcutils_get_default_allocator(); + constexpr char topic_name[] = "/test_topic"; + bool no_mangle = false; + rmw_topic_endpoint_info_array_t subscriptions_info = + rmw_get_zero_initialized_topic_endpoint_info_array(); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + nullptr, &allocator, topic_name, no_mangle, &subscriptions_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ( + RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_subscriptions_info_by_topic( + node, &allocator, topic_name, no_mangle, &subscriptions_info)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + node, nullptr, topic_name, no_mangle, &subscriptions_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + node, &invalid_allocator, topic_name, no_mangle, &subscriptions_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + node, &allocator, nullptr, no_mangle, &subscriptions_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + node, &allocator, topic_name, no_mangle, nullptr)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + + ASSERT_EQ( + RMW_RET_OK, + rmw_topic_endpoint_info_array_init_with_size(&subscriptions_info, 1u, &allocator)) << + rmw_get_error_string().str; + EXPECT_EQ( + RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( + node, &allocator, topic_name, no_mangle, &subscriptions_info)); + rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_fini(&subscriptions_info, &allocator)) << + rmw_get_error_string().str; +} + +TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), count_publishers_with_bad_arguments) { + size_t count = 0u; + constexpr char topic_name[] = "/test_topic"; + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(nullptr, topic_name, &count)); + rmw_reset_error(); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_count_publishers(node, topic_name, &count)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, nullptr, &count)); + rmw_reset_error(); + + constexpr char invalid_topic_name[] = "not a valid topic name !"; + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, invalid_topic_name, &count)); + rmw_reset_error(); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, topic_name, nullptr)); + rmw_reset_error(); +} + +TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), count_subscribers_with_bad_arguments) { + size_t count = 0u; + constexpr char topic_name[] = "/test_topic"; + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(nullptr, topic_name, &count)); + rmw_reset_error(); + + const char * implementation_identifier = node->implementation_identifier; + node->implementation_identifier = "not-an-rmw-implementation-identifier"; + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_count_subscribers(node, topic_name, &count)); + node->implementation_identifier = implementation_identifier; + rmw_reset_error(); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, nullptr, &count)); + rmw_reset_error(); + + constexpr char invalid_topic_name[] = "not a valid topic name !"; + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, invalid_topic_name, &count)); + rmw_reset_error(); + + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, topic_name, nullptr)); + rmw_reset_error(); +} From d1947633e49b24dd0e86af90f6e5ccd816057eb3 Mon Sep 17 00:00:00 2001 From: Michel Hidalgo Date: Fri, 18 Sep 2020 20:17:09 -0300 Subject: [PATCH 2/4] Bump test timeout. Signed-off-by: Michel Hidalgo --- test_rmw_implementation/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/test_rmw_implementation/CMakeLists.txt b/test_rmw_implementation/CMakeLists.txt index da42e0f2..1a9c834c 100644 --- a/test_rmw_implementation/CMakeLists.txt +++ b/test_rmw_implementation/CMakeLists.txt @@ -91,6 +91,7 @@ if(BUILD_TESTING) ament_add_gtest(test_graph_api${target_suffix} test/test_graph_api.cpp ENV ${rmw_implementation_env_var} + TIMEOUT 120 ) target_compile_definitions(test_graph_api${target_suffix} PUBLIC "RMW_IMPLEMENTATION=${rmw_implementation}") From 4435c5127612bc123a93ff1963762f68ed036ee7 Mon Sep 17 00:00:00 2001 From: Michel Hidalgo Date: Mon, 21 Sep 2020 15:22:45 -0300 Subject: [PATCH 3/4] Address peer review comments. Signed-off-by: Michel Hidalgo --- .../test/test_graph_api.cpp | 721 ++++++++++-------- 1 file changed, 414 insertions(+), 307 deletions(-) diff --git a/test_rmw_implementation/test/test_graph_api.cpp b/test_rmw_implementation/test/test_graph_api.cpp index 4ce5ea0b..8b607d8a 100644 --- a/test_rmw_implementation/test/test_graph_api.cpp +++ b/test_rmw_implementation/test/test_graph_api.cpp @@ -84,42 +84,53 @@ class CLASSNAME (TestGraphAPI, RMW_IMPLEMENTATION) : public ::testing::Test TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), get_node_names_with_bad_arguments) { rcutils_string_array_t node_names = rcutils_get_zero_initialized_string_array(); rcutils_string_array_t node_namespaces = rcutils_get_zero_initialized_string_array(); - EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(nullptr, &node_names, &node_namespaces)); + + // A null node is an invalid argument. + rmw_ret ret = rmw_get_node_names(nullptr, &node_names, &node_namespaces); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); - EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, nullptr, &node_namespaces)); + // A null array of node names is an invalid argument. + ret = rmw_get_node_names(node, nullptr, &node_namespaces); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); - EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, nullptr)); + // A null array of node namespaces is an invalid argument. + ret = rmw_get_node_names(node, &node_names, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + // A node from a different implementation cannot be used. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, - rmw_get_node_names(node, &node_names, &node_namespaces)); + ret = rmw_get_node_names(node, &node_names, &node_namespaces); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + // A non zero initialized array of node names is an invalid argument. rcutils_allocator_t allocator = rcutils_get_default_allocator(); - ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_names, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, &node_namespaces)); + ret = rcutils_string_array_init(&node_names, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_node_names(node, &node_names, &node_namespaces); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_names)) << rmw_get_error_string().str; - ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_namespaces, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_get_node_names(node, &node_names, &node_namespaces)); + // A non zero initialized array of node namespaces is an invalid argument. + ret = rcutils_string_array_init(&node_namespaces, 1u, &allocator) + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_node_names(node, &node_names, &node_namespaces); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_namespaces)) << rmw_get_error_string().str; @@ -131,40 +142,42 @@ TEST_F( rcutils_string_array_t node_names = rcutils_get_zero_initialized_string_array(); rcutils_string_array_t node_namespaces = rcutils_get_zero_initialized_string_array(); rcutils_string_array_t enclaves = rcutils_get_zero_initialized_string_array(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - nullptr, &node_names, &node_namespaces, &enclaves)); + + // A null node is an invalid argument. + rmw_ret_t ret = + rmw_get_node_names_with_enclaves(nullptr, &node_names, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, nullptr, &node_namespaces, &enclaves)); + // A null array of node names is an invalid argument. + ret = rmw_get_node_names_with_enclaves(node, nullptr, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, &node_names, nullptr, &enclaves)); + // A null array of node namespaces is an invalid argument. + ret = rmw_get_node_names_with_enclaves(node, &node_names, nullptr, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, &node_names, &node_namespaces, nullptr)); + // A null array of enclaves is an invalid argument. + ret = rmw_get_node_names_with_enclaves(node, &node_names, &node_namespaces, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); + // A node from a different implementation cannot be used. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_node_names_with_enclaves( - node, &node_names, &node_namespaces, &enclaves)); + ret = rmw_get_node_names_with_enclaves(node, &node_names, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); @@ -172,35 +185,38 @@ TEST_F( EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); rcutils_allocator_t allocator = rcutils_get_default_allocator(); - ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_names, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, &node_names, &node_namespaces, &enclaves)); + // A non zero initialized array of node names is an invalid argument. + ret = rcutils_string_array_init(&node_names, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_node_names_with_enclaves(node, &node_names, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); - EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_names)) << rmw_get_error_string().str; + ret = rcutils_string_array_fini(&node_names); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; - ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&node_namespaces, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, &node_names, &node_namespaces, &enclaves)); + // A non zero initialized array of node namespaces is an invalid argument. + ret = rcutils_string_array_init(&node_namespaces, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_node_names_with_enclaves(node, &node_names, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&enclaves)); - EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_namespaces)) << rmw_get_error_string().str; + ret = rcutils_string_array_fini(&node_namespaces); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; - ASSERT_EQ(RMW_RET_OK, rcutils_string_array_init(&enclaves, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_node_names_with_enclaves( - node, &node_names, &node_namespaces, &enclaves)); + // A non zero initialized array of enclaves is an invalid argument. + ret = rcutils_string_array_init(&enclaves, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_node_names_with_enclaves(node, &node_names, &node_namespaces, &enclaves); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); - EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&enclaves)) << rmw_get_error_string().str; + ret = rcutils_string_array_fini(&enclaves); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; } TEST_F( @@ -210,39 +226,41 @@ TEST_F( rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); bool no_demangle = false; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - nullptr, &allocator, no_demangle, &topic_names_and_types)); + // A null node is an invalid argument. + rmw_ret_t ret = + rmw_get_topic_names_and_types(nullptr, &allocator, no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, nullptr, no_demangle, &topic_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_topic_names_and_types(node, nullptr, no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, &invalid_allocator, no_demangle, &topic_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. + ret = rmw_get_topic_names_and_types( + node, &invalid_allocator, no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, &allocator, no_demangle, &topic_names_and_types)); + // A non zero initialized array of topic names and types is an invalid argument. + ret = rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_topic_names_and_types(node, &allocator, no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&topic_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + // A node from a different implementation cannot be used. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_topic_names_and_types( - node, &allocator, no_demangle, &topic_names_and_types)); + ret = rmw_get_topic_names_and_types(node, &allocator, no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); } @@ -251,42 +269,44 @@ TEST_F( CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), get_service_names_and_types_with_bad_arguments) { rcutils_allocator_t allocator = rcutils_get_default_allocator(); - rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); + rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); bool no_demangle = false; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - nullptr, &allocator, no_demangle, &topic_names_and_types)); + // A null node is an invalid argument. + rmw_ret_t ret = + rmw_get_service_names_and_types(nullptr, &allocator, no_demangle, &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, nullptr, no_demangle, &topic_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_service_names_and_types(node, nullptr, no_demangle, &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, &invalid_allocator, no_demangle, &topic_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. + ret = rmw_get_service_names_and_types( + node, &invalid_allocator, no_demangle, &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << + // A non zero initialized array of service names and types is an invalid argument. + ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_topic_names_and_types( - node, &allocator, no_demangle, &topic_names_and_types)); + ret = rmw_get_service_names_and_types(node, &allocator, no_demangle, &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << rmw_get_error_string().str; + // A node from a different implementation cannot be used. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_topic_names_and_types( - node, &allocator, no_demangle, &topic_names_and_types)); + ret = rmw_get_service_names_and_types(node, &allocator, no_demangle, &service_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); } @@ -298,83 +318,100 @@ TEST_F( rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); bool no_demangle = false; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - nullptr, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + // A null node is an invalid argument. + rmw_ret_t ret = rmw_get_subscriber_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, nullptr, other_node_name, other_node_namespace, no_demangle, &topic_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_subscriber_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &invalid_allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + ret = rmw_get_subscriber_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, nullptr, other_node_namespace, no_demangle, &topic_names_and_types)); + // A null node name is an invalid argument. + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid node name is an invalid argument. constexpr char invalid_node_name[] = "not a not valid node name !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, invalid_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, other_node_name, nullptr, no_demangle, &topic_names_and_types)); + // A null node name is an invalid argument. + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid node namespace is an invalid argument. constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, other_node_name, invalid_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + // A null array of topic names and types is an invalid argument. + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + // A non zero initialized array of topic names and types is an invalid argument. + ret = rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&topic_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + // A non existent node cannot be queried. constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; - EXPECT_EQ( - RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_subscriber_names_and_types_by_node( - node, &allocator, nonexistent_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_subscriber_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_NODE_NAME_NON_EXISTENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); } @@ -386,83 +423,100 @@ TEST_F( rmw_names_and_types_t topic_names_and_types = rmw_get_zero_initialized_names_and_types(); bool no_demangle = false; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - nullptr, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + // A null node is an invalid argument. + ret = rmw_get_publisher_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_publisher_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, nullptr, other_node_name, other_node_namespace, no_demangle, &topic_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_publisher_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &invalid_allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + ret = rmw_get_publisher_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, nullptr, other_node_namespace, no_demangle, &topic_names_and_types)); + // A null node name is an invalid argument. + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid node name is an invalid argument. constexpr char invalid_node_name[] = "not a not valid node name !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, invalid_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, other_node_name, nullptr, no_demangle, &topic_names_and_types)); + // A null node namespace is an invalid argument. + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); + // An invalid node namespace is an invalid argument. constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, other_node_name, invalid_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, nullptr)); + // A null array of topic names and types is an invalid argument. + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + // A non zero initialized array of topic names and types is an invalid argument. + ret = rmw_names_and_types_init(&topic_names_and_types, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&topic_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&topic_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + // A non existent node cannot be queried. constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; - EXPECT_EQ( - RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_publisher_names_and_types_by_node( - node, &allocator, nonexistent_node_name, other_node_namespace, no_demangle, - &topic_names_and_types)); + ret = rmw_get_publisher_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + no_demangle, &topic_names_and_types); + EXPECT_EQ(RMW_RET_NODE_NAME_NON_EXISTENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&topic_names_and_types)); } @@ -473,81 +527,99 @@ TEST_F( rcutils_allocator_t allocator = rcutils_get_default_allocator(); rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - nullptr, &allocator, other_node_name, other_node_namespace, - &service_names_and_types)); + // A null node is an invalid argument. + rmw_ret_t ret = rmw_get_service_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_service_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, nullptr, other_node_name, other_node_namespace, &service_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_service_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &invalid_allocator, other_node_name, other_node_namespace, nullptr)); + ret = rmw_get_service_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, nullptr, other_node_namespace, &service_names_and_types)); + // A null node name is an invalid argument. + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid node name is an invalid argument. constexpr char invalid_node_name[] = "not a not valid node name !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, invalid_node_name, other_node_namespace, - &service_names_and_types)); + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, other_node_name, nullptr, &service_names_and_types)); + // A null node namespace is an invalid argument. + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid node namespace is an invalid argument. constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, other_node_name, invalid_node_namespace, - &service_names_and_types)); + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, nullptr)); + // A null array of service names and types is an invalid argument. + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_service_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + // A non zero initialized array of service names and types is an invalid argument. + ret = rmw_names_and_types_init(&service_names_and_types, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&service_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + // A non existent node cannot be queried. constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; - EXPECT_EQ( - RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_service_names_and_types_by_node( - node, &allocator, nonexistent_node_name, other_node_namespace, - &service_names_and_types)); + ret = rmw_get_service_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_NODE_NAME_NON_EXISTENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); } @@ -558,81 +630,99 @@ TEST_F( rcutils_allocator_t allocator = rcutils_get_default_allocator(); rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - nullptr, &allocator, other_node_name, other_node_namespace, - &service_names_and_types)); + // A null node is an invalid argument. + rmw_ret_t ret = rmw_get_client_names_and_types_by_node( + nullptr, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_client_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, nullptr, other_node_name, other_node_namespace, &service_names_and_types)); + // A null allocator is an invalid argument. + ret = rmw_get_client_names_and_types_by_node( + node, nullptr, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &invalid_allocator, other_node_name, other_node_namespace, nullptr)); + ret = rmw_get_client_names_and_types_by_node( + node, &invalid_allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); + EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, nullptr, other_node_namespace, &service_names_and_types)); + // A null node name is an invalid argument. + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, nullptr, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid node name is an invalid argument. constexpr char invalid_node_name[] = "not a not valid node name !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, invalid_node_name, other_node_namespace, - &service_names_and_types)); + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, invalid_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, other_node_name, nullptr, &service_names_and_types)); + // A null node namespace is an invalid argument. + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, nullptr, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); + // An invalid node namespace is an invalid argument. constexpr char invalid_node_namespace[] = "not a not valid node namespace !"; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, other_node_name, invalid_node_namespace, - &service_names_and_types)); + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, invalid_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, nullptr)); + // A null array of service names and types is an invalid argument. + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_client_names_and_types_by_node( - node, &allocator, other_node_name, other_node_namespace, &service_names_and_types)); + // A non zero initialized array of service names and types is an invalid argument. + ret = rmw_names_and_types_init(&service_names_and_types, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, other_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&service_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + // A non existent node cannot be queried. constexpr char nonexistent_node_name[] = "a_test_node_that_does_not_exist"; - EXPECT_EQ( - RMW_RET_NODE_NAME_NON_EXISTENT, rmw_get_client_names_and_types_by_node( - node, &allocator, nonexistent_node_name, other_node_namespace, - &service_names_and_types)); + ret = rmw_get_client_names_and_types_by_node( + node, &allocator, nonexistent_node_name, other_node_namespace, + &service_names_and_types); + EXPECT_EQ(RMW_RET_NODE_NAME_NON_EXISTENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); } @@ -646,56 +736,59 @@ TEST_F( rmw_topic_endpoint_info_array_t publishers_info = rmw_get_zero_initialized_topic_endpoint_info_array(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - nullptr, &allocator, topic_name, no_mangle, &publishers_info)); + // A null node is an invalid argument. + rmw_ret_t ret = rmw_get_publishers_info_by_topic( + nullptr, &allocator, topic_name, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + // A node from a different implementation is an invalid argument. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_publishers_info_by_topic( - node, &allocator, topic_name, no_mangle, &publishers_info)); + ret = rmw_get_publishers_info_by_topic( + node, &allocator, topic_name, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - node, nullptr, topic_name, no_mangle, &publishers_info)); + // A null allocator is an invalid argument. + ret = rmw_get_publishers_info_by_topic(node, nullptr, topic_name, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - node, &invalid_allocator, topic_name, no_mangle, &publishers_info)); + ret = rmw_get_publishers_info_by_topic( + node, &invalid_allocator, topic_name, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - node, &allocator, nullptr, no_mangle, &publishers_info)); + // A null topic name is an invalid argument. + ret = rmw_get_publishers_info_by_topic( + node, &allocator, nullptr, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - node, &allocator, topic_name, no_mangle, nullptr)); + // A null array of topic endpoint info is an invalid argument. + ret = rmw_get_publishers_info_by_topic(node, &allocator, topic_name, no_mangle, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&publishers_info)); - ASSERT_EQ( - RMW_RET_OK, - rmw_topic_endpoint_info_array_init_with_size(&publishers_info, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_publishers_info_by_topic( - node, &allocator, topic_name, no_mangle, &publishers_info)); + // A non zero initialized array of topic endpoint info is an invalid argument. + ret = rmw_topic_endpoint_info_array_init_with_size(&publishers_info, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_publishers_info_by_topic( + node, &allocator, topic_name, no_mangle, &publishers_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_fini(&publishers_info, &allocator)) << - rmw_get_error_string().str; + ret = rmw_topic_endpoint_info_array_fini(&publishers_info, &allocator); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; } TEST_F( @@ -707,78 +800,87 @@ TEST_F( rmw_topic_endpoint_info_array_t subscriptions_info = rmw_get_zero_initialized_topic_endpoint_info_array(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - nullptr, &allocator, topic_name, no_mangle, &subscriptions_info)); + // A null node is an invalid argument. + rmw_ret_t ret = rmw_get_subscriptions_info_by_topic( + nullptr, &allocator, topic_name, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + // A node from a different implementation is an invalid argument. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - EXPECT_EQ( - RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_get_subscriptions_info_by_topic( - node, &allocator, topic_name, no_mangle, &subscriptions_info)); + ret = rmw_get_subscriptions_info_by_topic( + node, &allocator, topic_name, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - node, nullptr, topic_name, no_mangle, &subscriptions_info)); + // A null allocator is an invalid argument. + ret = rmw_get_subscriptions_info_by_topic( + node, nullptr, topic_name, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); + // An invalid (zero initialized) allocator is an invalid argument. rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - node, &invalid_allocator, topic_name, no_mangle, &subscriptions_info)); + ret = rmw_get_subscriptions_info_by_topic( + node, &invalid_allocator, topic_name, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - node, &allocator, nullptr, no_mangle, &subscriptions_info)); + // A null topic name is an invalid argument. + ret = rmw_get_subscriptions_info_by_topic( + node, &allocator, nullptr, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - node, &allocator, topic_name, no_mangle, nullptr)); + // A null array of topic endpoint info is an invalid argument. + ret = rmw_get_subscriptions_info_by_topic(node, &allocator, topic_name, no_mangle, nullptr); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_check_zero(&subscriptions_info)); - ASSERT_EQ( - RMW_RET_OK, - rmw_topic_endpoint_info_array_init_with_size(&subscriptions_info, 1u, &allocator)) << - rmw_get_error_string().str; - EXPECT_EQ( - RMW_RET_INVALID_ARGUMENT, rmw_get_subscriptions_info_by_topic( - node, &allocator, topic_name, no_mangle, &subscriptions_info)); + // A non zero initialized array of topic endpoint info is an invalid argument. + ret = rmw_topic_endpoint_info_array_init_with_size(&subscriptions_info, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rmw_get_subscriptions_info_by_topic( + node, &allocator, topic_name, no_mangle, &subscriptions_info); + EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_topic_endpoint_info_array_fini(&subscriptions_info, &allocator)) << - rmw_get_error_string().str; + ret = rmw_topic_endpoint_info_array_fini(&subscriptions_info, &allocator); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; } TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), count_publishers_with_bad_arguments) { size_t count = 0u; constexpr char topic_name[] = "/test_topic"; + // A null node is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(nullptr, topic_name, &count)); rmw_reset_error(); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_count_publishers(node, topic_name, &count)); node->implementation_identifier = implementation_identifier; rmw_reset_error(); + // A null topic name is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, nullptr, &count)); rmw_reset_error(); + // An invalid topic name is an invalid argument. constexpr char invalid_topic_name[] = "not a valid topic name !"; EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, invalid_topic_name, &count)); rmw_reset_error(); + // A null count is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_publishers(node, topic_name, nullptr)); rmw_reset_error(); } @@ -787,22 +889,27 @@ TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), count_subscribers_with_bad_a size_t count = 0u; constexpr char topic_name[] = "/test_topic"; + // A null node is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(nullptr, topic_name, &count)); rmw_reset_error(); + // A node from a different implementation cannot be used to query. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, rmw_count_subscribers(node, topic_name, &count)); node->implementation_identifier = implementation_identifier; rmw_reset_error(); + // A null topic name is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, nullptr, &count)); rmw_reset_error(); + // An invalid topic name is an invalid argument. constexpr char invalid_topic_name[] = "not a valid topic name !"; EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, invalid_topic_name, &count)); rmw_reset_error(); + // A null count is an invalid argument. EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, rmw_count_subscribers(node, topic_name, nullptr)); rmw_reset_error(); } From e97c9ed61a84b8257a7157c4369e3244840e1257 Mon Sep 17 00:00:00 2001 From: Michel Hidalgo Date: Mon, 21 Sep 2020 15:34:15 -0300 Subject: [PATCH 4/4] Minor fixes. Signed-off-by: Michel Hidalgo --- .../test/test_graph_api.cpp | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/test_rmw_implementation/test/test_graph_api.cpp b/test_rmw_implementation/test/test_graph_api.cpp index 8b607d8a..128e4c66 100644 --- a/test_rmw_implementation/test/test_graph_api.cpp +++ b/test_rmw_implementation/test/test_graph_api.cpp @@ -86,7 +86,7 @@ TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), get_node_names_with_bad_argu rcutils_string_array_t node_namespaces = rcutils_get_zero_initialized_string_array(); // A null node is an invalid argument. - rmw_ret ret = rmw_get_node_names(nullptr, &node_names, &node_namespaces); + rmw_ret_t ret = rmw_get_node_names(nullptr, &node_names, &node_namespaces); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); @@ -124,16 +124,18 @@ TEST_F(CLASSNAME(TestGraphAPI, RMW_IMPLEMENTATION), get_node_names_with_bad_argu EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_namespaces)); - EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_names)) << rmw_get_error_string().str; + ret = rcutils_string_array_fini(&node_names); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; // A non zero initialized array of node namespaces is an invalid argument. - ret = rcutils_string_array_init(&node_namespaces, 1u, &allocator) - ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; + ret = rcutils_string_array_init(&node_namespaces, 1u, &allocator); + ASSERT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; ret = rmw_get_node_names(node, &node_names, &node_namespaces); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_check_zero_rmw_string_array(&node_names)); - EXPECT_EQ(RMW_RET_OK, rcutils_string_array_fini(&node_namespaces)) << rmw_get_error_string().str; + ret = rcutils_string_array_fini(&node_namespaces); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; } TEST_F( @@ -270,25 +272,23 @@ TEST_F( get_service_names_and_types_with_bad_arguments) { rcutils_allocator_t allocator = rcutils_get_default_allocator(); rmw_names_and_types_t service_names_and_types = rmw_get_zero_initialized_names_and_types(); - bool no_demangle = false; // A null node is an invalid argument. rmw_ret_t ret = - rmw_get_service_names_and_types(nullptr, &allocator, no_demangle, &service_names_and_types); + rmw_get_service_names_and_types(nullptr, &allocator, &service_names_and_types); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); // A null allocator is an invalid argument. - ret = rmw_get_service_names_and_types(node, nullptr, no_demangle, &service_names_and_types); + ret = rmw_get_service_names_and_types(node, nullptr, &service_names_and_types); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); rcutils_allocator_t invalid_allocator = rcutils_get_zero_initialized_allocator(); // An invalid (zero initialized) allocator is an invalid argument. - ret = rmw_get_service_names_and_types( - node, &invalid_allocator, no_demangle, &service_names_and_types); + ret = rmw_get_service_names_and_types(node, &invalid_allocator, &service_names_and_types); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_check_zero(&service_names_and_types)); @@ -296,16 +296,16 @@ TEST_F( // A non zero initialized array of service names and types is an invalid argument. ASSERT_EQ(RMW_RET_OK, rmw_names_and_types_init(&service_names_and_types, 1u, &allocator)) << rmw_get_error_string().str; - ret = rmw_get_service_names_and_types(node, &allocator, no_demangle, &service_names_and_types); + ret = rmw_get_service_names_and_types(node, &allocator, &service_names_and_types); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret); rmw_reset_error(); - EXPECT_EQ(RMW_RET_OK, rmw_names_and_types_fini(&service_names_and_types)) << - rmw_get_error_string().str; + ret = rmw_names_and_types_fini(&service_names_and_types); + EXPECT_EQ(RMW_RET_OK, ret) << rmw_get_error_string().str; // A node from a different implementation cannot be used. const char * implementation_identifier = node->implementation_identifier; node->implementation_identifier = "not-an-rmw-implementation-identifier"; - ret = rmw_get_service_names_and_types(node, &allocator, no_demangle, &service_names_and_types); + ret = rmw_get_service_names_and_types(node, &allocator, &service_names_and_types); EXPECT_EQ(RMW_RET_INCORRECT_RMW_IMPLEMENTATION, ret); node->implementation_identifier = implementation_identifier; rmw_reset_error(); @@ -424,7 +424,7 @@ TEST_F( bool no_demangle = false; // A null node is an invalid argument. - ret = rmw_get_publisher_names_and_types_by_node( + rmw_ret_t ret = rmw_get_publisher_names_and_types_by_node( nullptr, &allocator, other_node_name, other_node_namespace, no_demangle, &topic_names_and_types); EXPECT_EQ(RMW_RET_INVALID_ARGUMENT, ret);