// Copyright 2017 Open Source Robotics Foundation, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include <gtest/gtest.h>

#include <chrono>

#include <functional>

#include <limits>

#include <map>

#include <memory>

#include <string>

#include <unordered_set>

#include <vector>

#include "rclcpp/exceptions.hpp"

#include "rclcpp/node.hpp"

#include "rclcpp/rclcpp.hpp"

#include "rcpputils/filesystem_helper.hpp"

#include "rcpputils/scope_exit.hpp"

#include "rmw/validate_namespace.h"

#include "test_msgs/msg/basic_types.hpp"

#include "test_msgs/msg/empty.hpp"

#include "test_msgs/srv/empty.hpp"

#include "../mocking_utils/patch.hpp"

class TestNode : public ::testing::Test

{

protected:

static void SetUpTestCase()

{

rclcpp::init(0, nullptr);

}

static void TearDownTestCase()

{

rclcpp::shutdown();

}

void SetUp() override

{

test_resources_path /= "test_node";

}

rcpputils::fs::path test_resources_path{TEST_RESOURCES_DIRECTORY};

};

/*

Testing node construction and destruction.

*/

TEST_F(TestNode, construction_and_destruction) {

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

EXPECT_NE(nullptr, node->get_node_base_interface());

EXPECT_NE(nullptr, node->get_node_clock_interface());

EXPECT_NE(nullptr, node->get_node_graph_interface());

EXPECT_NE(nullptr, node->get_node_logging_interface());

EXPECT_NE(nullptr, node->get_node_time_source_interface());

EXPECT_NE(nullptr, node->get_node_timers_interface());

EXPECT_NE(nullptr, node->get_node_topics_interface());

EXPECT_NE(nullptr, node->get_node_services_interface());

EXPECT_NE(nullptr, node->get_node_parameters_interface());

EXPECT_NE(nullptr, node->get_node_waitables_interface());

EXPECT_NE(nullptr, node->get_node_options().get_rcl_node_options());

EXPECT_NE(nullptr, node->get_graph_event());

EXPECT_NE(nullptr, node->get_clock());

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("invalid_node?", "/ns");

(void)node;

}, rclcpp::exceptions::InvalidNodeNameError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/invalid_ns?");

(void)node;

}, rclcpp::exceptions::InvalidNamespaceError);

}

}

/*

Testing lifecycles of subscriptions and publishers after node dies

*/

TEST_F(TestNode, pub_and_sub_lifecycles) {

using test_msgs::msg::Empty;

rclcpp::Publisher<Empty>::SharedPtr pub;

rclcpp::Subscription<Empty>::SharedPtr sub;

const auto callback = [](Empty::ConstSharedPtr) {};

{

// Create the node and context in a nested scope so that their

// std::shared_ptrs expire before we use pub and sub

auto context = std::make_shared<rclcpp::Context>();

context->init(0, nullptr);

rclcpp::NodeOptions options;

options.context(context);

const auto node = std::make_shared<rclcpp::Node>("my_node", "/ns", options);

pub = node->create_publisher<Empty>("topic", 10);

sub = node->create_subscription<Empty>("topic", 10, callback);

}

pub->publish(Empty());

}

TEST_F(TestNode, get_name_and_namespace) {

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/ns", node->get_namespace());

EXPECT_STREQ("/ns", node->get_effective_namespace().c_str());

EXPECT_STREQ("/ns/my_node", node->get_fully_qualified_name());

}

