gtest_fallback.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2015-2017 Michele Colledanchise - All Rights Reserved
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
4 * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
5 * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
9 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
10 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
11 */
12 
13 #include <gtest/gtest.h>
14 #include "action_test_node.h"
15 #include "condition_test_node.h"
16 #include "behaviortree_cpp/behavior_tree.h"
17 
18 using BT::NodeStatus;
19 
20 struct SimpleFallbackTest : testing::Test
21 {
22  BT::FallbackNode root;
23  BT::AsyncActionTest action;
24  BT::ConditionTestNode condition;
25 
26  SimpleFallbackTest() : root("root_fallback"), action("action"), condition("condition")
27  {
28  root.addChild(&condition);
29  root.addChild(&action);
30  }
31  ~SimpleFallbackTest()
32  {
33  haltAllActions(&root);
34  }
35 };
36 
37 struct ComplexFallbackTest : testing::Test
38 {
39  BT::FallbackNode root;
40  BT::AsyncActionTest action_1;
41  BT::ConditionTestNode condition_1;
42  BT::ConditionTestNode condition_2;
43 
44  BT::FallbackNode fal_conditions;
45 
46  ComplexFallbackTest()
47  : root("root_fallback")
48  , action_1("action_1")
49  , condition_1("condition_1")
50  , condition_2("condition_2")
51  , fal_conditions("fallback_conditions")
52  {
53  root.addChild(&fal_conditions);
54  {
55  fal_conditions.addChild(&condition_1);
56  fal_conditions.addChild(&condition_2);
57  }
58  root.addChild(&action_1);
59  }
60  ~ComplexFallbackTest()
61  {
62  haltAllActions(&root);
63  }
64 };
65 
66 struct SimpleFallbackWithMemoryTest : testing::Test
67 {
68  BT::FallbackStarNode root;
69  BT::AsyncActionTest action;
70  BT::ConditionTestNode condition;
71 
72  SimpleFallbackWithMemoryTest() : root("root_sequence"), action("action"), condition("condition")
73  {
74  root.addChild(&condition);
75  root.addChild(&action);
76  }
77  ~SimpleFallbackWithMemoryTest()
78  {
79  haltAllActions(&root);
80  }
81 };
82 
83 struct ComplexFallbackWithMemoryTest : testing::Test
84 {
85  BT::FallbackStarNode root;
86 
87  BT::AsyncActionTest action_1;
88  BT::AsyncActionTest action_2;
89 
90  BT::ConditionTestNode condition_1;
91  BT::ConditionTestNode condition_2;
92 
93  BT::FallbackStarNode fal_conditions;
94  BT::FallbackStarNode fal_actions;
95 
96  ComplexFallbackWithMemoryTest()
97  : root("root_fallback")
98  , action_1("action_1")
99  , action_2("action_2")
100  , condition_1("condition_1")
101  , condition_2("condition_2")
102  , fal_conditions("fallback_conditions")
103  , fal_actions("fallback_actions")
104  {
105  root.addChild(&fal_conditions);
106  {
107  fal_conditions.addChild(&condition_1);
108  fal_conditions.addChild(&condition_2);
109  }
110  root.addChild(&fal_actions);
111  {
112  fal_actions.addChild(&action_1);
113  fal_actions.addChild(&action_2);
114  }
115  }
116  ~ComplexFallbackWithMemoryTest()
117  {
118  haltAllActions(&root);
119  }
120 };
121 
122 /****************TESTS START HERE***************************/
123 
124 TEST_F(SimpleFallbackTest, ConditionTrue)
125 {
126  std::cout << "Ticking the root node !" << std::endl << std::endl;
127  // Ticking the root node
128  condition.setBoolean(true);
129  BT::NodeStatus state = root.executeTick();
130 
131  ASSERT_EQ(NodeStatus::SUCCESS, state);
132  ASSERT_EQ(NodeStatus::IDLE, condition.status());
133  ASSERT_EQ(NodeStatus::IDLE, action.status());
134 }
135 
136 TEST_F(SimpleFallbackTest, ConditionToFalse)
137 {
138  condition.setBoolean(false);
139 
140  BT::NodeStatus state = root.executeTick();
141  condition.setBoolean(true);
142 
143  state = root.executeTick();
144 
145  ASSERT_EQ(NodeStatus::SUCCESS, state);
146  ASSERT_EQ(NodeStatus::IDLE, condition.status());
147  ASSERT_EQ(NodeStatus::IDLE, action.status());
148 }
149 
150 TEST_F(ComplexFallbackTest, Condition1ToTrue)
151 {
152  condition_1.setBoolean(false);
153  condition_2.setBoolean(false);
154 
155  BT::NodeStatus state = root.executeTick();
156 
157  ASSERT_EQ(NodeStatus::RUNNING, state);
158  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
159  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
160  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
161  ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
162 
163  condition_1.setBoolean(true);
164 
165  state = root.executeTick();
166 
167  ASSERT_EQ(NodeStatus::SUCCESS, state);
168  ASSERT_EQ(NodeStatus::IDLE, fal_conditions.status());
169  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
170  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
171  ASSERT_EQ(NodeStatus::IDLE, action_1.status());
172 }
173 
174 TEST_F(ComplexFallbackTest, Condition2ToTrue)
175 {
176  condition_1.setBoolean(false);
177  condition_2.setBoolean(false);
178 
179  BT::NodeStatus state = root.executeTick();
180 
181  ASSERT_EQ(NodeStatus::RUNNING, state);
182  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
183  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
184  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
185  ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
186 
187  condition_2.setBoolean(true);
188 
189  state = root.executeTick();
190 
191  ASSERT_EQ(NodeStatus::SUCCESS, state);
192  ASSERT_EQ(NodeStatus::IDLE, fal_conditions.status());
193  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
194  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
195  ASSERT_EQ(NodeStatus::IDLE, action_1.status());
196 }
197 
198 TEST_F(SimpleFallbackWithMemoryTest, ConditionFalse)
199 {
200  condition.setBoolean(false);
201  BT::NodeStatus state = root.executeTick();
202  std::this_thread::sleep_for(std::chrono::milliseconds(100));
203 
204  ASSERT_EQ(NodeStatus::RUNNING, state);
205  ASSERT_EQ(NodeStatus::FAILURE, condition.status());
206  ASSERT_EQ(NodeStatus::RUNNING, action.status());
207 }
208 
209 TEST_F(SimpleFallbackWithMemoryTest, ConditionTurnToTrue)
210 {
211  condition.setBoolean(false);
212  BT::NodeStatus state = root.executeTick();
213 
214  ASSERT_EQ(NodeStatus::RUNNING, state);
215  ASSERT_EQ(NodeStatus::FAILURE, condition.status());
216  ASSERT_EQ(NodeStatus::RUNNING, action.status());
217 
218  condition.setBoolean(true);
219  state = root.executeTick();
220 
221  ASSERT_EQ(NodeStatus::RUNNING, state);
222  ASSERT_EQ(NodeStatus::FAILURE, condition.status());
223  ASSERT_EQ(NodeStatus::RUNNING, action.status());
224 }
225 
226 TEST_F(ComplexFallbackWithMemoryTest, ConditionsTrue)
227 {
228  BT::NodeStatus state = root.executeTick();
229 
230  ASSERT_EQ(NodeStatus::SUCCESS, state);
231  ASSERT_EQ(NodeStatus::IDLE, fal_conditions.status());
232  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
233  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
234  ASSERT_EQ(NodeStatus::IDLE, fal_actions.status());
235  ASSERT_EQ(NodeStatus::IDLE, action_1.status());
236  ASSERT_EQ(NodeStatus::IDLE, action_2.status());
237 }
238 
239 TEST_F(ComplexFallbackWithMemoryTest, Condition1False)
240 {
241  condition_1.setBoolean(false);
242  BT::NodeStatus state = root.executeTick();
243 
244  ASSERT_EQ(NodeStatus::SUCCESS, state);
245  ASSERT_EQ(NodeStatus::IDLE, fal_conditions.status());
246  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
247  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
248  ASSERT_EQ(NodeStatus::IDLE, fal_actions.status());
249  ASSERT_EQ(NodeStatus::IDLE, action_1.status());
250  ASSERT_EQ(NodeStatus::IDLE, action_2.status());
251 }
252 
253 TEST_F(ComplexFallbackWithMemoryTest, ConditionsFalse)
254 {
255  condition_1.setBoolean(false);
256  condition_2.setBoolean(false);
257  BT::NodeStatus state = root.executeTick();
258 
259  ASSERT_EQ(NodeStatus::RUNNING, state);
260  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
261  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
262  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
263  ASSERT_EQ(NodeStatus::RUNNING, fal_actions.status());
264  ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
265  ASSERT_EQ(NodeStatus::IDLE, action_2.status());
266 }
267 
268 TEST_F(ComplexFallbackWithMemoryTest, Conditions1ToTrue)
269 {
270  condition_1.setBoolean(false);
271  condition_2.setBoolean(false);
272  BT::NodeStatus state = root.executeTick();
273 
274  condition_1.setBoolean(true);
275  state = root.executeTick();
276 
277  ASSERT_EQ(NodeStatus::RUNNING, state);
278  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
279  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
280  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
281  ASSERT_EQ(NodeStatus::RUNNING, fal_actions.status());
282  ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
283  ASSERT_EQ(NodeStatus::IDLE, action_2.status());
284 }
285 
286 TEST_F(ComplexFallbackWithMemoryTest, Conditions2ToTrue)
287 {
288  condition_1.setBoolean(false);
289  condition_2.setBoolean(false);
290  BT::NodeStatus state = root.executeTick();
291 
292  condition_2.setBoolean(true);
293  state = root.executeTick();
294 
295  ASSERT_EQ(NodeStatus::RUNNING, state);
296  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
297  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
298  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
299  ASSERT_EQ(NodeStatus::RUNNING, fal_actions.status());
300  ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
301  ASSERT_EQ(NodeStatus::IDLE, action_2.status());
302 }
303 
304 TEST_F(ComplexFallbackWithMemoryTest, Action1Failed)
305 {
306  action_1.setBoolean(false);
307  condition_1.setBoolean(false);
308  condition_2.setBoolean(false);
309 
310  BT::NodeStatus state = root.executeTick();
311 
312  state = root.executeTick();
313  std::this_thread::sleep_for(std::chrono::milliseconds(500));
314  state = root.executeTick();
315 
316  ASSERT_EQ(NodeStatus::RUNNING, state);
317  ASSERT_EQ(NodeStatus::FAILURE, fal_conditions.status());
318  ASSERT_EQ(NodeStatus::IDLE, condition_1.status());
319  ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
320  ASSERT_EQ(NodeStatus::RUNNING, fal_actions.status());
321  ASSERT_EQ(NodeStatus::FAILURE, action_1.status());
322  ASSERT_EQ(NodeStatus::RUNNING, action_2.status());
323 }
ComplexFallbackWithMemoryTest::fal_conditions
BT::FallbackStarNode fal_conditions
Definition: gtest_fallback.cpp:93
ComplexFallbackWithMemoryTest::action_1
BT::AsyncActionTest action_1
Definition: gtest_fallback.cpp:87
SimpleFallbackTest::action
BT::AsyncActionTest action
Definition: gtest_fallback.cpp:23
SimpleFallbackWithMemoryTest::condition
BT::ConditionTestNode condition
Definition: gtest_fallback.cpp:70
SimpleFallbackTest::condition
BT::ConditionTestNode condition
Definition: gtest_fallback.cpp:24
SimpleFallbackWithMemoryTest::root
BT::FallbackStarNode root
Definition: gtest_fallback.cpp:68
BT::ConditionTestNode::setBoolean
void setBoolean(bool boolean_value)
Definition: condition_test_node.cpp:40
ComplexFallbackWithMemoryTest::action_2
BT::AsyncActionTest action_2
Definition: gtest_fallback.cpp:88
ComplexFallbackTest::condition_2
BT::ConditionTestNode condition_2
Definition: gtest_fallback.cpp:42
ComplexFallbackTest::action_1
BT::AsyncActionTest action_1
Definition: gtest_fallback.cpp:40
condition_test_node.h
ComplexFallbackTest::fal_conditions
BT::FallbackNode fal_conditions
Definition: gtest_fallback.cpp:44
BT::haltAllActions
void haltAllActions(TreeNode *root_node)
Definition: behavior_tree.cpp:116
BT::FallbackStarNode
The FallbackStarNode is used to try different strategies, until one succeed. If any child returns RUN...
Definition: fallback_star_node.h:34
action_test_node.h
ComplexFallbackTest::root
BT::FallbackNode root
Definition: gtest_fallback.cpp:39
ComplexFallbackTest::condition_1
BT::ConditionTestNode condition_1
Definition: gtest_fallback.cpp:41
SimpleFallbackTest::root
BT::FallbackNode root
Definition: gtest_fallback.cpp:22
behavior_tree.h
BT::ControlNode::addChild
void addChild(TreeNode *child)
Definition: control_node.cpp:26
ComplexFallbackWithMemoryTest::fal_actions
BT::FallbackStarNode fal_actions
Definition: gtest_fallback.cpp:94
BT::TreeNode::status
NodeStatus status() const
Definition: tree_node.cpp:75
SimpleFallbackWithMemoryTest::action
BT::AsyncActionTest action
Definition: gtest_fallback.cpp:69
BT::NodeStatus
NodeStatus
Definition: basic_types.h:28
ComplexFallbackWithMemoryTest::condition_2
BT::ConditionTestNode condition_2
Definition: gtest_fallback.cpp:91
BT::TreeNode::executeTick
virtual BT::NodeStatus executeTick()
The method that will be executed to invoke tick(); and setStatus();.
Definition: tree_node.cpp:35
BT::FallbackNode
The FallbackNode is used to try different strategies, until one succeed. If any child returns RUNNING...
Definition: fallback_node.h:35
ComplexFallbackWithMemoryTest::condition_1
BT::ConditionTestNode condition_1
Definition: gtest_fallback.cpp:90
TEST_F
TEST_F(SimpleFallbackTest, ConditionTrue)
Definition: gtest_fallback.cpp:124

behaviortree_cpp
Author(s): Michele Colledanchise, Davide Faconti
autogenerated on Sun Feb 3 2019 03:14:32