test_stacklight.cpp
Go to the documentation of this file.
1 /*
2  * Software License Agreement (Apache License)
3  *
4  * Copyright (c) 2019 Joshua Hatzenbuehler
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #include <gtest/gtest.h>
20 #include <ros/ros.h>
21 #include "packml_stacklight/utils.h"
22 
23 namespace utils_test
24 {
25 class StacklightTest : public testing::Test, packml_stacklight::Utils
26 {
27 protected:
28  StacklightTest()
29  {
30  int8_t max_state_value = packml_msgs::State::COMPLETE + 1;
31 
32  SCOPED_TRACE("StatusActionEmptyTest");
33  EXPECT_NE(0, action_vec_.size());
34 
35  SCOPED_TRACE("StatusActionCorrectSize");
36  EXPECT_EQ(max_state_value, action_vec_.size());
37  }
38 
39  FRIEND_TEST(StacklightTest, LightVectorInit);
40  FRIEND_TEST(StacklightTest, ButtonVectorInit);
41  FRIEND_TEST(StacklightTest, DefaultStateMatch);
42  FRIEND_TEST(StacklightTest, LightFlashOnSecs);
43  FRIEND_TEST(StacklightTest, LightFlashOffSecs);
44  FRIEND_TEST(StacklightTest, BuzzerFlashOnSecs);
45  FRIEND_TEST(StacklightTest, BuzzerFlashOffSecs);
46  FRIEND_TEST(StacklightTest, PublishFrequency);
47  FRIEND_TEST(StacklightTest, StatusTimeout);
48  FRIEND_TEST(StacklightTest, LightFlash);
49  FRIEND_TEST(StacklightTest, BuzzerFlash);
50  FRIEND_TEST(StacklightTest, PublishAllNoState);
51  FRIEND_TEST(StacklightTest, PublishAll);
52  FRIEND_TEST(StacklightTest, StatusTimeoutReset);
53  FRIEND_TEST(StacklightTest, StatusTimeoutNoReset);
54  FRIEND_TEST(StacklightTest, TestPubMapFromAction);
55  FRIEND_TEST(StacklightTest, TestPubMapFromState);
56  FRIEND_TEST(StacklightTest, TestPublishTopics);
57 };
58 
59 TEST_F(StacklightTest, LightActionDefault)
60 {
61  packml_stacklight::Light light;
62  EXPECT_EQ(false, light.active_);
63  EXPECT_EQ(false, light.flashing_);
64  EXPECT_EQ(packml_stacklight::Light::Value::UNDEFINED, light.current_);
65 }
66 
67 TEST_F(StacklightTest, BuzzerActionDefault)
68 {
69  packml_stacklight::Buzzer buzzer;
70  EXPECT_EQ(false, buzzer.active_);
71  EXPECT_EQ(false, buzzer.flashing_);
72 }
73 
74 TEST_F(StacklightTest, ButtonActionDefault)
75 {
76  packml_stacklight::Button button;
77  EXPECT_EQ(false, button.light_.active_);
78  EXPECT_EQ(false, button.light_.flashing_);
79  EXPECT_EQ(packml_stacklight::Button::Value::UNDEFINED, button.current_);
80 }
81 
82 TEST_F(StacklightTest, LightVectorInit)
83 {
84  int8_t max_light_value = packml_stacklight::Light::Value::BLUE + 1;
85 
86  std::vector<packml_stacklight::Action>::iterator action_it;
87  for (action_it = action_vec_.begin(); action_it != action_vec_.end(); ++action_it)
88  {
89  EXPECT_EQ(max_light_value, action_it->light_vec_.size());
90  }
91 }
92 
93 TEST_F(StacklightTest, ButtonVectorInit)
94 {
95  int8_t max_button_value = packml_stacklight::Button::Value::RESET + 1;
96 
97  std::vector<packml_stacklight::Action>::iterator action_it;
98  for (action_it = action_vec_.begin(); action_it != action_vec_.end(); ++action_it)
99  {
100  EXPECT_EQ(max_button_value, action_it->button_vec_.size());
101  }
102 }
103 
104 TEST_F(StacklightTest, DefaultStateMatch)
105 {
106  for (int8_t state = packml_msgs::State::UNDEFINED; state <= packml_msgs::State::COMPLETE; state++)
107  {
108  std::vector<packml_stacklight::Light>::iterator light_it;
109  std::vector<packml_stacklight::Button>::iterator button_it;
110  packml_msgs::State temp;
111  temp.val = state;
112 
113  packml_stacklight::Action action = getActionFromState(temp);
114 
115  switch (state)
116  {
117  case packml_msgs::State::ABORTING:
118  case packml_msgs::State::ABORTED:
119  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
120  {
121  if (light_it->current_ == packml_stacklight::Light::Value::RED ||
122  light_it->current_ == packml_stacklight::Light::Value::BLUE)
123  {
124  EXPECT_EQ(true, light_it->active_);
125  EXPECT_EQ(true, light_it->flashing_);
126  }
127  else
128  {
129  EXPECT_EQ(false, light_it->active_);
130  }
131  }
132 
133  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
134  {
135  if (button_it->current_ == packml_stacklight::Button::Value::RESET)
136  {
137  EXPECT_EQ(true, button_it->light_.active_);
138  EXPECT_EQ(true, button_it->light_.flashing_);
139  EXPECT_EQ(packml_stacklight::Light::Value::BLUE, button_it->light_.current_);
140  }
141  else
142  {
143  EXPECT_EQ(false, button_it->light_.active_);
144  }
145  }
146 
147  EXPECT_EQ(false, action.buzzer_.active_);
148  break;
149 
150  case packml_msgs::State::CLEARING:
151  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
152  {
153  if (light_it->current_ == packml_stacklight::Light::Value::RED ||
154  light_it->current_ == packml_stacklight::Light::Value::BLUE)
155  {
156  EXPECT_EQ(true, light_it->active_);
157  EXPECT_EQ(true, light_it->flashing_);
158  }
159  else
160  {
161  EXPECT_EQ(false, light_it->active_);
162  }
163  }
164 
165  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
166  {
167  EXPECT_EQ(false, button_it->light_.active_);
168  }
169 
170  EXPECT_EQ(false, action.buzzer_.active_);
171  break;
172 
173  case packml_msgs::State::STOPPING:
174  case packml_msgs::State::STOPPED:
175  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
176  {
177  if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
178  {
179  EXPECT_EQ(true, light_it->active_);
180  EXPECT_EQ(true, light_it->flashing_);
181  }
182  else if (light_it->current_ == packml_stacklight::Light::Value::RED)
183  {
184  EXPECT_EQ(true, light_it->active_);
185  EXPECT_EQ(false, light_it->flashing_);
186  }
187  else
188  {
189  EXPECT_EQ(false, light_it->active_);
190  }
191  }
192 
193  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
194  {
195  EXPECT_EQ(false, button_it->light_.active_);
196  }
197 
198  EXPECT_EQ(false, action.buzzer_.active_);
199  break;
200 
201  case packml_msgs::State::RESETTING:
202  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
203  {
204  if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
205  {
206  EXPECT_EQ(true, light_it->active_);
207  EXPECT_EQ(true, light_it->flashing_);
208  }
209  else
210  {
211  EXPECT_EQ(false, light_it->active_);
212  }
213  }
214 
215  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
216  {
217  EXPECT_EQ(false, button_it->light_.active_);
218  }
219 
220  EXPECT_EQ(false, action.buzzer_.active_);
221  break;
222 
223  case packml_msgs::State::IDLE:
224  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
225  {
226  if (light_it->current_ == packml_stacklight::Light::Value::GREEN ||
227  light_it->current_ == packml_stacklight::Light::Value::BLUE)
228  {
229  EXPECT_EQ(true, light_it->active_);
230  EXPECT_EQ(true, light_it->flashing_);
231  }
232  else
233  {
234  EXPECT_EQ(false, light_it->active_);
235  }
236  }
237 
238  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
239  {
240  if (button_it->current_ == packml_stacklight::Button::Value::START)
241  {
242  EXPECT_EQ(true, button_it->light_.active_);
243  EXPECT_EQ(true, button_it->light_.flashing_);
244  EXPECT_EQ(packml_stacklight::Light::Value::GREEN, button_it->light_.current_);
245  }
246  else
247  {
248  EXPECT_EQ(false, button_it->light_.active_);
249  }
250  }
251 
252  EXPECT_EQ(false, action.buzzer_.active_);
253  break;
254 
255  case packml_msgs::State::STARTING:
256  case packml_msgs::State::UNHOLDING:
257  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
258  {
259  if (light_it->current_ == packml_stacklight::Light::Value::GREEN)
260  {
261  EXPECT_EQ(true, light_it->active_);
262  EXPECT_EQ(false, light_it->flashing_);
263  }
264  else if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
265  {
266  EXPECT_EQ(true, light_it->active_);
267  EXPECT_EQ(true, light_it->flashing_);
268  }
269  else
270  {
271  EXPECT_EQ(false, light_it->active_);
272  }
273  }
274 
275  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
276  {
277  if (button_it->current_ == packml_stacklight::Button::Value::START)
278  {
279  EXPECT_EQ(true, button_it->light_.active_);
280  EXPECT_EQ(false, button_it->light_.flashing_);
281  EXPECT_EQ(packml_stacklight::Light::Value::GREEN, button_it->light_.current_);
282  }
283  else
284  {
285  EXPECT_EQ(false, button_it->light_.active_);
286  }
287  }
288 
289  EXPECT_EQ(true, action.buzzer_.active_);
290  EXPECT_EQ(true, action.buzzer_.flashing_);
291  break;
292 
293  case packml_msgs::State::EXECUTE:
294  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
295  {
296  if (light_it->current_ == packml_stacklight::Light::Value::GREEN)
297  {
298  EXPECT_EQ(true, light_it->active_);
299  EXPECT_EQ(false, light_it->flashing_);
300  }
301  else if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
302  {
303  EXPECT_EQ(true, light_it->active_);
304  EXPECT_EQ(true, light_it->flashing_);
305  }
306  else
307  {
308  EXPECT_EQ(false, light_it->active_);
309  }
310  }
311 
312  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
313  {
314  if (button_it->current_ == packml_stacklight::Button::Value::START)
315  {
316  EXPECT_EQ(true, button_it->light_.active_);
317  EXPECT_EQ(false, button_it->light_.flashing_);
318  EXPECT_EQ(packml_stacklight::Light::Value::GREEN, button_it->light_.current_);
319  }
320  else
321  {
322  EXPECT_EQ(false, button_it->light_.active_);
323  }
324  }
325 
326  EXPECT_EQ(false, action.buzzer_.active_);
327  break;
328 
329  case packml_msgs::State::HOLDING:
330  case packml_msgs::State::HELD:
331  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
332  {
333  if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
334  {
335  EXPECT_EQ(true, light_it->active_);
336  EXPECT_EQ(false, light_it->flashing_);
337  }
338  else
339  {
340  EXPECT_EQ(false, light_it->active_);
341  }
342  }
343 
344  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
345  {
346  EXPECT_EQ(false, button_it->light_.active_);
347  }
348 
349  EXPECT_EQ(false, action.buzzer_.active_);
350  break;
351 
352  case packml_msgs::State::SUSPENDING:
353  case packml_msgs::State::SUSPENDED:
354  // todo starving vs blocked => flashing vs steady
355  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
356  {
357  if (light_it->current_ == packml_stacklight::Light::Value::AMBER)
358  {
359  EXPECT_EQ(true, light_it->active_);
360  EXPECT_EQ(true, light_it->flashing_); // todo check if flashing or steady from config
361  }
362  else if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
363  {
364  EXPECT_EQ(true, light_it->active_);
365  EXPECT_EQ(true, light_it->flashing_);
366  }
367  else
368  {
369  EXPECT_EQ(false, light_it->active_);
370  }
371  }
372 
373  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
374  {
375  if (button_it->current_ == packml_stacklight::Button::Value::START)
376  {
377  EXPECT_EQ(true, button_it->light_.active_);
378  EXPECT_EQ(false, button_it->light_.flashing_);
379  EXPECT_EQ(packml_stacklight::Light::Value::GREEN, button_it->light_.current_);
380  }
381  else
382  {
383  EXPECT_EQ(false, button_it->light_.active_);
384  }
385  }
386 
387  EXPECT_EQ(false, action.buzzer_.active_);
388  break;
389 
390  case packml_msgs::State::UNSUSPENDING:
391  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
392  {
393  if (light_it->current_ == packml_stacklight::Light::Value::GREEN)
394  {
395  EXPECT_EQ(true, light_it->active_);
396  EXPECT_EQ(false, light_it->flashing_);
397  }
398  else if (light_it->current_ == packml_stacklight::Light::Value::BLUE)
399  {
400  EXPECT_EQ(true, light_it->active_);
401  EXPECT_EQ(true, light_it->flashing_);
402  }
403  else
404  {
405  EXPECT_EQ(false, light_it->active_);
406  }
407  }
408 
409  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
410  {
411  EXPECT_EQ(false, button_it->light_.active_);
412  }
413 
414  EXPECT_EQ(true, action.buzzer_.active_);
415  EXPECT_EQ(true, action.buzzer_.flashing_);
416  break;
417 
418  default:
419  for (light_it = action.light_vec_.begin(); light_it != action.light_vec_.end(); ++light_it)
420  {
421  EXPECT_EQ(false, light_it->active_);
422  }
423 
424  for (button_it = action.button_vec_.begin(); button_it != action.button_vec_.end(); ++button_it)
425  {
426  EXPECT_EQ(false, button_it->light_.active_);
427  }
428 
429  EXPECT_EQ(false, action.buzzer_.active_);
430  break;
431  }
432  }
433 }
434 
435 TEST_F(StacklightTest, LightFlashOnSecs)
436 {
437  double default_val = flash_sec_light_on_;
438  double set_val = flash_sec_light_on_ = default_val * 2;
439  EXPECT_EQ(flash_sec_light_on_, set_val);
440  EXPECT_NE(flash_sec_light_on_, default_val);
441 }
442 
443 TEST_F(StacklightTest, LightFlashOffSecs)
444 {
445  double default_val = flash_sec_light_off_;
446  double set_val = flash_sec_light_off_ = default_val * 2;
447  EXPECT_EQ(flash_sec_light_off_, set_val);
448  EXPECT_NE(flash_sec_light_off_, default_val);
449 }
450 
451 TEST_F(StacklightTest, BuzzerFlashOnSecs)
452 {
453  double default_val = flash_sec_buzzer_on_;
454  double set_val = flash_sec_buzzer_on_ = default_val * 2;
455  EXPECT_EQ(flash_sec_buzzer_on_, set_val);
456  EXPECT_NE(flash_sec_buzzer_on_, default_val);
457 }
458 
459 TEST_F(StacklightTest, BuzzerFlashOffSecs)
460 {
461  double default_val = flash_sec_buzzer_off_;
462  double set_val = flash_sec_buzzer_off_ = default_val * 2;
463  EXPECT_EQ(flash_sec_buzzer_off_, set_val);
464  EXPECT_NE(flash_sec_buzzer_off_, default_val);
465 }
466 
467 TEST_F(StacklightTest, PublishFrequency)
468 {
469  double default_val = publish_frequency_;
470  double set_val = publish_frequency_ = default_val * 2;
471  EXPECT_EQ(publish_frequency_, set_val);
472  EXPECT_NE(publish_frequency_, default_val);
473 }
474 
475 TEST_F(StacklightTest, StatusTimeout)
476 {
477  double default_val = status_timeout_;
478  double set_val = status_timeout_ = default_val * 2;
479  EXPECT_EQ(status_timeout_, set_val);
480  EXPECT_NE(status_timeout_, default_val);
481 }
482 
483 TEST_F(StacklightTest, LightFlash)
484 {
485  packml_stacklight::Flash::Value flash = packml_stacklight::Flash::Value::ON;
486  packml_msgs::State temp;
487  temp.val = packml_msgs::State::ABORTING;
488 
489  flash_sec_light_on_ = 0.5;
490  flash_sec_light_off_ = 0.5;
491 
492  double on_secs = flash_sec_light_on_;
493  double off_secs = flash_sec_light_off_;
494 
495  flash = getLightFlash(temp);
496  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
497 
498  ros::Duration(0.1).sleep();
499  flash = getLightFlash(temp);
500  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
501 
502  ros::Duration(on_secs).sleep();
503  flash = getLightFlash(temp);
504  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
505 
506  ros::Duration(0.1).sleep();
507  flash = getLightFlash(temp);
508  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
509 
510  ros::Duration(off_secs).sleep();
511  flash = getLightFlash(temp);
512  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
513 
514  ros::Duration(on_secs * 2).sleep();
515  flash = getLightFlash(temp);
516  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
517 
518  temp.val = packml_msgs::State::ABORTED;
519  flash = getLightFlash(temp);
520  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
521 }
522 
523 TEST_F(StacklightTest, BuzzerFlash)
524 {
525  packml_stacklight::Flash::Value flash = packml_stacklight::Flash::Value::ON;
526  packml_msgs::State temp;
527  temp.val = packml_msgs::State::STOPPING;
528 
529  flash_sec_buzzer_on_ = 0.5;
530  flash_sec_buzzer_off_ = 0.5;
531 
532  double on_secs = flash_sec_buzzer_on_;
533  double off_secs = flash_sec_buzzer_off_;
534 
535  flash = getBuzzerFlash(temp);
536  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
537 
538  ros::Duration(0.1).sleep();
539  flash = getBuzzerFlash(temp);
540  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
541 
542  ros::Duration(on_secs).sleep();
543  flash = getBuzzerFlash(temp);
544  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
545 
546  ros::Duration(0.1).sleep();
547  flash = getBuzzerFlash(temp);
548  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
549 
550  ros::Duration(off_secs).sleep();
551  flash = getBuzzerFlash(temp);
552  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
553 
554  ros::Duration(on_secs * 2).sleep();
555  flash = getBuzzerFlash(temp);
556  EXPECT_EQ(packml_stacklight::Flash::Value::OFF, flash);
557 
558  temp.val = packml_msgs::State::STOPPED;
559  flash = getBuzzerFlash(temp);
560  EXPECT_EQ(packml_stacklight::Flash::Value::ON, flash);
561 }
562 
563 TEST_F(StacklightTest, PublishAllNoState)
564 {
565  bool pub_all = false;
566  packml_msgs::State temp;
567  temp.val = packml_msgs::State::UNDEFINED;
568 
569  publish_frequency_ = 0.5;
570 
571  double secs = publish_frequency_;
572 
573  pub_all = getShouldPublish(temp);
574  EXPECT_EQ(true, pub_all);
575 
576  ros::Duration(0.1).sleep();
577  pub_all = getShouldPublish(temp);
578  EXPECT_EQ(false, pub_all);
579 
580  ros::Duration(0.1).sleep();
581  pub_all = getShouldPublish(temp);
582  EXPECT_EQ(false, pub_all);
583 
584  ros::Duration(secs).sleep();
585  pub_all = getShouldPublish(temp);
586  EXPECT_EQ(true, pub_all);
587 
588  ros::Duration(0.1).sleep();
589  pub_all = getShouldPublish(temp);
590  EXPECT_EQ(false, pub_all);
591 
592  ros::Duration(0.1).sleep();
593  pub_all = getShouldPublish(temp);
594  EXPECT_EQ(false, pub_all);
595 }
596 
597 TEST_F(StacklightTest, PublishAll)
598 {
599  bool pub_all = false;
600  packml_msgs::State temp;
601  temp.val = packml_msgs::State::STOPPING;
602 
603  publish_frequency_ = 0.5;
604 
605  double secs = publish_frequency_;
606 
607  pub_all = getShouldPublish(temp);
608  EXPECT_EQ(true, pub_all);
609 
610  ros::Duration(0.1).sleep();
611  pub_all = getShouldPublish(temp);
612  EXPECT_EQ(false, pub_all);
613 
614  ros::Duration(secs).sleep();
615  pub_all = getShouldPublish(temp);
616  EXPECT_EQ(true, pub_all);
617 
618  ros::Duration(0.1).sleep();
619  pub_all = getShouldPublish(temp);
620  EXPECT_EQ(false, pub_all);
621 
622  ros::Duration(0.1).sleep();
623  pub_all = getShouldPublish(temp);
624  EXPECT_EQ(false, pub_all);
625 
626  ros::Duration(secs).sleep();
627  pub_all = getShouldPublish(temp);
628  EXPECT_EQ(true, pub_all);
629 
630  ros::Duration(0.1).sleep();
631  temp.val = packml_msgs::State::STOPPED;
632  pub_all = getShouldPublish(temp);
633  EXPECT_EQ(true, pub_all);
634 
635  ros::Duration(0.1).sleep();
636  pub_all = getShouldPublish(temp);
637  EXPECT_EQ(false, pub_all);
638 }
639 
640 TEST_F(StacklightTest, StatusTimeoutReset)
641 {
642  packml_msgs::State temp;
643  temp.val = packml_msgs::State::STOPPING;
644  ros::Time temp_time = ros::Time(0);
645 
646  status_timeout_ = 0.5;
647 
648  double secs = status_timeout_;
649 
650  maybeResetState(temp, temp_time);
651  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
652  EXPECT_NE(ros::Time(0), temp_time);
653 
654  ros::Duration(0.1).sleep();
655  maybeResetState(temp, temp_time);
656  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
657 
658  ros::Duration(0.1).sleep();
659  maybeResetState(temp, temp_time);
660  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
661 
662  ros::Duration(secs).sleep();
663  maybeResetState(temp, temp_time);
664  EXPECT_EQ(packml_msgs::State::UNDEFINED, temp.val);
665 }
666 
667 TEST_F(StacklightTest, StatusTimeoutNoReset)
668 {
669  packml_msgs::State temp;
670  temp.val = packml_msgs::State::STOPPING;
671  ros::Time temp_time = ros::Time(0);
672 
673  status_timeout_ = 0.0;
674 
675  double secs = status_timeout_;
676 
677  maybeResetState(temp, temp_time);
678  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
679  EXPECT_NE(ros::Time(0), temp_time);
680 
681  ros::Duration(0.1).sleep();
682  maybeResetState(temp, temp_time);
683  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
684 
685  ros::Duration(.5).sleep();
686  maybeResetState(temp, temp_time);
687  EXPECT_EQ(packml_msgs::State::STOPPING, temp.val);
688 }
689 
690 TEST_F(StacklightTest, TestPubMapFromAction)
691 {
692  packml_msgs::State temp;
693  temp.val = packml_msgs::State::STARTING;
694  int8_t max_light_value = packml_stacklight::Light::Value::BLUE;
695  int8_t max_button_value = packml_stacklight::Button::Value::RESET;
696  int32_t max_map_count = max_light_value + max_button_value + 1; // plus one is for buzzer
697 
698  packml_stacklight::Action action = getActionFromState(temp);
699  std::map<std::string, uint8_t> temp_map = getPubMap(action);
700  EXPECT_EQ(max_map_count, temp_map.size());
701 }
702 
703 TEST_F(StacklightTest, TestPubMapFromState)
704 {
705  packml_msgs::State temp;
706  temp.val = packml_msgs::State::STARTING;
707  int8_t max_light_value = packml_stacklight::Light::Value::BLUE;
708  int8_t max_button_value = packml_stacklight::Button::Value::RESET;
709  int32_t max_map_count = max_light_value + max_button_value + 1; // plus one is for buzzer
710 
711  std::map<std::string, uint8_t> temp_map = getPubMap(temp);
712  EXPECT_EQ(max_map_count, temp_map.size());
713 }
714 
715 TEST_F(StacklightTest, TestPublishTopics)
716 {
717  packml_msgs::State temp;
718  temp.val = packml_msgs::State::UNDEFINED;
719 
720  std::map<std::string, uint8_t> temp_map = getPubMap(temp);
721  std::map<std::string, uint8_t>::iterator map_itr;
722 
723  map_itr = temp_map.find("UNDEFINED");
724  EXPECT_EQ(temp_map.end(), map_itr);
725 
726  map_itr = temp_map.find("UNDEFINED-LIGHT");
727  EXPECT_EQ(temp_map.end(), map_itr);
728 
729  map_itr = temp_map.find("UNDEFINED-BUTTON");
730  EXPECT_EQ(temp_map.end(), map_itr);
731 
732  map_itr = temp_map.find("red");
733  EXPECT_NE(temp_map.end(), map_itr);
734  temp_map.erase(map_itr);
735 
736  map_itr = temp_map.find("amber");
737  EXPECT_NE(temp_map.end(), map_itr);
738  temp_map.erase(map_itr);
739 
740  map_itr = temp_map.find("green");
741  EXPECT_NE(temp_map.end(), map_itr);
742  temp_map.erase(map_itr);
743 
744  map_itr = temp_map.find("blue");
745  EXPECT_NE(temp_map.end(), map_itr);
746  temp_map.erase(map_itr);
747 
748  map_itr = temp_map.find("start");
749  EXPECT_NE(temp_map.end(), map_itr);
750  temp_map.erase(map_itr);
751 
752  map_itr = temp_map.find("reset");
753  EXPECT_NE(temp_map.end(), map_itr);
754  temp_map.erase(map_itr);
755 
756  map_itr = temp_map.find("buzzer");
757  EXPECT_NE(temp_map.end(), map_itr);
758  temp_map.erase(map_itr);
759 
760  EXPECT_EQ(0, temp_map.size());
761 }
762 
763 } // namespace utils_test
764 
765 int main(int argc, char** argv)
766 {
767  ros::Time::init();
768  ::testing::InitGoogleTest(&argc, argv);
769 
770  int res = RUN_ALL_TESTS();
771 
772  return res;
773 }
packml_stacklight::Utils::getPubMap
std::map< std::string, uint8_t > getPubMap(Action action)
Definition: utils.cpp:269
packml_stacklight::Action::button_vec_
std::vector< Button > button_vec_
Definition: action.h:34
packml_stacklight::Light
Definition: light.h:26
packml_stacklight::Utils::flash_sec_light_off_
double flash_sec_light_off_
Definition: utils.h:39
utils_test::StacklightTest::StacklightTest
StacklightTest()
Definition: test_stacklight.cpp:28
packml_stacklight::Light::active_
bool active_
Definition: light.h:44
ros::Duration::sleep
bool sleep() const
packml_stacklight::Utils::status_timeout_
double status_timeout_
Definition: utils.h:43
packml_stacklight::Utils::maybeResetState
void maybeResetState(packml_msgs::State &current_state, ros::Time &last_time)
Definition: utils.cpp:338
packml_stacklight::Utils::getActionFromState
Action getActionFromState(packml_msgs::State current_state)
Definition: utils.cpp:259
utils_test
Definition: test_stacklight.cpp:23
packml_stacklight::Utils::action_vec_
std::vector< Action > action_vec_
Definition: utils.h:35
packml_stacklight::Utils::getShouldPublish
bool getShouldPublish(packml_msgs::State current_state)
Definition: utils.cpp:236
packml_stacklight::Button::current_
Value current_
Definition: button.h:41
packml_stacklight::Button::light_
Light light_
Definition: button.h:42
packml_stacklight::Utils::publish_frequency_
double publish_frequency_
Definition: utils.h:42
packml_stacklight::Utils::flash_sec_buzzer_off_
double flash_sec_buzzer_off_
Definition: utils.h:41
packml_stacklight::Button
Definition: button.h:28
packml_stacklight::Action::light_vec_
std::vector< Light > light_vec_
Definition: action.h:33
packml_stacklight::Buzzer
Definition: buzzer.h:26
utils_test::TEST_F
TEST_F(StacklightTest, LightActionDefault)
Definition: test_stacklight.cpp:59
packml_stacklight::Action
Definition: action.h:29
packml_stacklight::Utils::flash_sec_light_on_
double flash_sec_light_on_
Definition: utils.h:38
packml_stacklight::Utils
Definition: utils.h:32
ros::Time::init
static void init()
packml_stacklight::Utils::getBuzzerFlash
Flash::Value getBuzzerFlash(packml_msgs::State current_state)
Definition: utils.cpp:196
packml_stacklight::Utils::getLightFlash
Flash::Value getLightFlash(packml_msgs::State current_state)
Definition: utils.cpp:185
utils_test::StacklightTest::FRIEND_TEST
FRIEND_TEST(StacklightTest, LightVectorInit)
packml_stacklight::Buzzer::active_
bool active_
Definition: buzzer.h:29
packml_stacklight::Buzzer::flashing_
bool flashing_
Definition: buzzer.h:30
packml_stacklight::Flash::Value
Value
Definition: flash.h:29
packml_stacklight::Light::flashing_
bool flashing_
Definition: light.h:45
utils_test::StacklightTest
Definition: test_stacklight.cpp:25
packml_stacklight::Action::buzzer_
Buzzer buzzer_
Definition: action.h:35
packml_stacklight::Light::current_
Value current_
Definition: light.h:43
main
int main(int argc, char **argv)
Definition: test_stacklight.cpp:765
packml_stacklight::Utils::flash_sec_buzzer_on_
double flash_sec_buzzer_on_
Definition: utils.h:40

packml_stacklight
Author(s): Joshua Hatzenbuehler
autogenerated on Fri Jul 12 2019 03:31:01