{

auto options = rclcpp::NodeOptions()

.arguments({"--ros-args", "-r", "__ns:=/another_ns"});

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns", options);

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/another_ns", node->get_namespace());

EXPECT_STREQ("/another_ns/my_node", node->get_fully_qualified_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/ns", node->get_namespace());

EXPECT_STREQ("/ns", node->get_effective_namespace().c_str());

EXPECT_STREQ("/ns/my_node", node->get_fully_qualified_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/", node->get_namespace());

EXPECT_STREQ("/", node->get_effective_namespace().c_str());

EXPECT_STREQ("/my_node", node->get_fully_qualified_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/", node->get_namespace());

EXPECT_STREQ("/", node->get_effective_namespace().c_str());

EXPECT_STREQ("/my_node", node->get_fully_qualified_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/my/ns");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/my/ns", node->get_namespace());

EXPECT_STREQ("/my/ns", node->get_effective_namespace().c_str());

EXPECT_STREQ("/my/ns/my_node", node->get_fully_qualified_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "my/ns");

EXPECT_STREQ("my_node", node->get_name());

EXPECT_STREQ("/my/ns", node->get_namespace());

EXPECT_STREQ("/my/ns", node->get_effective_namespace().c_str());

EXPECT_STREQ("/my/ns/my_node", node->get_fully_qualified_name());

}

{

auto node1 = std::make_shared<rclcpp::Node>("my_node1", "my/ns");

auto node2 = std::make_shared<rclcpp::Node>("my_node2", "my/ns");

auto node3 = std::make_shared<rclcpp::Node>("my_node3", "/ns2");

auto node4 = std::make_shared<rclcpp::Node>("my_node4", "my/ns3");

auto names_and_namespaces = node1->get_node_names();

auto name_namespace_set = std::unordered_set<std::string>(

names_and_namespaces.begin(),

names_and_namespaces.end());

std::function<bool(std::string)> Set_Contains = [&](std::string string_key)

{

return name_namespace_set.find(string_key) != name_namespace_set.end();

};

EXPECT_TRUE(Set_Contains("/my/ns/my_node1"));

EXPECT_TRUE(Set_Contains("/my/ns/my_node2"));

EXPECT_TRUE(Set_Contains("/ns2/my_node3"));

EXPECT_TRUE(Set_Contains("/my/ns3/my_node4"));

}

}

TEST_F(TestNode, subnode_get_name_and_namespace) {

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

auto subnode = node->create_sub_node("sub_ns");

EXPECT_STREQ("my_node", subnode->get_name());

EXPECT_STREQ("/ns", subnode->get_namespace());

EXPECT_STREQ("sub_ns", subnode->get_sub_namespace().c_str());

EXPECT_STREQ("/ns/sub_ns", subnode->get_effective_namespace().c_str());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("sub_ns");

EXPECT_STREQ("my_node", subnode->get_name());

EXPECT_STREQ("/ns", subnode->get_namespace());

EXPECT_STREQ("sub_ns", subnode->get_sub_namespace().c_str());

EXPECT_STREQ("/ns/sub_ns", subnode->get_effective_namespace().c_str());

auto subnode2 = subnode->create_sub_node("sub_ns2");

EXPECT_STREQ("my_node", subnode2->get_name());

EXPECT_STREQ("/ns", subnode2->get_namespace());

EXPECT_STREQ("sub_ns/sub_ns2", subnode2->get_sub_namespace().c_str());

EXPECT_STREQ("/ns/sub_ns/sub_ns2", subnode2->get_effective_namespace().c_str());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node");

auto subnode = node->create_sub_node("sub_ns");

EXPECT_STREQ("my_node", subnode->get_name());

EXPECT_STREQ("/", subnode->get_namespace());

EXPECT_STREQ("sub_ns", subnode->get_sub_namespace().c_str());

EXPECT_STREQ("/sub_ns", subnode->get_effective_namespace().c_str());

auto subnode2 = subnode->create_sub_node("sub_ns2");

EXPECT_STREQ("my_node", subnode2->get_name());

EXPECT_STREQ("/", subnode2->get_namespace());

EXPECT_STREQ("sub_ns/sub_ns2", subnode2->get_sub_namespace().c_str());

EXPECT_STREQ("/sub_ns/sub_ns2", subnode2->get_effective_namespace().c_str());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node");

ASSERT_THROW(

{

auto subnode = node->create_sub_node("/sub_ns");

}, rclcpp::exceptions::NameValidationError);

}

}

/*

Testing node construction and destruction.

*/

TEST_F(TestNode, subnode_construction_and_destruction) {

{

ASSERT_NO_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

auto subnode = node->create_sub_node("sub_ns");

});

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

auto subnode = node->create_sub_node("invalid_ns?");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns/");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns/");

