9 #include "gtest/gtest.h"
12 #define private public
21 #include <std_msgs/Header.h>
26 void spin(
double duration,
double wait)
29 while (waited < duration)
39 spin(duration, duration / 1000.0);
46 for (
const auto& sub : subs)
48 if (sub->getName() == topic)
50 num += sub->getNumCallbacks();
88 TEST(GenericLazyPubSub, OverallTest)
91 const auto ns = pnh.getNamespace();
92 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
94 size_t numOutReceived = 0;
97 EXPECT_EQ(0, inPub.getNumSubscribers());
100 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
105 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
108 EXPECT_EQ(0, lazySub->numProcessed);
109 EXPECT_FALSE(lazySub->getPub());
110 EXPECT_EQ(1, inPub.getNumSubscribers());
112 EXPECT_EQ(
true, lazySub->isSubscribed());
115 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
118 EXPECT_EQ(0, lazySub->numProcessed);
119 EXPECT_EQ(0, numOutReceived);
120 EXPECT_FALSE(lazySub->getPub());
121 EXPECT_EQ(1, inPub.getNumSubscribers());
124 EXPECT_EQ(
true, lazySub->isSubscribed());
126 inPub.publish(std_msgs::Header());
129 EXPECT_EQ(1, lazySub->numProcessed);
130 EXPECT_EQ(1, numOutReceived);
131 ASSERT_TRUE(lazySub->getPub());
132 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
133 EXPECT_EQ(1, inPub.getNumSubscribers());
136 EXPECT_EQ(
true, lazySub->isSubscribed());
140 EXPECT_EQ(1, lazySub->numProcessed);
141 EXPECT_EQ(1, numOutReceived);
142 ASSERT_TRUE(lazySub->getPub());
143 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
144 EXPECT_EQ(0, inPub.getNumSubscribers());
147 EXPECT_EQ(
false, lazySub->isSubscribed());
149 inPub.publish(std_msgs::Header());
152 EXPECT_EQ(1, lazySub->numProcessed);
153 EXPECT_EQ(1, numOutReceived);
154 ASSERT_TRUE(lazySub->getPub());
155 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
156 EXPECT_EQ(0, inPub.getNumSubscribers());
159 EXPECT_EQ(
false, lazySub->isSubscribed());
162 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
163 auto outSub2 = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
166 EXPECT_EQ(1, lazySub->numProcessed);
167 EXPECT_EQ(1, numOutReceived);
168 ASSERT_TRUE(lazySub->getPub());
169 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
170 EXPECT_EQ(1, inPub.getNumSubscribers());
173 EXPECT_EQ(
true, lazySub->isSubscribed());
177 lazySub->updateSubscription();
180 EXPECT_EQ(1, lazySub->numProcessed);
181 EXPECT_EQ(1, numOutReceived);
182 ASSERT_TRUE(lazySub->getPub());
183 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
184 EXPECT_EQ(1, inPub.getNumSubscribers());
187 EXPECT_EQ(
true, lazySub->isSubscribed());
189 inPub.publish(std_msgs::Header());
190 inPub.publish(std_msgs::Header());
193 EXPECT_EQ(3, lazySub->numProcessed);
194 EXPECT_EQ(5, numOutReceived);
195 ASSERT_TRUE(lazySub->getPub());
196 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
197 EXPECT_EQ(1, inPub.getNumSubscribers());
200 EXPECT_EQ(
true, lazySub->isSubscribed());
204 EXPECT_EQ(3, lazySub->numProcessed);
205 EXPECT_EQ(5, numOutReceived);
206 ASSERT_TRUE(lazySub->getPub());
207 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
208 EXPECT_EQ(0, inPub.getNumSubscribers());
211 EXPECT_EQ(
false, lazySub->isSubscribed());
213 inPub.publish(std_msgs::Header());
214 inPub.publish(std_msgs::Header());
215 inPub.publish(std_msgs::Header());
218 EXPECT_EQ(3, lazySub->numProcessed);
219 EXPECT_EQ(5, numOutReceived);
220 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
221 EXPECT_EQ(0, inPub.getNumSubscribers());
224 EXPECT_EQ(
false, lazySub->isSubscribed());
227 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
230 EXPECT_EQ(3, lazySub->numProcessed);
231 EXPECT_EQ(5, numOutReceived);
232 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
233 EXPECT_EQ(1, inPub.getNumSubscribers());
236 EXPECT_EQ(
true, lazySub->isSubscribed());
242 EXPECT_EQ(5, numOutReceived);
243 EXPECT_EQ(0, inPub.getNumSubscribers());
249 TEST(GenericLazyPubSub, StartSequenceNothing)
252 const auto ns = pnh.getNamespace();
253 size_t numOutReceived = 0;
257 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
262 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
265 EXPECT_EQ(0, lazySub->numProcessed);
266 EXPECT_FALSE(lazySub->getPub());
269 EXPECT_EQ(
true, lazySub->isSubscribed());
272 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
275 EXPECT_EQ(0, lazySub->numProcessed);
276 EXPECT_EQ(0, numOutReceived);
277 EXPECT_FALSE(lazySub->getPub());
278 EXPECT_EQ(1, inPub.getNumSubscribers());
281 EXPECT_EQ(
true, lazySub->isSubscribed());
283 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
286 EXPECT_EQ(0, lazySub->numProcessed);
287 EXPECT_EQ(0, numOutReceived);
288 EXPECT_FALSE(lazySub->getPub());
289 EXPECT_EQ(1, inPub.getNumSubscribers());
292 EXPECT_EQ(
true, lazySub->isSubscribed());
294 for (
size_t i = 0; i < 10; ++i)
295 inPub.publish(std_msgs::Header());
298 EXPECT_EQ(10, lazySub->numProcessed);
299 EXPECT_EQ(10, numOutReceived);
300 ASSERT_TRUE(lazySub->getPub());
301 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
302 EXPECT_EQ(1, inPub.getNumSubscribers());
305 EXPECT_EQ(
true, lazySub->isSubscribed());
309 EXPECT_EQ(10, lazySub->numProcessed);
310 EXPECT_EQ(10, numOutReceived);
311 ASSERT_TRUE(lazySub->getPub());
312 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
315 EXPECT_EQ(
false, lazySub->isSubscribed());
318 TEST(GenericLazyPubSub, StartSequenceIn)
321 const auto ns = pnh.getNamespace();
322 size_t numOutReceived = 0;
327 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
332 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
335 EXPECT_EQ(0, inPub.getNumSubscribers());
338 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
341 EXPECT_EQ(0, lazySub->numProcessed);
342 EXPECT_FALSE(lazySub->getPub());
343 EXPECT_EQ(1, inPub.getNumSubscribers());
346 EXPECT_EQ(
true, lazySub->isSubscribed());
349 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
352 EXPECT_EQ(0, lazySub->numProcessed);
353 EXPECT_EQ(0, numOutReceived);
354 EXPECT_FALSE(lazySub->getPub());
355 EXPECT_EQ(1, inPub.getNumSubscribers());
358 EXPECT_EQ(
true, lazySub->isSubscribed());
360 for (
size_t i = 0; i < 10; ++i)
361 inPub.publish(std_msgs::Header());
364 EXPECT_EQ(10, lazySub->numProcessed);
365 EXPECT_EQ(10, numOutReceived);
366 ASSERT_TRUE(lazySub->getPub());
367 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
368 EXPECT_EQ(1, inPub.getNumSubscribers());
371 EXPECT_EQ(
true, lazySub->isSubscribed());
375 EXPECT_EQ(10, lazySub->numProcessed);
376 EXPECT_EQ(10, numOutReceived);
377 ASSERT_TRUE(lazySub->getPub());
378 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
379 EXPECT_EQ(0, inPub.getNumSubscribers());
382 EXPECT_EQ(
false, lazySub->isSubscribed());
385 TEST(GenericLazyPubSub, StartSequenceOut)
388 const auto ns = pnh.getNamespace();
389 size_t numOutReceived = 0;
394 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
399 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
402 EXPECT_EQ(0, outSub.getNumPublishers());
406 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
409 EXPECT_EQ(0, lazySub->numProcessed);
410 EXPECT_FALSE(lazySub->getPub());
411 EXPECT_EQ(0, outSub.getNumPublishers());
414 EXPECT_EQ(
true, lazySub->isSubscribed());
417 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
420 EXPECT_EQ(0, lazySub->numProcessed);
421 EXPECT_EQ(0, numOutReceived);
422 EXPECT_FALSE(lazySub->getPub());
423 EXPECT_EQ(1, inPub.getNumSubscribers());
424 EXPECT_EQ(0, outSub.getNumPublishers());
427 EXPECT_EQ(
true, lazySub->isSubscribed());
429 for (
size_t i = 0; i < 10; ++i)
430 inPub.publish(std_msgs::Header());
433 EXPECT_EQ(10, lazySub->numProcessed);
434 EXPECT_EQ(10, numOutReceived);
435 ASSERT_TRUE(lazySub->getPub());
436 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
437 EXPECT_EQ(1, inPub.getNumSubscribers());
438 EXPECT_EQ(1, outSub.getNumPublishers());
441 EXPECT_EQ(
true, lazySub->isSubscribed());
445 EXPECT_EQ(10, lazySub->numProcessed);
446 EXPECT_EQ(10, numOutReceived);
447 ASSERT_TRUE(lazySub->getPub());
448 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
449 EXPECT_EQ(1, outSub.getNumPublishers());
452 EXPECT_EQ(
true, lazySub->isSubscribed());
455 TEST(GenericLazyPubSub, StartSequenceInOut)
458 const auto ns = pnh.getNamespace();
459 size_t numOutReceived = 0;
464 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
469 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
470 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
473 EXPECT_EQ(0, outSub.getNumPublishers());
477 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
480 EXPECT_EQ(0, lazySub->numProcessed);
481 EXPECT_EQ(0, numOutReceived);
482 EXPECT_FALSE(lazySub->getPub());
483 EXPECT_EQ(1, inPub.getNumSubscribers());
484 EXPECT_EQ(0, outSub.getNumPublishers());
487 EXPECT_EQ(
true, lazySub->isSubscribed());
489 for (
size_t i = 0; i < 10; ++i)
490 inPub.publish(std_msgs::Header());
493 EXPECT_EQ(10, lazySub->numProcessed);
494 EXPECT_EQ(10, numOutReceived);
495 ASSERT_TRUE(lazySub->getPub());
496 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
497 EXPECT_EQ(1, inPub.getNumSubscribers());
498 EXPECT_EQ(1, outSub.getNumPublishers());
501 EXPECT_EQ(
true, lazySub->isSubscribed());
504 TEST(GenericLazyPubSub, StartSequenceNoOut)
507 const auto ns = pnh.getNamespace();
512 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
518 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
521 EXPECT_EQ(0, lazySub->numProcessed);
522 EXPECT_FALSE(lazySub->getPub());
523 EXPECT_EQ(1, inPub.getNumSubscribers());
526 EXPECT_EQ(
true, lazySub->isSubscribed());
528 inPub.publish(std_msgs::Header());
531 EXPECT_EQ(1, lazySub->numProcessed);
532 ASSERT_TRUE(lazySub->getPub());
533 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
534 EXPECT_EQ(0, inPub.getNumSubscribers());
537 EXPECT_EQ(
false, lazySub->isSubscribed());
540 TEST(GenericLazyPubSub, QueueSize)
543 size_t numOutReceived = 0;
545 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
550 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
551 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
552 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh, 5, 3);
556 for (
size_t i = 0; i < 10; ++i)
557 inPub.publish(std_msgs::Header());
560 EXPECT_LE(5, lazySub->numProcessed);
561 EXPECT_GE(6, lazySub->numProcessed);
562 EXPECT_LE(5, numOutReceived);
563 EXPECT_GE(6, numOutReceived);
566 TEST(GenericLazyPubSub, MultiLatchedInputs)
569 size_t numOutReceived = 0;
571 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
578 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
579 auto lazySub = std::make_unique<TestLazyPubSub>(
"/latched",
"out", pnh);
583 EXPECT_EQ(5, lazySub->numProcessed);
584 EXPECT_EQ(5, numOutReceived);
598 auto opts = GenericLazyPubSub::createAdvertiseOptions(event);
599 opts.topic =
"topic_from_opts";
604 TEST(GenericLazyPubSub, OverrideAdvertiseOptions)
607 size_t numOutReceived = 0;
609 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
614 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
615 auto outSub = pnh.subscribe<std_msgs::Header>(
"topic_from_opts", 10, outCb);
616 auto lazySub = std::make_unique<TestAdvertiseOptions>(
"in",
"out", pnh);
620 for (
size_t i = 0; i < 10; ++i)
621 inPub.publish(std_msgs::Header());
624 EXPECT_EQ(10, lazySub->numProcessed);
625 EXPECT_EQ(10, numOutReceived);
626 EXPECT_FALSE(lazySub->getPub().isLatched());
629 TEST(GenericLazyPubSub, LatchIsRetained)
632 size_t numOutReceived = 0;
634 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
639 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10,
true);
640 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
641 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
645 for (
size_t i = 0; i < 10; ++i)
646 inPub.publish(std_msgs::Header());
649 EXPECT_EQ(10, lazySub->numProcessed);
650 EXPECT_EQ(10, numOutReceived);
651 EXPECT_TRUE(lazySub->getPub().isLatched());
654 TEST(GenericLazyPubSub, SetLazy)
657 const auto ns = pnh.getNamespace();
658 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
660 size_t numOutReceived = 0;
661 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
666 auto lazySub = std::make_unique<TestLazyPubSub>(
"in",
"out", pnh);
669 EXPECT_EQ(0, lazySub->numProcessed);
670 EXPECT_EQ(0, numOutReceived);
671 EXPECT_FALSE(lazySub->getPub());
672 EXPECT_EQ(1, inPub.getNumSubscribers());
675 EXPECT_EQ(
true, lazySub->isSubscribed());
676 EXPECT_EQ(
true, lazySub->isLazy());
678 lazySub->setLazy(
false);
681 EXPECT_EQ(0, lazySub->numProcessed);
682 EXPECT_EQ(0, numOutReceived);
683 EXPECT_FALSE(lazySub->getPub());
684 EXPECT_EQ(1, inPub.getNumSubscribers());
687 EXPECT_EQ(
true, lazySub->isSubscribed());
688 EXPECT_EQ(
false, lazySub->isLazy());
690 inPub.publish(std_msgs::Header());
693 EXPECT_EQ(1, lazySub->numProcessed);
694 EXPECT_EQ(0, numOutReceived);
695 ASSERT_TRUE(lazySub->getPub());
696 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
697 EXPECT_EQ(1, inPub.getNumSubscribers());
700 EXPECT_EQ(
true, lazySub->isSubscribed());
701 EXPECT_EQ(
false, lazySub->isLazy());
704 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
707 EXPECT_EQ(1, lazySub->numProcessed);
708 EXPECT_EQ(0, numOutReceived);
709 ASSERT_TRUE(lazySub->getPub());
710 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
711 EXPECT_EQ(1, inPub.getNumSubscribers());
714 EXPECT_EQ(
true, lazySub->isSubscribed());
715 EXPECT_EQ(
false, lazySub->isLazy());
717 inPub.publish(std_msgs::Header());
720 EXPECT_EQ(2, lazySub->numProcessed);
721 EXPECT_EQ(1, numOutReceived);
722 ASSERT_TRUE(lazySub->getPub());
723 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
724 EXPECT_EQ(1, inPub.getNumSubscribers());
727 EXPECT_EQ(
true, lazySub->isSubscribed());
728 EXPECT_EQ(
false, lazySub->isLazy());
732 EXPECT_EQ(2, lazySub->numProcessed);
733 EXPECT_EQ(1, numOutReceived);
734 ASSERT_TRUE(lazySub->getPub());
735 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
736 EXPECT_EQ(1, inPub.getNumSubscribers());
739 EXPECT_EQ(
true, lazySub->isSubscribed());
740 EXPECT_EQ(
false, lazySub->isLazy());
742 lazySub->setLazy(
true);
745 EXPECT_EQ(2, lazySub->numProcessed);
746 EXPECT_EQ(1, numOutReceived);
747 ASSERT_TRUE(lazySub->getPub());
748 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
749 EXPECT_EQ(0, inPub.getNumSubscribers());
752 EXPECT_EQ(
false, lazySub->isSubscribed());
753 EXPECT_EQ(
true, lazySub->isLazy());
756 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
759 EXPECT_EQ(2, lazySub->numProcessed);
760 EXPECT_EQ(1, numOutReceived);
761 ASSERT_TRUE(lazySub->getPub());
762 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
763 EXPECT_EQ(1, inPub.getNumSubscribers());
766 EXPECT_EQ(
true, lazySub->isSubscribed());
767 EXPECT_EQ(
true, lazySub->isLazy());
769 inPub.publish(std_msgs::Header());
772 EXPECT_EQ(3, lazySub->numProcessed);
773 EXPECT_EQ(2, numOutReceived);
774 ASSERT_TRUE(lazySub->getPub());
775 EXPECT_EQ(1, lazySub->getPub().getNumSubscribers());
776 EXPECT_EQ(1, inPub.getNumSubscribers());
779 EXPECT_EQ(
true, lazySub->isSubscribed());
780 EXPECT_EQ(
true, lazySub->isLazy());
784 EXPECT_EQ(3, lazySub->numProcessed);
785 EXPECT_EQ(2, numOutReceived);
786 ASSERT_TRUE(lazySub->getPub());
787 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
788 EXPECT_EQ(0, inPub.getNumSubscribers());
791 EXPECT_EQ(
false, lazySub->isSubscribed());
792 EXPECT_EQ(
true, lazySub->isLazy());
794 lazySub->setLazy(
false);
797 EXPECT_EQ(3, lazySub->numProcessed);
798 EXPECT_EQ(2, numOutReceived);
799 ASSERT_TRUE(lazySub->getPub());
800 EXPECT_EQ(0, lazySub->getPub().getNumSubscribers());
801 EXPECT_EQ(1, inPub.getNumSubscribers());
804 EXPECT_EQ(
true, lazySub->isSubscribed());
805 EXPECT_EQ(
false, lazySub->isLazy());
811 const auto ns = pnh.getNamespace();
812 auto inPub = pnh.advertise<std_msgs::Header>(
"in", 10);
814 size_t numOutReceived = 0;
815 boost::function<void(
const std_msgs::Header&)> outCb = [&](
const std_msgs::Header& h)
827 EXPECT_EQ(0, numOutReceived);
828 EXPECT_EQ(1, inPub.getNumSubscribers());
829 EXPECT_FALSE(lazySub1.
getPub());
830 EXPECT_FALSE(lazySub2.
getPub());
831 EXPECT_FALSE(lazySub3.
getPub());
841 auto outSub = pnh.subscribe<std_msgs::Header>(
"out", 10, outCb);
847 EXPECT_EQ(0, numOutReceived);
848 EXPECT_EQ(1, inPub.getNumSubscribers());
849 EXPECT_FALSE(lazySub1.
getPub());
850 EXPECT_FALSE(lazySub2.
getPub());
851 EXPECT_FALSE(lazySub3.
getPub());
860 inPub.publish(std_msgs::Header());
866 EXPECT_EQ(1, numOutReceived);
867 EXPECT_EQ(1, inPub.getNumSubscribers());
868 ASSERT_TRUE(lazySub1.
getPub());
870 ASSERT_TRUE(lazySub2.
getPub());
872 ASSERT_TRUE(lazySub3.
getPub());
882 inPub.publish(std_msgs::Header());
888 EXPECT_EQ(2, numOutReceived);
889 EXPECT_EQ(1, inPub.getNumSubscribers());
890 ASSERT_TRUE(lazySub1.
getPub());
892 ASSERT_TRUE(lazySub2.
getPub());
894 ASSERT_TRUE(lazySub3.
getPub());
909 EXPECT_EQ(2, numOutReceived);
910 EXPECT_EQ(0, inPub.getNumSubscribers());
911 ASSERT_TRUE(lazySub1.
getPub());
913 ASSERT_TRUE(lazySub2.
getPub());
915 ASSERT_TRUE(lazySub3.
getPub());
925 inPub.publish(std_msgs::Header());
931 EXPECT_EQ(2, numOutReceived);
932 EXPECT_EQ(0, inPub.getNumSubscribers());
933 ASSERT_TRUE(lazySub1.
getPub());
935 ASSERT_TRUE(lazySub2.
getPub());
937 ASSERT_TRUE(lazySub3.
getPub());
948 int main(
int argc,
char **argv)
950 testing::InitGoogleTest(&argc, argv);
951 ros::init(argc, argv,
"test_generic_lazy_pubsub");
956 return RUN_ALL_TESTS();