rtt_dynamic_reconfigure_tests.cpp
Go to the documentation of this file.
1 /*********************************************************************
2  *
3  * Copyright (c) 2014, Intermodalics BVBA
4  * All rights reserved.
5  *
6  *********************************************************************/
7 
8 #define RTT_STATIC
9 
10 #include <rtt_dynamic_reconfigure/server.h>
11 #include <rtt_dynamic_reconfigure/auto_config.h>
12 #include <gtest/gtest.h>
13 
14 #include <rtt/plugin/PluginLoader.hpp>
15 #include <rtt/Logger.hpp>
16 
17 #include <rtt/deployment/ComponentLoader.hpp>
18 #include <rtt/os/main.h>
19 
20 #include <rtt/internal/GlobalService.hpp>
21 #include <rtt/OperationCaller.hpp>
22 
23 #include <dynamic_reconfigure/ConfigDescription.h>
24 #include <dynamic_reconfigure/config_tools.h>
25 
26 #include <rtt_dynamic_reconfigure_tests/TestConfig.h>
27 #include "test_component.hpp"
28 
29 using namespace rtt_dynamic_reconfigure;
30 using namespace rtt_dynamic_reconfigure_tests;
31 
32 class DynamicReconfigureTest : public ::testing::Test
33 {
34 public:
35  DynamicReconfigureTestComponent tc;
36 
37  // virtual void SetUp() {}
38  // virtual void TearDown() {}
39 };
40 
41 static const dynamic_reconfigure::Group *getGroup(const dynamic_reconfigure::ConfigDescription::_groups_type *groups, const std::string &name)
42 {
43  if (!groups) return 0;
44  for(dynamic_reconfigure::ConfigDescription::_groups_type::const_iterator it = groups->begin(); it != groups->end(); ++it) {
45  if (it->name == name) return &(*it);
46  }
47  return 0;
48 }
49 
50 static const dynamic_reconfigure::ParamDescription *getParamDescription(const dynamic_reconfigure::Group *group, const std::string &name)
51 {
52  if (!group) return 0;
53  for(dynamic_reconfigure::Group::_parameters_type::const_iterator it = group->parameters.begin(); it != group->parameters.end(); ++it) {
54  if (it->name == name) return &(*it);
55  }
56  return 0;
57 }
58 
59 TEST_F(DynamicReconfigureTest, ConfigDescription)
60 {
61  // load test_reconfigure service
62  ASSERT_TRUE(tc.loadService("test_reconfigure"));
63  ASSERT_TRUE(tc.provides()->hasService("test_reconfigure"));
64 
65  // properties should still have their original default value
66  EXPECT_EQ(0, tc.props.int_param);
67  EXPECT_EQ(0, tc.props.double_param);
68  EXPECT_EQ("", tc.props.str_param);
69  EXPECT_FALSE(tc.props.bool_param);
70 
71  // non-existent properties should have been created with the default value
72  ASSERT_TRUE(tc.properties()->getPropertyType<double>("non_existent"));
73  EXPECT_EQ(5.0, *(tc.properties()->getPropertyType<double>("non_existent")));
74 
75  // get a pointer to the reconfigure service
76  boost::shared_ptr<Server<TestConfig> > server = boost::dynamic_pointer_cast<Server<TestConfig> >(tc.provides("test_reconfigure"));
77  ASSERT_TRUE(server.get());
78 
79  // check ConfigDescription groups
80  dynamic_reconfigure::ConfigDescriptionPtr description = server->getDescriptionMessage();
81  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "int_param"));
82  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "double_param"));
83  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "str_param"));
84  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "bool_param"));
85  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "non_existent"));
86  //EXPECT_TRUE(getGroup(&(description->groups), "a_group"));
87  //EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "a_group"), "group_param"));
88 
89  // check ConfigDescription dflt/min/max values
90  struct {
91  int int_param;
92  double double_param;
93  std::string str_param;
94  bool bool_param;
95  std::string group_param;
96  } temp;
97  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "int_param", temp.int_param));
98  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "double_param", temp.double_param));
99  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "str_param", temp.str_param));
100  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "bool_param", temp.bool_param));
101  //EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "group_param", temp.group_param));
102  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "int_param", temp.int_param));
103  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "double_param", temp.double_param));
104  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "str_param", temp.str_param));
105  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "bool_param", temp.bool_param));
106  //EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "group_param", temp.group_param));
107  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "int_param", temp.int_param));
108  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "double_param", temp.double_param));
109  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "str_param", temp.str_param));
110  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "bool_param", temp.bool_param));
111  //EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "group_param", temp.group_param));
112 }
113 
114 TEST_F(DynamicReconfigureTest, MinMaxDefault)
115 {
116  // load test_reconfigure service
117  ASSERT_TRUE(tc.loadService("test_reconfigure"));
118  ASSERT_TRUE(tc.provides()->hasService("test_reconfigure"));
119 
120  // check minimum values
121  const RTT::PropertyBag &min = tc.provides("test_reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("min")->rvalue();
122  EXPECT_EQ(0, *(min.getPropertyType<int>("int_param")));
123  EXPECT_EQ(0.0, *(min.getPropertyType<double>("double_param")));
124  EXPECT_EQ(0.0, *(min.getPropertyType<double>("non_existent")));
125 
126  // check maximum values
127  const RTT::PropertyBag &max = tc.provides("test_reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("max")->rvalue();
128  EXPECT_EQ(100, *(max.getPropertyType<int>("int_param")));
129  EXPECT_EQ(1.0, *(max.getPropertyType<double>("double_param")));
130  EXPECT_EQ(10.0, *(max.getPropertyType<double>("non_existent")));
131 
132  // check default values
133  const RTT::PropertyBag &dflt = tc.provides("test_reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("default")->rvalue();
134  EXPECT_EQ(50, *(dflt.getPropertyType<int>("int_param")));
135  EXPECT_EQ(.5, *(dflt.getPropertyType<double>("double_param")));
136  EXPECT_EQ("Hello World", dflt.getPropertyType<std::string>("str_param")->rvalue());
137  EXPECT_TRUE(*(dflt.getPropertyType<bool>("bool_param")));
138  EXPECT_EQ(5.0, *(dflt.getPropertyType<double>("non_existent")));
139 }
140 
141 TEST_F(DynamicReconfigureTest, DefaultUpdateCallback)
142 {
143  // load test_reconfigure service
144  ASSERT_TRUE(tc.loadService("reconfigure"));
145  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
146 
147  // check that no user callback has been called during service construction
148  EXPECT_FALSE(tc.updatePropertiesCalled);
149  EXPECT_FALSE(tc.updatePropertiesConstCalled);
150  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
151 
152  // check actual callback
153  dynamic_reconfigure::Reconfigure reconfigure;
154  EXPECT_TRUE(tc.setConfigCallback("reconfigure", reconfigure.request, reconfigure.response));
155  EXPECT_FALSE(tc.updatePropertiesCalled);
156  EXPECT_FALSE(tc.updatePropertiesConstCalled);
157  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
158 }
159 
160 TEST_F(DynamicReconfigureTest, UpdatePropertiesCallback)
161 {
162  // add updateProperties operation
163  tc.addOperation("updateProperties", &DynamicReconfigureTestComponent::updateProperties, &tc);
164 
165  // load test_reconfigure service
166  ASSERT_TRUE(tc.loadService("reconfigure"));
167  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
168 
169  // check that updateProperties callback has been called during service construction
170  EXPECT_TRUE(tc.updatePropertiesCalled);
171  EXPECT_FALSE(tc.updatePropertiesConstCalled);
172  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
173  tc.updatePropertiesCalled = false;
174 
175  // check actual callback
176  dynamic_reconfigure::Reconfigure reconfigure;
177  EXPECT_TRUE(tc.setConfigCallback("reconfigure", reconfigure.request, reconfigure.response));
178  EXPECT_TRUE(tc.updatePropertiesCalled);
179  EXPECT_FALSE(tc.updatePropertiesConstCalled);
180  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
181 }
182 
183 TEST_F(DynamicReconfigureTest, UpdatePropertiesConstCallback)
184 {
185  // add updateProperties operation
186  tc.addOperation("updateProperties", &DynamicReconfigureTestComponent::updatePropertiesConst, &tc);
187 
188  // load test_reconfigure service
189  ASSERT_TRUE(tc.loadService("reconfigure"));
190  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
191 
192  // check that updatePropertiesConst callback has been called during service construction
193  EXPECT_FALSE(tc.updatePropertiesCalled);
194  EXPECT_TRUE(tc.updatePropertiesConstCalled);
195  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
196  tc.updatePropertiesConstCalled = false;
197 
198  // check actual callback
199  dynamic_reconfigure::Reconfigure reconfigure;
200  EXPECT_TRUE(tc.setConfigCallback("reconfigure", reconfigure.request, reconfigure.response));
201  EXPECT_FALSE(tc.updatePropertiesCalled);
202  EXPECT_TRUE(tc.updatePropertiesConstCalled);
203  EXPECT_FALSE(tc.notifyPropertiesUpdateCalled);
204 }
205 
206 TEST_F(DynamicReconfigureTest, NotifyPropertiesUpdateCallback)
207 {
208  // add updateProperties operation
209  tc.addOperation("notifyPropertiesUpdate", &DynamicReconfigureTestComponent::notifyPropertiesUpdate, &tc);
210 
211  // load test_reconfigure service
212  ASSERT_TRUE(tc.loadService("reconfigure"));
213  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
214 
215  // check that notifyPropertiesUpdate callback has been called during service construction
216  EXPECT_FALSE(tc.updatePropertiesCalled);
217  EXPECT_FALSE(tc.updatePropertiesConstCalled);
218  EXPECT_TRUE(tc.notifyPropertiesUpdateCalled);
219  tc.notifyPropertiesUpdateCalled = false;
220 
221  // check actual callback
222  dynamic_reconfigure::Reconfigure reconfigure;
223  EXPECT_TRUE(tc.setConfigCallback("reconfigure", reconfigure.request, reconfigure.response));
224  EXPECT_FALSE(tc.updatePropertiesCalled);
225  EXPECT_FALSE(tc.updatePropertiesConstCalled);
226  EXPECT_TRUE(tc.notifyPropertiesUpdateCalled);
227 }
228 
229 TEST_F(DynamicReconfigureTest, AutoConfig)
230 {
231  // load test_reconfigure service
232  ASSERT_TRUE(tc.loadService("reconfigure"));
233  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
234 
235  // get a pointer to the reconfigure service
236  boost::shared_ptr<Server<AutoConfig> > server = boost::dynamic_pointer_cast<Server<AutoConfig> >(tc.provides("reconfigure"));
237  ASSERT_TRUE(server.get());
238 
239  // min/max/default property bag should exist with the same number of properties
240  ASSERT_TRUE(tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("min"));
241  ASSERT_TRUE(tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("max"));
242  ASSERT_TRUE(tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("default"));
243  ASSERT_EQ(tc.properties()->size(), tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("min")->rvalue().size());
244  ASSERT_EQ(tc.properties()->size(), tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("max")->rvalue().size());
245  ASSERT_EQ(tc.properties()->size(), tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("default")->rvalue().size());
246 
247  // properties should still have their original default value
248  EXPECT_EQ(0, tc.props.int_param);
249  EXPECT_EQ(0.0, tc.props.double_param);
250  EXPECT_EQ("", tc.props.str_param);
251  EXPECT_FALSE(tc.props.bool_param);
252  EXPECT_EQ(0.0, tc.props.float_param);
253  EXPECT_EQ(0, tc.props.uint_param);
254  EXPECT_TRUE(tc.props.bag_param.size() == 1);
255  EXPECT_EQ("", tc.props.str_param_in_bag);
256  EXPECT_EQ(1.0, tc.props.vector3_param.x);
257  EXPECT_EQ(2.0, tc.props.vector3_param.y);
258  EXPECT_EQ(3.0, tc.props.vector3_param.z);
259 
260  // default value properties should exists with the initial value of the properties
261  const RTT::PropertyBag &dflt = tc.provides("reconfigure")->properties()->getPropertyType<RTT::PropertyBag>("default")->rvalue();
262  ASSERT_TRUE(dflt.getPropertyType<int>("int_param"));
263  EXPECT_EQ(tc.props.int_param, *(dflt.getPropertyType<int>("int_param")));
264  ASSERT_TRUE(dflt.getPropertyType<double>("double_param"));
265  EXPECT_EQ(tc.props.double_param, *(dflt.getPropertyType<double>("double_param")));
266  ASSERT_TRUE(dflt.getPropertyType<std::string>("str_param"));
267  EXPECT_EQ(tc.props.str_param, dflt.getPropertyType<std::string>("str_param")->rvalue());
268  ASSERT_TRUE(dflt.getPropertyType<bool>("bool_param"));
269  EXPECT_EQ(tc.props.bool_param, *(dflt.getPropertyType<bool>("bool_param")));
270  ASSERT_TRUE(dflt.getPropertyType<float>("float_param"));
271  EXPECT_EQ(tc.props.float_param, *(dflt.getPropertyType<float>("float_param")));
272  ASSERT_TRUE(dflt.getPropertyType<unsigned int>("uint_param"));
273  EXPECT_EQ(tc.props.uint_param, *(dflt.getPropertyType<unsigned int>("uint_param")));
274 
275  ASSERT_TRUE(dflt.getPropertyType<RTT::PropertyBag>("bag_param"));
276  const RTT::PropertyBag &dflt_bag = *(dflt.getPropertyType<RTT::PropertyBag>("bag_param"));
277  EXPECT_TRUE(dflt_bag.size() == 1);
278  ASSERT_TRUE(dflt_bag.getPropertyType<std::string>("str_param"));
279  EXPECT_EQ(tc.props.str_param_in_bag, dflt_bag.getPropertyType<std::string>("str_param")->rvalue());
280 
281  ASSERT_TRUE(dflt.getPropertyType<RTT::PropertyBag>("vector3_param"));
282  const RTT::PropertyBag &dflt_vector3_bag = *(dflt.getPropertyType<RTT::PropertyBag>("vector3_param"));
283  EXPECT_TRUE(dflt_vector3_bag.size() == 3);
284  ASSERT_TRUE(dflt_vector3_bag.getPropertyType<double>("x"));
285  ASSERT_TRUE(dflt_vector3_bag.getPropertyType<double>("y"));
286  ASSERT_TRUE(dflt_vector3_bag.getPropertyType<double>("z"));
287  EXPECT_EQ(tc.props.vector3_param.x, dflt_vector3_bag.getPropertyType<double>("x")->rvalue());
288  EXPECT_EQ(tc.props.vector3_param.y, dflt_vector3_bag.getPropertyType<double>("y")->rvalue());
289  EXPECT_EQ(tc.props.vector3_param.z, dflt_vector3_bag.getPropertyType<double>("z")->rvalue());
290 
291  // check ConfigDescription
292  dynamic_reconfigure::ConfigDescriptionPtr description = server->getDescriptionMessage();
293  ASSERT_TRUE(description->groups.size() == 3);
294  EXPECT_EQ("Default", description->groups[0].name);
295  EXPECT_EQ("", description->groups[0].type);
296  EXPECT_EQ(6, description->groups[0].parameters.size());
297  EXPECT_EQ(0, description->groups[0].parent);
298  EXPECT_EQ(0, description->groups[0].id);
299  EXPECT_EQ("bag_param", description->groups[1].name);
300  EXPECT_EQ("", description->groups[1].type);
301  EXPECT_EQ(1, description->groups[1].parameters.size());
302  EXPECT_EQ(0, description->groups[1].parent);
303  EXPECT_EQ(1, description->groups[1].id);
304  EXPECT_EQ("vector3_param", description->groups[2].name);
305  EXPECT_EQ("", description->groups[2].type);
306  EXPECT_EQ(3, description->groups[2].parameters.size());
307  EXPECT_EQ(0, description->groups[2].parent);
308  EXPECT_EQ(2, description->groups[2].id);
309 
310  // check default/minimum/maximum values in description message
311  struct {
312  int int_param;
313  double double_param;
314  std::string str_param;
315  bool bool_param;
316  double float_param;
317  int uint_param;
318  std::string str_param_in_bag;
319  geometry_msgs::Vector3 vector3_param;
320  } temp;
321  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "int_param", temp.int_param));
322  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "double_param", temp.double_param));
323  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "str_param", temp.str_param));
324  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "bool_param", temp.bool_param));
325  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "float_param", temp.float_param));
326  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "uint_param", temp.uint_param));
327  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "bag_param__str_param", temp.str_param_in_bag));
328  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "vector3_param__x", temp.vector3_param.x));
329  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "vector3_param__y", temp.vector3_param.y));
330  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "vector3_param__z", temp.vector3_param.z));
331  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "int_param", temp.int_param));
332  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "double_param", temp.double_param));
333  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "str_param", temp.str_param));
334  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "bool_param", temp.bool_param));
335  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "float_param", temp.float_param));
336  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "uint_param", temp.uint_param));
337  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "bag_param__str_param", temp.str_param_in_bag));
338  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "vector3_param__x", temp.vector3_param.x));
339  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "vector3_param__y", temp.vector3_param.y));
340  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "vector3_param__z", temp.vector3_param.z));
341  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "int_param", temp.int_param));
342  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "double_param", temp.double_param));
343  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "str_param", temp.str_param));
344  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "bool_param", temp.bool_param));
345  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "float_param", temp.float_param));
346  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "uint_param", temp.uint_param));
347  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "bag_param__str_param", temp.str_param_in_bag));
348  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "vector3_param__x", temp.vector3_param.x));
349  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "vector3_param__y", temp.vector3_param.y));
350  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "vector3_param__z", temp.vector3_param.z));
351 }
352 
353 TEST_F(DynamicReconfigureTest, AutoConfigAddPropertiesAndRefresh)
354 {
355  // load test_reconfigure service
356  ASSERT_TRUE(tc.loadService("reconfigure"));
357  ASSERT_TRUE(tc.provides()->hasService("reconfigure"));
358 
359  // get a pointer to the reconfigure service
360  boost::shared_ptr<Server<AutoConfig> > server = boost::dynamic_pointer_cast<Server<AutoConfig> >(tc.provides("reconfigure"));
361  ASSERT_TRUE(server.get());
362 
363  // add a property to the TaskContext after having loaded the reconfigure service
364  tc.properties()->ownProperty(new RTT::Property<std::string>("new_param"));
365 
366  // refresh dynamic reconfigure service
367  server->refresh();
368 
369  // check ConfigDescription
370  dynamic_reconfigure::ConfigDescriptionPtr description = server->getDescriptionMessage();
371  std::string str;
372  EXPECT_TRUE(getParamDescription(getGroup(&(description->groups), "Default"), "new_param"));
373  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->dflt, "new_param", str));
374  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->min, "new_param", str));
375  EXPECT_TRUE(dynamic_reconfigure::ConfigTools::getParameter(description->max, "new_param", str));
376 }
377 
378 int main(int argc, char **argv) {
379  ::testing::InitGoogleTest(&argc, argv);
380 
381  // Initialize Orocos
382  __os_init(argc, argv);
383 
384  RTT::Logger::log().setStdStream(std::cerr);
385  RTT::Logger::log().mayLogStdOut(true);
386  RTT::Logger::log().setLogLevel(RTT::Logger::Debug);
387 
388  RTT::ComponentLoader::Instance()->import("rtt_ros", std::string());
389  RTT::OperationCaller<bool(std::string)> import = RTT::internal::GlobalService::Instance()->provides("ros")->getOperation("import");
390  import("rtt_dynamic_reconfigure_tests");
391 
392  return RUN_ALL_TESTS();
393 }
main
int main(int argc, char **argv)
Definition: rtt_dynamic_reconfigure_tests.cpp:378
auto_config.h
RTT::PropertyBag::getPropertyType
Property< T > * getPropertyType(const std::string &name) const
min
const T & min(const T &a, const T &b)
__os_init
int __os_init(int argc, char **argv)
rtt_dynamic_reconfigure::DynamicReconfigureTestComponent::notifyPropertiesUpdate
void notifyPropertiesUpdate(uint32_t)
Definition: test_component.hpp:93
RTT::ConfigurationInterface::properties
PropertyBag * properties()
RTT::ComponentLoader::Instance
static boost::shared_ptr< ComponentLoader > Instance()
max
const T & max(const T &a, const T &b)
boost::shared_ptr
RTT::PropertyBag::ownProperty
bool ownProperty(base::PropertyBase *p)
rtt_dynamic_reconfigure
rtt_dynamic_reconfigure::DynamicReconfigureTestComponent
Definition: test_component.hpp:51
RTT::Logger::mayLogStdOut
void mayLogStdOut(bool tf)
DynamicReconfigureTest::tc
DynamicReconfigureTestComponent tc
Definition: rtt_dynamic_reconfigure_tests.cpp:35
TEST_F
TEST_F(DynamicReconfigureTest, ConfigDescription)
Definition: rtt_dynamic_reconfigure_tests.cpp:59
rtt_dynamic_reconfigure::DynamicReconfigureTestComponent::updatePropertiesConst
bool updatePropertiesConst(const RTT::PropertyBag &bag, uint32_t)
Definition: test_component.hpp:87
RTT::Logger::log
static Logger & log()
rtt_dynamic_reconfigure::DynamicReconfigureTestComponent::updateProperties
bool updateProperties(RTT::PropertyBag &bag, uint32_t)
Definition: test_component.hpp:81
test_component.hpp
getParamDescription
static const dynamic_reconfigure::ParamDescription * getParamDescription(const dynamic_reconfigure::Group *group, const std::string &name)
Definition: rtt_dynamic_reconfigure_tests.cpp:50
RTT::Logger::setStdStream
void setStdStream(std::ostream &stdos)
RTT::PropertyBag::size
size_t size() const
rtt_dynamic_reconfigure::AutoConfig
getGroup
static const dynamic_reconfigure::Group * getGroup(const dynamic_reconfigure::ConfigDescription::_groups_type *groups, const std::string &name)
Definition: rtt_dynamic_reconfigure_tests.cpp:41
rtt_dynamic_reconfigure::Server::getDescriptionMessage
dynamic_reconfigure::ConfigDescriptionPtr getDescriptionMessage()
rtt_dynamic_reconfigure::Server
rtt_dynamic_reconfigure_tests
RTT::internal::GlobalService::Instance
static RTT_API Service::shared_ptr Instance()
RTT::Logger::setLogLevel
void setLogLevel(LogLevel ll)

rtt_dynamic_reconfigure_tests
Author(s): Johannes Meyer
autogenerated on Sat Jun 8 2019 18:05:50