auto subnode = node->create_sub_node("/sub_ns");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

auto subnode = node->create_sub_node("/sub_ns");

}, rclcpp::exceptions::NameValidationError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

auto subnode = node->create_sub_node("~sub_ns");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("invalid_ns?");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_NO_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("sub_ns");

});

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("/sub_ns");

}, rclcpp::exceptions::NameValidationError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("~sub_ns");

}, rclcpp::exceptions::InvalidNamespaceError);

}

{

ASSERT_THROW(

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto subnode = node->create_sub_node("");

}, rclcpp::exceptions::NameValidationError);

}

}

TEST_F(TestNode, get_logger) {

{

auto node = std::make_shared<rclcpp::Node>("my_node");

EXPECT_STREQ("my_node", node->get_logger().get_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

EXPECT_STREQ("ns.my_node", node->get_logger().get_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "ns");

EXPECT_STREQ("ns.my_node", node->get_logger().get_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "/my/ns");

EXPECT_STREQ("my.ns.my_node", node->get_logger().get_name());

}

{

auto node = std::make_shared<rclcpp::Node>("my_node", "my/ns");

EXPECT_STREQ("my.ns.my_node", node->get_logger().get_name());

}

}

TEST_F(TestNode, get_clock) {

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto ros_clock = node->get_clock();

EXPECT_NE(nullptr, ros_clock);

EXPECT_EQ(ros_clock->get_clock_type(), RCL_ROS_TIME);

const rclcpp::Node & const_node = *node.get();

EXPECT_NE(nullptr, const_node.get_clock());

}

TEST_F(TestNode, now) {

auto node = std::make_shared<rclcpp::Node>("my_node", "/ns");

auto clock = node->get_clock();

auto now_builtin = node->now().nanoseconds();

auto now_external = clock->now().nanoseconds();

EXPECT_GE(now_external, now_builtin);

EXPECT_LT(now_external - now_builtin, 5000000L);

}

std::string

operator"" _unq(const char * prefix, size_t prefix_length)

{

static uint64_t count = 0;

return std::string(prefix, prefix_length) + "_" + std::to_string(++count);

}

TEST_F(TestNode, declare_parameter_with_no_initial_values) {

// test cases without initial values

auto node = std::make_shared<rclcpp::Node>("test_declare_parameter_node"_unq);

{

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

// no default, no initial

const std::string parameter_name = "parameter"_unq;

rclcpp::ParameterValue value = node->declare_parameter(

parameter_name, rclcpp::ParameterValue{}, descriptor);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_NOT_SET);

// Does not throw if unset before access

EXPECT_EQ(

rclcpp::PARAMETER_NOT_SET,

node->get_parameter(parameter_name).get_parameter_value().get_type());

}

{

// int default, no initial

rclcpp::ParameterValue default_value(42);

rclcpp::ParameterValue value = node->declare_parameter("parameter"_unq, default_value);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), default_value.get<int>());

}

{

// int default, no initial, custom parameter descriptor

auto name = "parameter"_unq;

rclcpp::ParameterValue default_value(42);

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.read_only = true;

rclcpp::ParameterValue value =

node->declare_parameter(name, default_value, descriptor);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), default_value.get<int>());

rcl_interfaces::msg::ParameterDescriptor actual_descriptor =

node->describe_parameter(name);

EXPECT_EQ(actual_descriptor.read_only, descriptor.read_only);

}

{

// int default, no initial, implicit template specialization

int default_value = 42;

EXPECT_EQ(node->declare_parameter("parameter"_unq, default_value), default_value);

}

{

// parameter already declared throws

auto name = "parameter"_unq;

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

EXPECT_THROW(

{

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

},

rclcpp::exceptions::ParameterAlreadyDeclaredException);

}

{

// parameter name invalid throws

EXPECT_THROW(

{node->declare_parameter("", 5);},

rclcpp::exceptions::InvalidParametersException);

}

{

// parameter rejected throws

auto name = "parameter"_unq;

auto on_set_parameters =

[&name](const std::vector<rclcpp::Parameter> & parameters) {

rcl_interfaces::msg::SetParametersResult result;

result.successful = true;

for (const auto & parameter : parameters) {

if (

parameter.get_name() == name &&

parameter.get_type() != rclcpp::PARAMETER_INTEGER)

{

result.successful = false;

result.reason = "'" + name + "' must be an integer";

}

}

return result;

};

auto handler = node->add_on_set_parameters_callback(on_set_parameters);

RCPPUTILS_SCOPE_EXIT(

{node->remove_on_set_parameters_callback(handler.get());}); // always reset

EXPECT_THROW(

{node->declare_parameter<std::string>(name, "not an int");},

rclcpp::exceptions::InvalidParameterValueException);

}

}

TEST_F(TestNode, declare_parameter_with_allow_undeclared_parameters) {

// test cases without initial values

auto node = std::make_shared<rclcpp::Node>(

"test_declare_parameter_node"_unq, "/",

rclcpp::NodeOptions{}.allow_undeclared_parameters(true));

{

// declared parameters static typing is still enforced

auto param_name = "parameter"_unq;

auto value = node->declare_parameter(param_name, 5);

EXPECT_EQ(value, 5);

EXPECT_FALSE(node->set_parameter({param_name, "asd"}).successful);

auto param = node->get_parameter(param_name);

EXPECT_EQ(param.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(param.get_value<int64_t>(), 5);

}

{

// not for automatically declared parameters

auto param_name = "parameter"_unq;

EXPECT_TRUE(node->set_parameter({param_name, 5}).successful);

auto param = node->get_parameter(param_name);

EXPECT_EQ(param.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(param.get_value<int64_t>(), 5);

EXPECT_TRUE(node->set_parameter({param_name, "asd"}).successful);

param = node->get_parameter(param_name);

EXPECT_EQ(param.get_type(), rclcpp::PARAMETER_STRING);

EXPECT_EQ(param.get_value<std::string>(), "asd");

}

{

// declare after set is invalid

auto param_name = "parameter"_unq;

EXPECT_TRUE(node->set_parameter({param_name, 5}).successful);

auto param = node->get_parameter(param_name);

EXPECT_EQ(param.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(param.get_value<int64_t>(), 5);

EXPECT_THROW(

node->declare_parameter(param_name, 5),

rclcpp::exceptions::ParameterAlreadyDeclaredException);

}

}

auto get_fixed_on_parameter_set_callback(const std::string & name, bool successful)

{

return

[name, successful](const std::vector<rclcpp::Parameter> & parameters) {

(void)parameters;

rcl_interfaces::msg::SetParametersResult result;

result.successful = successful;

return result;

};

}

TEST_F(TestNode, test_registering_multiple_callbacks_api) {

auto node = std::make_shared<rclcpp::Node>("test_declare_parameter_node"_unq);

{

int64_t default_value{42};

auto name1 = "parameter"_unq;

auto scoped_callback1 = node->add_on_set_parameters_callback(

get_fixed_on_parameter_set_callback(name1, true));

EXPECT_NE(scoped_callback1, nullptr);

int64_t value{node->declare_parameter(name1, default_value)};

EXPECT_EQ(value, default_value);

auto name2 = "parameter"_unq;

auto scoped_callback2 = node->add_on_set_parameters_callback(

get_fixed_on_parameter_set_callback(name2, false));

EXPECT_NE(scoped_callback2, nullptr);

EXPECT_THROW(

{node->declare_parameter(name2, default_value);},

rclcpp::exceptions::InvalidParameterValueException);

auto name3 = "parameter"_unq;

scoped_callback2.reset();

value = node->declare_parameter(name3, default_value);

EXPECT_EQ(value, default_value);

}

{

int64_t default_value{42};

auto name1 = "parameter"_unq;

auto scoped_callback1 = node->add_on_set_parameters_callback(

get_fixed_on_parameter_set_callback(name1, true));

EXPECT_NE(scoped_callback1, nullptr);

int64_t value{node->declare_parameter(name1, default_value)};

EXPECT_EQ(value, default_value);

auto name2 = "parameter"_unq;

auto scoped_callback2 = node->add_on_set_parameters_callback(

get_fixed_on_parameter_set_callback(name2, false));

EXPECT_NE(scoped_callback2, nullptr);

EXPECT_THROW(

{node->declare_parameter(name2, default_value);},

rclcpp::exceptions::InvalidParameterValueException);

auto name3 = "parameter"_unq;

node->remove_on_set_parameters_callback(scoped_callback2.get());

value = node->declare_parameter(name3, default_value);

EXPECT_EQ(value, default_value);

}

{

int64_t default_value{42};

auto name1 = "parameter"_unq;

rclcpp::Node::OnSetParametersCallbackHandle::SharedPtr scoped_callback(

node->add_on_set_parameters_callback(

get_fixed_on_parameter_set_callback(name1, false)));

rclcpp::Node::OnSetParametersCallbackHandle::SharedPtr scoped_callback_copy(scoped_callback);

scoped_callback.reset();

EXPECT_THROW(

{node->declare_parameter("parameter"_unq, default_value);},

rclcpp::exceptions::InvalidParameterValueException);

scoped_callback_copy.reset();

// All the shared_ptr has been reset

int64_t value = node->declare_parameter("parameter"_unq, default_value);

EXPECT_EQ(value, default_value);

}

}

TEST_F(TestNode, declare_parameter_with_overrides) {

// test cases with overrides

rclcpp::NodeOptions no;

no.parameter_overrides(

{

{"parameter_no_default", 42},

{"parameter_no_default_set", 42},

{"parameter_no_default_set_cvref", 42},

{"parameter_and_default", 42},

{"parameter_and_default_ignore_override", 42},

{"parameter_custom", 42},

{"parameter_template", 42},

{"parameter_already_declared", 42},

{"parameter_rejected", 42},

{"parameter_type_mismatch", "not an int"},

});

auto node = std::make_shared<rclcpp::Node>("test_declare_parameter_node"_unq, no);

{

// no default, with override

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_no_default", rclcpp::ParameterType::PARAMETER_INTEGER);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 42);

}

{

// no default, with override, and set after

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_no_default_set", rclcpp::ParameterType::PARAMETER_INTEGER);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 42);

// check that the value is changed after a set

node->set_parameter({"parameter_no_default_set", 44});

EXPECT_EQ(node->get_parameter("parameter_no_default_set").get_value<int>(), 44);

}

{

// no default, with override

const rclcpp::ParameterValue & value = node->declare_parameter(

"parameter_no_default_set_cvref", rclcpp::ParameterType::PARAMETER_INTEGER);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 42);

// check that the value is changed after a set

node->set_parameter({"parameter_no_default_set_cvref", 44});

EXPECT_EQ(value.get<int>(), 44);

}

{

// int default, with override

rclcpp::ParameterValue default_value(43);

rclcpp::ParameterValue value = node->declare_parameter("parameter_and_default", default_value);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 42); // and not 43 which is the default value

}

{

// int default, with override and ignoring it

rclcpp::ParameterValue default_value(43);

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_and_default_ignore_override",

default_value,

rcl_interfaces::msg::ParameterDescriptor(),

true);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 43); // and not 42, the parameter override is ignored.

}

{

// int default, with initial, custom parameter descriptor

rclcpp::ParameterValue default_value(43);

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.read_only = true;

rclcpp::ParameterValue value =

node->declare_parameter("parameter_custom", default_value, descriptor);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int>(), 42); // and not 43 which is the default value

rcl_interfaces::msg::ParameterDescriptor actual_descriptor =

node->describe_parameter("parameter_custom");

EXPECT_EQ(actual_descriptor.read_only, descriptor.read_only);

}

{

// int default, with initial, implicit template specialization

int default_value = 43;

// is equal to 42, not 43 which is the default value

EXPECT_EQ(node->declare_parameter("parameter_template", default_value), 42);

}

{

// parameter already declared throws

auto name = "parameter_already_declared";

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

EXPECT_THROW(

{

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

},

rclcpp::exceptions::ParameterAlreadyDeclaredException);

}

{

// parameter name invalid throws

EXPECT_THROW(

{node->declare_parameter("", 5);},

rclcpp::exceptions::InvalidParametersException);

}

{

// parameter rejected throws, with initial value

auto name = std::string("parameter_rejected");

auto on_set_parameters =

[&name](const std::vector<rclcpp::Parameter> & parameters) {

rcl_interfaces::msg::SetParametersResult result;

result.successful = true;

for (const auto & parameter : parameters) {

if (

parameter.get_name() == name &&

parameter.get_type() == rclcpp::PARAMETER_INTEGER)

{

if (parameter.get_value<int>() < 43) {

result.successful = false;

result.reason = "'" + name + "' must be an integer and less than 43";

}

}

}

return result;

};

auto handler = node->add_on_set_parameters_callback(on_set_parameters);

RCPPUTILS_SCOPE_EXIT(

{node->remove_on_set_parameters_callback(handler.get());}); // always reset

EXPECT_THROW(

{node->declare_parameter<int>(name, 43);},

rclcpp::exceptions::InvalidParameterValueException);

}

{

// default type and initial value type do not match

EXPECT_THROW(

{node->declare_parameter("parameter_type_mismatch", 42);},

rclcpp::exceptions::InvalidParameterTypeException);

}

{

// default type and expected type do not match

EXPECT_THROW(

{node->declare_parameter(

"parameter_type_mismatch", rclcpp::ParameterType::PARAMETER_INTEGER);},

rclcpp::exceptions::InvalidParameterTypeException);

}

{

// statically typed parameter must be initialized

EXPECT_THROW(

{node->declare_parameter<std::string>("static_and_uninitialized");},

rclcpp::exceptions::UninitializedStaticallyTypedParameterException);

}

{

// cannot pass an expected type and a descriptor with dynamic_typing=True

rcl_interfaces::msg::ParameterDescriptor descriptor{};

descriptor.dynamic_typing = true;

EXPECT_THROW(

{node->declare_parameter(

"invalid_argument", rclcpp::ParameterType::PARAMETER_INTEGER, descriptor);},

std::invalid_argument);

}

}

TEST_F(TestNode, declare_parameters_with_no_initial_values) {

// test cases without initial values

auto node = std::make_shared<rclcpp::Node>("test_declare_parameters_node"_unq);

{

// with namespace, defaults, no custom descriptors, no initial

int64_t bigger_than_int = INT64_MAX - 42;

auto values = node->declare_parameters<int64_t>(

"namespace1", {

{"parameter_a", 42},

{"parameter_b", 256},

{"parameter_c", bigger_than_int},

});

std::vector<int64_t> expected = {42, 256, bigger_than_int};

EXPECT_EQ(values, expected);

EXPECT_TRUE(node->has_parameter("namespace1.parameter_a"));

EXPECT_TRUE(node->has_parameter("namespace1.parameter_b"));

EXPECT_FALSE(node->has_parameter("namespace1"));

}

{

// without namespace, defaults, no custom descriptors, no initial

auto values = node->declare_parameters<int64_t>(

"", {

{"parameter_without_ns_a", 42},

{"parameter_without_ns_b", 256},

});

std::vector<int64_t> expected = {42, 256};

EXPECT_EQ(values, expected);

EXPECT_TRUE(node->has_parameter("parameter_without_ns_a"));

EXPECT_TRUE(node->has_parameter("parameter_without_ns_b"));

}

{

// with namespace, defaults, custom descriptors, no initial

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.read_only = true;

auto values = node->declare_parameters<int64_t>(

"namespace2", {

{"parameter_a", {42, descriptor}},

{"parameter_b", {256, descriptor}},

});

std::vector<int64_t> expected = {42, 256};

EXPECT_EQ(values, expected);

EXPECT_TRUE(node->has_parameter("namespace2.parameter_a"));

EXPECT_TRUE(node->has_parameter("namespace2.parameter_b"));

EXPECT_FALSE(node->has_parameter("namespace2"));

}

{

// without namespace, defaults, custom descriptors, no initial

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.read_only = true;

auto values = node->declare_parameters<int64_t>(

"", {

{"parameter_without_ns_c", {42, descriptor}},

{"parameter_without_ns_d", {256, descriptor}},

});

std::vector<int64_t> expected = {42, 256};

EXPECT_EQ(values, expected);

EXPECT_TRUE(node->has_parameter("parameter_without_ns_c"));

EXPECT_TRUE(node->has_parameter("parameter_without_ns_d"));

}

{

// empty parameters

auto values = node->declare_parameters<int64_t>("", {});

std::vector<int64_t> expected {};

EXPECT_EQ(values, expected);

}

{

// parameter already declared throws, even with not_set type

auto name = "parameter"_unq;

node->declare_parameter(name, 42);

EXPECT_THROW(

{node->declare_parameters<int64_t>("", {{name, 42}});},

rclcpp::exceptions::ParameterAlreadyDeclaredException);

}

{

// parameter name invalid throws

EXPECT_THROW(

{node->declare_parameters<int64_t>("", {{"", 42}});},

rclcpp::exceptions::InvalidParametersException);

}

{

// parameter rejected throws

auto name = "parameter"_unq;

auto on_set_parameters =

[&name](const std::vector<rclcpp::Parameter> & parameters) {

rcl_interfaces::msg::SetParametersResult result;

result.successful = true;

for (const auto & parameter : parameters) {

if (

parameter.get_name() == name &&

parameter.get_type() != rclcpp::PARAMETER_INTEGER)

{

result.successful = false;

result.reason = "'" + name + "' must be an integer";

}

}

return result;

};

auto handler = node->add_on_set_parameters_callback(on_set_parameters);

RCPPUTILS_SCOPE_EXIT(

{node->remove_on_set_parameters_callback(handler.get());}); // always reset

EXPECT_THROW(

{node->declare_parameters<std::string>("", {{name, "not an int"}});},

rclcpp::exceptions::InvalidParameterValueException);

}

}

TEST_F(TestNode, declare_parameter_with_cli_overrides) {

const std::string parameters_filepath = (

test_resources_path / "test_parameters.yaml").string();

// test cases with overrides

rclcpp::NodeOptions no;

no.arguments(

{

"--ros-args",

"-p", "parameter_bool:=false",

"-p", "parameter_int:=42",

"-p", "parameter_double:=0.42",

"-p", "parameter_string:=foo",

"--params-file", parameters_filepath.c_str(),

"-p", "parameter_bool_array:=[false, true]",

"-p", "parameter_int_array:=[-21, 42]",

"-p", "parameter_double_array:=[-1.0, .42]",

"-p", "parameter_string_array:=[foo, bar]"

});

// To match parameters YAML file content, use a well-known node name for this test only.

auto node = std::make_shared<rclcpp::Node>("test_declare_parameter_node", no);

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_bool", rclcpp::ParameterType::PARAMETER_BOOL);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_BOOL);

EXPECT_EQ(value.get<bool>(), true);

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_int", rclcpp::ParameterType::PARAMETER_INTEGER);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER);

EXPECT_EQ(value.get<int64_t>(), 21); // set to 42 in CLI, overriden by file

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_double", rclcpp::ParameterType::PARAMETER_DOUBLE);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE);

EXPECT_EQ(value.get<double>(), 0.42);

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_string", rclcpp::ParameterType::PARAMETER_STRING);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_STRING);

EXPECT_EQ(value.get<std::string>(), "foo");

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_bool_array", rclcpp::ParameterType::PARAMETER_BOOL_ARRAY);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_BOOL_ARRAY);

std::vector<bool> expected_value{false, true};

EXPECT_EQ(value.get<std::vector<bool>>(), expected_value);

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_int_array", rclcpp::ParameterType::PARAMETER_INTEGER_ARRAY);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_INTEGER_ARRAY);

std::vector<int64_t> expected_value{-21, 42};

EXPECT_EQ(value.get<std::vector<int64_t>>(), expected_value);

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_double_array", rclcpp::ParameterType::PARAMETER_DOUBLE_ARRAY);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_DOUBLE_ARRAY);

std::vector<double> expected_value{-1.0, 0.42};

EXPECT_EQ(value.get<std::vector<double>>(), expected_value);

}

{

rclcpp::ParameterValue value = node->declare_parameter(

"parameter_string_array", rclcpp::ParameterType::PARAMETER_STRING_ARRAY);

EXPECT_EQ(value.get_type(), rclcpp::PARAMETER_STRING_ARRAY);

std::vector<std::string> expected_value{"foo", "bar"};

// set to [baz, baz, baz] in file, overriden by CLI

EXPECT_EQ(value.get<std::vector<std::string>>(), expected_value);

}

}

TEST_F(TestNode, undeclare_parameter) {

auto node = std::make_shared<rclcpp::Node>("test_undeclare_parameter_node"_unq);

{

// normal use

auto name = "parameter"_unq;

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

EXPECT_TRUE(node->has_parameter(name));

node->undeclare_parameter(name);

EXPECT_FALSE(node->has_parameter(name));

}

{

// not declared throws

auto name = "parameter"_unq;

EXPECT_FALSE(node->has_parameter(name));

EXPECT_THROW(

{node->undeclare_parameter(name);},

rclcpp::exceptions::ParameterNotDeclaredException);

}

{

// statically typed parameter throws

auto name = "parameter"_unq;

node->declare_parameter(name, 42);

EXPECT_TRUE(node->has_parameter(name));

EXPECT_THROW(

{node->undeclare_parameter(name);},

rclcpp::exceptions::InvalidParameterTypeException);

EXPECT_TRUE(node->has_parameter(name));

}

{

// read only parameter throws

auto name = "parameter"_unq;

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.read_only = true;

node->declare_parameter(name, 42, descriptor);

EXPECT_TRUE(node->has_parameter(name));

EXPECT_THROW(

{node->undeclare_parameter(name);},

rclcpp::exceptions::ParameterImmutableException);

EXPECT_TRUE(node->has_parameter(name));

}

}

TEST_F(TestNode, has_parameter) {

auto node = std::make_shared<rclcpp::Node>("test_has_parameter_node"_unq);

// normal use

auto name = "parameter"_unq;

EXPECT_FALSE(node->has_parameter(name));

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

EXPECT_TRUE(node->has_parameter(name));

node->undeclare_parameter(name);

EXPECT_FALSE(node->has_parameter(name));

}

TEST_F(TestNode, list_parameters) {

auto node = std::make_shared<rclcpp::Node>("test_list_parameter_node"_unq);

// normal use

auto name = "parameter"_unq;

const size_t before_size = node->list_parameters({}, 1u).names.size();

rcl_interfaces::msg::ParameterDescriptor descriptor;

descriptor.dynamic_typing = true;

node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);

EXPECT_EQ(1u + before_size, node->list_parameters({}, 1u).names.size());

node->undeclare_parameter(name);

EXPECT_EQ(before_size, node->list_parameters({}, 1u).names.size());

}

TEST_F(TestNode, set_parameter_undeclared_parameters_not_allowed) {

auto node = std::make_shared<rclcpp::Node>(

"test_set_parameter_node"_unq,

rclcpp::NodeOptions().allow_undeclared_parameters(false));

{

// normal use

auto name = "parameter"_unq;

EXPECT_FALSE(node->has_parameter(name));

node->declare_parameter(name, 42);

EXPECT_TRUE(node->has_parameter(name));

EXPECT_EQ(node->get_parameter(name).get_value<int>(), 42);

EXPECT_TRUE(node->set_parameter(rclcpp::Parameter(name, 43)).successful);

EXPECT_EQ(node->get_parameter(name).get_value<int>(), 43);

}