ChimeraTK-ApplicationCore 04.08.00
Loading...
Searching...
No Matches
testTestFacilities.cc
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
2// SPDX-License-Identifier: LGPL-3.0-or-later
3
4#define BOOST_TEST_MODULE testTestFacilities
5
6#include "Application.h"
7#include "ApplicationModule.h"
8#include "check_timeout.h"
9#include "DeviceModule.h"
10#include "ScalarAccessor.h"
11#include "TestableMode.h"
12#include "TestFacility.h"
13#include "VariableGroup.h"
14
15#include <ChimeraTK/Device.h>
16
17#include <boost/mpl/list.hpp>
18#include <boost/thread/barrier.hpp>
19
20#include <latch>
21
22// #define BOOST_NO_EXCEPTIONS
23#include <boost/test/included/unit_test.hpp>
24// #undef BOOST_NO_EXCEPTIONS
25
26namespace Tests::testTestFacilities {
27
28 using namespace boost::unit_test_framework;
29 namespace ctk = ChimeraTK;
30
31 constexpr std::string_view dummySdm{"(dummy?map=test_readonly.map)"};
32
33 /********************************************************************************************************************/
34 /* the BlockingReadTestModule blockingly reads its input in the main loop and writes the result to its output */
35
36 struct BlockingReadTestModule : public ctk::ApplicationModule {
37 using ctk::ApplicationModule::ApplicationModule;
38
39 ctk::ScalarPushInput<int32_t> someInput{this, "/value", "cm", "This is just some input for testing"};
40 ctk::ScalarOutput<int32_t> someOutput{this, "someOutput", "cm", "Description"};
41
42 void mainLoop() override {
43 while(true) {
44 int32_t val = someInput;
45 someOutput = val;
46 usleep(10000); // wait some extra time to make sure we are really blocking
47 // the test procedure thread
48 someOutput.write();
49 someInput.read(); // read at the end to propagate the initial value
50 }
51 }
52 };
53
54 /********************************************************************************************************************/
55 /* the ReadAnyTestModule calls readAny on a bunch of inputs and outputs some information on the received data */
56
57 struct ReadAnyTestModule : public ctk::ApplicationModule {
58 using ctk::ApplicationModule::ApplicationModule;
59
60 struct Inputs : public ctk::VariableGroup {
61 using ctk::VariableGroup::VariableGroup;
62 ctk::ScalarPushInput<int32_t> v1{this, "v1", "cm", "Input 1 for testing"};
63 ctk::ScalarPushInput<int32_t> v2{this, "/REG2", "cm", "Input 2 for testing"};
64 ctk::ScalarPushInput<int32_t> v3{this, "v3", "cm", "Input 3 for testing"};
65 ctk::ScalarPushInput<int32_t> v4{this, "v4", "cm", "Input 4 for testing"};
66 };
67 Inputs inputs{this, "inputs", "A group of inputs"};
68 ctk::ScalarOutput<int32_t> value{this, "/value", "cm", "The last value received from any of the inputs"};
69 ctk::ScalarOutput<uint32_t> index{
70 this, "index", "", "The index (1..4) of the input where the last value was received"};
71
72 void prepare() override {
73 incrementDataFaultCounter(); // force all outputs to invalid
74 writeAll();
75 decrementDataFaultCounter(); // validity according to input validity
76 }
77
78 void mainLoop() override {
79 auto group = inputs.readAnyGroup();
80 while(true) {
81 auto justRead = group.readAny();
82 if(inputs.v1.getId() == justRead) {
83 index = 1;
84 value = int32_t(inputs.v1);
85 }
86 else if(inputs.v2.getId() == justRead) {
87 index = 2;
88 value = int32_t(inputs.v2);
89 }
90 else if(inputs.v3.getId() == justRead) {
91 index = 3;
92 value = int32_t(inputs.v3);
93 }
94 else if(inputs.v4.getId() == justRead) {
95 index = 4;
96 value = int32_t(inputs.v4);
97 }
98 else {
99 index = 0;
100 value = 0;
101 }
102 usleep(10000); // wait some extra time to make sure we are really blocking
103 // the test procedure thread
104 index.write();
105 value.write();
106 }
107 }
108 };
109
110 /********************************************************************************************************************/
111 /* the PollingReadModule is designed to test poll-type transfers (even mixed with push-type) */
112
113 struct PollingReadModule : public ctk::ApplicationModule {
114 using ctk::ApplicationModule::ApplicationModule;
115
116 ctk::ScalarPushInput<int32_t> push{this, "push", "cm", "A push-type input"};
117 ctk::ScalarPushInput<int32_t> push2{this, "push2", "cm", "A second push-type input"};
118 ctk::ScalarPollInput<int32_t> poll{this, "poll", "cm", "A poll-type input"};
119
120 ctk::ScalarOutput<int32_t> valuePush{this, "valuePush", "cm", "The last value received for 'push'"};
121 ctk::ScalarOutput<int32_t> valuePoll{this, "valuePoll", "cm", "The last value received for 'poll'"};
122 ctk::ScalarOutput<int32_t> state{this, "state", "", "State of the test mainLoop"};
123
124 void prepare() override {
125 incrementDataFaultCounter(); // foce all outputs to invalid
126 writeAll();
127 decrementDataFaultCounter(); // validity according to input validity
128 }
129
130 void mainLoop() override {
131 while(true) {
132 push.read();
133 poll.read();
134 valuePush = int32_t(push);
135 valuePoll = int32_t(poll);
136 valuePoll.write();
137 valuePush.write();
138 state = 1;
139 state.write();
140
141 push2.read();
142 push.readNonBlocking();
143 poll.read();
144 valuePush = int32_t(push);
145 valuePoll = int32_t(poll);
146 valuePoll.write();
147 valuePush.write();
148 state = 2;
149 state.write();
150
151 push2.read();
152 push.readLatest();
153 poll.read();
154 valuePush = int32_t(push);
155 valuePoll = int32_t(poll);
156 valuePoll.write();
157 valuePush.write();
158 state = 3;
159 state.write();
160 }
161 }
162 };
163
164 /********************************************************************************************************************/
165 /* the PollingThroughFanoutsModule is designed to test poll-type transfers in combination with FanOuts */
166
167 struct PollingThroughFanoutsModule : ctk::ApplicationModule {
168 using ctk::ApplicationModule::ApplicationModule;
169 ctk::ScalarPushInput<int> push1{this, "push1", "", ""};
170 ctk::ScalarPollInput<int> poll1{this, "poll1", "", ""};
171 ctk::ScalarPollInput<int> poll2{this, "poll2", "", ""};
172 ctk::ScalarOutput<int> out1{this, "out1", "", ""};
173 ctk::ScalarOutput<int> out2{this, "out2", "", ""};
174
175 std::mutex mForChecking;
176 bool hasRead{false};
177
178 void prepare() override { writeAll(); }
179
180 void run() override { ApplicationModule::run(); }
181
182 void mainLoop() override {
183 while(true) {
184 push1.read();
185
186 std::unique_lock<std::mutex> lock(mForChecking);
187 hasRead = true;
188 poll1.read();
189 poll2.read();
190 usleep(1000); // give try_lock() in tests a chance to fail if testable mode lock would not work
191 }
192 }
193 };
194
195 /********************************************************************************************************************/
196 /* test that no TestableModeAccessorDecorator is used if the testable mode is not enabled */
197
198 struct TestNoDecoratorApplication : public ctk::Application {
199 TestNoDecoratorApplication() : Application("testApplication") {}
200 ~TestNoDecoratorApplication() override { shutdown(); }
201
202 BlockingReadTestModule blockingReadTestModule{this, "blockingReadTestModule", "Module for testing blocking read"};
203 ReadAnyTestModule readAnyTestModule{this, "readAnyTestModule", "Module for testing readAny()"};
204 };
205
206 BOOST_AUTO_TEST_CASE(testNoDecorator) {
207 std::cout << "***************************************************************"
208 "******************************************************"
209 << std::endl;
210 std::cout << "==> testNoDecorator" << std::endl;
211
212 TestNoDecoratorApplication app;
213
214 auto pvManagers = ctk::createPVManager();
215 app.setPVManager(pvManagers.second);
216
217 app.initialise();
218 app.run();
219
220 // check if we got the decorator for the input
221 auto hlinput = app.blockingReadTestModule.someInput.getHighLevelImplElement();
222 BOOST_CHECK(boost::dynamic_pointer_cast<ctk::detail::TestableMode::AccessorDecorator<int32_t>>(hlinput) == nullptr);
223
224 // check that we did not get the decorator for the output
225 auto hloutput = app.blockingReadTestModule.someOutput.getHighLevelImplElement();
226 BOOST_CHECK(
227 boost::dynamic_pointer_cast<ctk::detail::TestableMode::AccessorDecorator<int32_t>>(hloutput) == nullptr);
228 }
229
230 /********************************************************************************************************************/
231 /* test blocking read in test mode */
232
233 struct TestBlockingReadApplication : public ctk::Application {
234 TestBlockingReadApplication() : Application("testApplication") {}
235 ~TestBlockingReadApplication() override { shutdown(); }
236
237 BlockingReadTestModule blockingReadTestModule{this, "blockingReadTestModule", "Module for testing blocking read"};
238 };
239
240 BOOST_AUTO_TEST_CASE(testBlockingRead) {
241 std::cout << "***************************************************************"
242 "******************************************************"
243 << std::endl;
244 std::cout << "==> testBlockingRead" << std::endl;
245
246 TestBlockingReadApplication app;
247
248 ctk::TestFacility test{app};
249 auto pvInput = test.getScalar<int32_t>("/value");
250 auto pvOutput = test.getScalar<int32_t>("/blockingReadTestModule/someOutput");
251 test.runApplication();
252
253 // test blocking read when taking control in the test thread (note: the
254 // blocking read is executed in the app module!)
255 for(int i = 0; i < 5; ++i) {
256 pvInput = 120 + i;
257 pvInput.write();
258 usleep(10000);
259 BOOST_CHECK(pvOutput.readNonBlocking() == false);
260 test.stepApplication();
261 CHECK_TIMEOUT(pvOutput.readNonBlocking() == true, 10000);
262 int val = pvOutput;
263 BOOST_CHECK(val == 120 + i);
264 }
265 }
266
267 /********************************************************************************************************************/
268 /* test testReadAny in test mode */
269
270 struct TestReadAnyApplication : public ctk::Application {
271 TestReadAnyApplication() : Application("testApplication") {}
272 ~TestReadAnyApplication() override { shutdown(); }
273
274 ReadAnyTestModule readAnyTestModule{this, "readAnyTestModule", "Module for testing readAny()"};
275 };
276
277 BOOST_AUTO_TEST_CASE(testReadAny) {
278 std::cout << "***************************************************************"
279 "******************************************************"
280 << std::endl;
281 std::cout << "==> testReadAny" << std::endl;
282
283 TestReadAnyApplication app;
284
285 ctk::TestFacility test{app};
286 auto value = test.getScalar<int32_t>("/value");
287 auto index = test.getScalar<uint32_t>("/readAnyTestModule/index");
288 auto v1 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v1");
289 auto v2 = test.getScalar<int32_t>("/REG2"); // just named irregularly, no device present!
290 auto v3 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v3");
291 auto v4 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v4");
292 test.runApplication();
293 // check that we don't receive anything yet
294 usleep(10000);
295 BOOST_CHECK(value.readNonBlocking() == false);
296 BOOST_CHECK(index.readNonBlocking() == false);
297
298 // send something to v4
299 v4 = 66;
300 v4.write();
301
302 // check that we still don't receive anything yet
303 usleep(10000);
304 BOOST_CHECK(value.readNonBlocking() == false);
305 BOOST_CHECK(index.readNonBlocking() == false);
306
307 // run the application and check that we got the expected result
308 test.stepApplication();
309 BOOST_CHECK(value.readNonBlocking() == true);
310 BOOST_CHECK(index.readNonBlocking() == true);
311 BOOST_CHECK_EQUAL(value, 66);
312 BOOST_CHECK_EQUAL(index, 4);
313
314 // send something to v1
315 v1 = 33;
316 v1.write();
317
318 // check that we still don't receive anything yet
319 usleep(10000);
320 BOOST_CHECK(value.readNonBlocking() == false);
321 BOOST_CHECK(index.readNonBlocking() == false);
322
323 // run the application and check that we got the expected result
324 test.stepApplication();
325 BOOST_CHECK(value.readNonBlocking() == true);
326 BOOST_CHECK(index.readNonBlocking() == true);
327 BOOST_CHECK_EQUAL(value, 33);
328 BOOST_CHECK_EQUAL(index, 1);
329
330 // send something to v1 again
331 v1 = 34;
332 v1.write();
333
334 // check that we still don't receive anything yet
335 usleep(10000);
336 BOOST_CHECK(value.readNonBlocking() == false);
337 BOOST_CHECK(index.readNonBlocking() == false);
338
339 // run the application and check that we got the expected result
340 test.stepApplication();
341
342 BOOST_CHECK(value.readNonBlocking() == true);
343 BOOST_CHECK(index.readNonBlocking() == true);
344 BOOST_CHECK_EQUAL(value, 34);
345 BOOST_CHECK_EQUAL(index, 1);
346
347 // send something to v3
348 v3 = 40;
349 v3.write();
350
351 // check that we still don't receive anything yet
352 usleep(10000);
353 BOOST_CHECK(value.readNonBlocking() == false);
354 BOOST_CHECK(index.readNonBlocking() == false);
355
356 // run the application and check that we got the expected result
357 test.stepApplication();
358 BOOST_CHECK(value.readNonBlocking() == true);
359 BOOST_CHECK(index.readNonBlocking() == true);
360 BOOST_CHECK_EQUAL(value, 40);
361 BOOST_CHECK_EQUAL(index, 3);
362
363 // send something to v2
364 v2 = 50;
365 v2.write();
366
367 // check that we still don't receive anything yet
368 usleep(10000);
369 BOOST_CHECK(value.readNonBlocking() == false);
370 BOOST_CHECK(index.readNonBlocking() == false);
371
372 // run the application and check that we got the expected result
373 test.stepApplication();
374 BOOST_CHECK(value.readNonBlocking() == true);
375 BOOST_CHECK(index.readNonBlocking() == true);
376 BOOST_CHECK_EQUAL(value, 50);
377 BOOST_CHECK_EQUAL(index, 2);
378
379 // check that stepApplication() throws an exception if no input data is
380 // available
381 try {
382 test.stepApplication();
383 BOOST_ERROR("IllegalParameter exception expected.");
384 }
385 catch(ChimeraTK::logic_error&) {
386 }
387
388 // check that we still don't receive anything anymore
389 usleep(10000);
390 BOOST_CHECK(value.readNonBlocking() == false);
391 BOOST_CHECK(index.readNonBlocking() == false);
392
393 // send something to v1 a 3rd time
394 v1 = 35;
395 v1.write();
396
397 // check that we still don't receive anything yet
398 usleep(10000);
399 BOOST_CHECK(value.readNonBlocking() == false);
400 BOOST_CHECK(index.readNonBlocking() == false);
401
402 // run the application and check that we got the expected result
403 test.stepApplication();
404 BOOST_CHECK(value.readNonBlocking() == true);
405 BOOST_CHECK(index.readNonBlocking() == true);
406 BOOST_CHECK_EQUAL(value, 35);
407 BOOST_CHECK_EQUAL(index, 1);
408 }
409
410 /********************************************************************************************************************/
411 /* test the interplay of multiple chained modules and their threads in test mode
412 */
413
414 struct TestChaniedModulesApplication : public ctk::Application {
415 TestChaniedModulesApplication() : Application("testApplication") {}
416 ~TestChaniedModulesApplication() override { shutdown(); }
417
418 BlockingReadTestModule blockingReadTestModule{this, "blockingReadTestModule", "Module for testing blocking read"};
419 ReadAnyTestModule readAnyTestModule{this, "readAnyTestModule", "Module for testing readAny()"};
420 };
421
422 BOOST_AUTO_TEST_CASE(testChainedModules) {
423 std::cout << "***************************************************************"
424 "******************************************************"
425 << std::endl;
426 std::cout << "==> testChainedModules" << std::endl;
427
428 TestChaniedModulesApplication app;
429
430 ctk::TestFacility test{app};
431 auto value = test.getScalar<int32_t>("/blockingReadTestModule/someOutput");
432 auto index = test.getScalar<uint32_t>("/readAnyTestModule/index");
433 auto v1 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v1");
434 auto v2 = test.getScalar<int32_t>("/REG2"); // just named irregularly, no device present!
435 auto v3 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v3");
436 auto v4 = test.getScalar<int32_t>("/readAnyTestModule/inputs/v4");
437 test.runApplication();
438
439 // check that we don't receive anything yet
440 usleep(10000);
441 BOOST_CHECK(value.readNonBlocking() == false);
442 BOOST_CHECK(index.readNonBlocking() == false);
443
444 // send something to v2
445 v2 = 11;
446 v2.write();
447
448 // check that we still don't receive anything yet
449 usleep(10000);
450 BOOST_CHECK(value.readNonBlocking() == false);
451 BOOST_CHECK(index.readNonBlocking() == false);
452
453 // run the application and check that we got the expected result
454 test.stepApplication();
455 BOOST_CHECK(value.readNonBlocking() == true);
456 BOOST_CHECK(index.readNonBlocking() == true);
457 BOOST_CHECK(value == 11);
458 BOOST_CHECK(index == 2);
459
460 // send something to v3
461 v3 = 12;
462 v3.write();
463
464 // check that we still don't receive anything yet
465 usleep(10000);
466 BOOST_CHECK(value.readNonBlocking() == false);
467 BOOST_CHECK(index.readNonBlocking() == false);
468
469 // run the application and check that we got the expected result
470 test.stepApplication();
471 BOOST_CHECK(value.readNonBlocking() == true);
472 BOOST_CHECK(index.readNonBlocking() == true);
473 BOOST_CHECK(value == 12);
474 BOOST_CHECK(index == 3);
475
476 // send something to v3 again
477 v3 = 13;
478 v3.write();
479
480 // check that we still don't receive anything yet
481 usleep(10000);
482 BOOST_CHECK(value.readNonBlocking() == false);
483 BOOST_CHECK(index.readNonBlocking() == false);
484
485 // run the application and check that we got the expected result
486 test.stepApplication();
487 BOOST_CHECK(value.readNonBlocking() == true);
488 BOOST_CHECK(index.readNonBlocking() == true);
489 BOOST_CHECK(value == 13);
490 BOOST_CHECK(index == 3);
491
492 // check that stepApplication() throws an exception if no input data is
493 // available
494 try {
495 test.stepApplication();
496 BOOST_ERROR("IllegalParameter exception expected.");
497 }
498 catch(ChimeraTK::logic_error&) {
499 }
500
501 // check that we still don't receive anything anymore
502 usleep(10000);
503 BOOST_CHECK(value.readNonBlocking() == false);
504 BOOST_CHECK(index.readNonBlocking() == false);
505 }
506
507 /********************************************************************************************************************/
508 /* test combination with trigger */
509
510 struct TestWithTriggerApplication : public ctk::Application {
511 TestWithTriggerApplication() : Application("testApplication") {}
512 ~TestWithTriggerApplication() override { shutdown(); }
513
514 ctk::DeviceModule dev{this, dummySdm.data(), "/trigger"};
515 BlockingReadTestModule blockingReadTestModule{this, "blockingReadTestModule", "Module for testing blocking read"};
516 ReadAnyTestModule readAnyTestModule{this, "readAnyTestModule", "Module for testing readAny()"};
517 };
518
519 BOOST_AUTO_TEST_CASE(testWithTrigger) {
520 std::cout << "***************************************************************"
521 "******************************************************"
522 << std::endl;
523 std::cout << "==> testWithTrigger" << std::endl;
524
525 TestWithTriggerApplication app;
526
527 ctk::TestFacility test{app};
528 ctk::Device dev;
529 dev.open(dummySdm.data());
530 auto valueFromBlocking = test.getScalar<int32_t>("/blockingReadTestModule/someOutput");
531 auto index = test.getScalar<uint32_t>("/readAnyTestModule/index");
532 auto trigger = test.getVoid("/trigger");
533 auto v2 = dev.getScalarRegisterAccessor<int32_t>("/REG2.DUMMY_WRITEABLE");
534 test.runApplication();
535
536 // check that we don't receive anything yet
537 usleep(10000);
538 BOOST_CHECK(valueFromBlocking.readNonBlocking() == false);
539 BOOST_CHECK(index.readNonBlocking() == false);
540
541 // send something to v2 and send the trigger
542 v2 = 11;
543 v2.write();
544 trigger.write();
545
546 // check that we still don't receive anything yet
547 usleep(10000);
548 BOOST_CHECK(valueFromBlocking.readNonBlocking() == false);
549 BOOST_CHECK(index.readNonBlocking() == false);
550
551 // run the application and check that we got the expected result
552 test.stepApplication();
553 BOOST_CHECK(valueFromBlocking.readNonBlocking() == true);
554 BOOST_CHECK(index.readNonBlocking() == true);
555 BOOST_CHECK(valueFromBlocking == 11);
556 BOOST_CHECK(index == 2);
557
558 // again send something to v2 and send the trigger
559 v2 = 22;
560 v2.write();
561 trigger.write();
562
563 // check that we still don't receive anything yet
564 usleep(10000);
565 BOOST_CHECK(valueFromBlocking.readNonBlocking() == false);
566 BOOST_CHECK(index.readNonBlocking() == false);
567
568 // run the application and check that we got the expected result
569 test.stepApplication();
570 BOOST_CHECK(valueFromBlocking.readNonBlocking() == true);
571 BOOST_CHECK(index.readNonBlocking() == true);
572 BOOST_CHECK(valueFromBlocking == 22);
573 BOOST_CHECK(index == 2);
574
575 // check that stepApplication() throws an exception if no input data is
576 // available
577 try {
578 test.stepApplication();
579 BOOST_ERROR("IllegalParameter exception expected.");
580 }
581 catch(ChimeraTK::logic_error&) {
582 }
583
584 // check that we still don't receive anything anymore
585 usleep(10000);
586 BOOST_CHECK(valueFromBlocking.readNonBlocking() == false);
587 // BOOST_CHECK(valueFromAsync.readNonBlocking() == false);
588 BOOST_CHECK(index.readNonBlocking() == false);
589 }
590
591 /********************************************************************************************************************/
592 /* test convenience read functions */
593
594 struct TestConvenienceReadApplication : public ctk::Application {
595 TestConvenienceReadApplication() : Application("testApplication") {}
596 ~TestConvenienceReadApplication() override { shutdown(); }
597
598 BlockingReadTestModule blockingReadTestModule{this, "blockingReadTestModule", "Module for testing blocking read"};
599 };
600
601 BOOST_AUTO_TEST_CASE(testConvenienceRead) {
602 std::cout << "***************************************************************"
603 "******************************************************"
604 << std::endl;
605 std::cout << "==> testConvenienceRead" << std::endl;
606
607 TestConvenienceReadApplication app;
608
609 ctk::TestFacility test{app};
610 test.runApplication();
611
612 // test blocking read when taking control in the test thread (note: the blocking read is executed in the app module!)
613 for(int i = 0; i < 5; ++i) {
614 test.writeScalar<int32_t>("/value", 120 + i);
615 test.stepApplication();
616 CHECK_TIMEOUT(test.readScalar<int32_t>("/blockingReadTestModule/someOutput") == 120 + i, 10000);
617 }
618
619 // same with array function (still a scalar variable behind, but this does not matter)
620 for(int i = 0; i < 5; ++i) {
621 std::vector<int32_t> myValue{120 + i};
622 test.writeArray<int32_t>("/value", myValue);
623 test.stepApplication();
624 CHECK_TIMEOUT(
625 test.readArray<int32_t>("/blockingReadTestModule/someOutput") == std::vector<int32_t>{120 + i}, 10000);
626 }
627 }
628
629 /********************************************************************************************************************/
630 /* test poll-type transfers mixed with push-type */
631
632 struct TestPollingApplication : public ctk::Application {
633 TestPollingApplication() : Application("testApplication") {}
634 ~TestPollingApplication() override { shutdown(); }
635
636 PollingReadModule pollingReadModule{this, "pollingReadModule", "Module for testing poll-type transfers"};
637 };
638
639 BOOST_AUTO_TEST_CASE(testPolling) {
640 std::cout << "***************************************************************"
641 "******************************************************"
642 << std::endl;
643 std::cout << "==> testPolling" << std::endl;
644
645 TestPollingApplication app; // app.pollingReadModule.connectTo(app.cs);
646
647 ctk::TestFacility test{app};
648 test.runApplication();
649
650 auto pv_push = test.getScalar<int32_t>("/pollingReadModule/push");
651 auto pv_push2 = test.getScalar<int32_t>("/pollingReadModule/push2");
652 auto pv_poll = test.getScalar<int32_t>("/pollingReadModule/poll");
653 auto pv_valuePush = test.getScalar<int32_t>("/pollingReadModule/valuePush");
654 auto pv_valuePoll = test.getScalar<int32_t>("/pollingReadModule/valuePoll");
655 auto pv_state = test.getScalar<int>("/pollingReadModule/state");
656
657 // write values to 'push' and 'poll' and check result
658 pv_push = 120;
659 pv_push.write();
660 pv_poll = 42;
661 pv_poll.write();
662 test.stepApplication();
663 pv_valuePoll.read();
664 pv_valuePush.read();
665 pv_state.read();
666 BOOST_CHECK_EQUAL((int32_t)pv_valuePoll, 42);
667 BOOST_CHECK_EQUAL((int32_t)pv_valuePush, 120);
668 BOOST_CHECK_EQUAL((int32_t)pv_state, 1);
669
670 // this time the application gets triggered by push2, push is read
671 // non-blockingly (single value only)
672 pv_push = 22;
673 pv_push.write();
674 pv_poll = 44;
675 pv_poll.write();
676 pv_poll = 45;
677 pv_poll.write();
678 pv_push2.write();
679 test.stepApplication();
680 pv_valuePoll.read();
681 pv_valuePush.read();
682 pv_state.read();
683 BOOST_CHECK_EQUAL((int32_t)pv_valuePoll, 45);
684 BOOST_CHECK_EQUAL((int32_t)pv_valuePush, 22);
685 BOOST_CHECK_EQUAL((int32_t)pv_state, 2);
686
687 // this time the application gets triggered by push2, push is read with
688 // readLatest()
689 pv_push = 24;
690 pv_push.write();
691 pv_poll = 46;
692 pv_poll.write();
693 pv_push2.write();
694 test.stepApplication();
695 pv_valuePoll.read();
696 pv_valuePush.read();
697 pv_state.read();
698 BOOST_CHECK_EQUAL((int32_t)pv_valuePoll, 46);
699 BOOST_CHECK_EQUAL((int32_t)pv_valuePush, 24);
700 BOOST_CHECK_EQUAL((int32_t)pv_state, 3);
701
702 // provoke internal queue overflow in poll-type variable (should not make any difference)
703 pv_push = 25;
704 pv_push.write();
705 for(int i = 0; i < 10; ++i) {
706 pv_poll = 50 + i;
707 }
708 pv_poll.write();
709 pv_push2.write();
710 test.stepApplication();
711 pv_valuePoll.read();
712 pv_valuePush.read();
713 pv_state.read();
714 BOOST_CHECK_EQUAL((int32_t)pv_valuePoll, 59);
715 BOOST_CHECK_EQUAL((int32_t)pv_valuePush, 25);
716 BOOST_CHECK_EQUAL((int32_t)pv_state, 1);
717 }
718
719 /********************************************************************************************************************/
720 /* test poll-type transfers in combination with various FanOuts */
721
722 struct TestPollingThroughFanOutsApplication : public ctk::Application {
723 TestPollingThroughFanOutsApplication() : Application("AnotherTestApplication") {}
724 ~TestPollingThroughFanOutsApplication() override { shutdown(); }
725
726 ctk::DeviceModule dev{this, dummySdm.data(), "/fakeTriggerToSatisfyUnusedRegister"};
727 PollingThroughFanoutsModule m1{this, "m1", ""};
728 PollingThroughFanoutsModule m2{this, "m2", ""};
729 };
730
731 BOOST_AUTO_TEST_CASE(testPollingThroughFanOuts) {
732 std::cout << "***************************************************************"
733 "******************************************************"
734 << std::endl;
735 std::cout << "==> testPollingThroughFanOuts" << std::endl;
736
737 // Case 1: FeedingFanOut
738 // ---------------------
739 {
740 TestPollingThroughFanOutsApplication app;
741
742 app.m2.poll1 = {&app.m2, "/m1/out1", "", ""};
743 app.m2.poll2 = {&app.m2, "/m1/out1", "", ""};
744 app.m2.push1 = {&app.m2, "/m1/out2", "", ""};
745
746 std::unique_lock<std::mutex> lk1(app.m1.mForChecking, std::defer_lock);
747 std::unique_lock<std::mutex> lk2(app.m2.mForChecking, std::defer_lock);
748
749 ctk::TestFacility test{app};
750
751 test.runApplication();
752
753 // test single value
754 BOOST_REQUIRE(lk1.try_lock());
755 app.m1.out1 = 123;
756 app.m1.out1.write();
757 app.m1.out2.write();
758 lk1.unlock();
759
760 test.stepApplication();
761
762 BOOST_REQUIRE(lk2.try_lock());
763 BOOST_CHECK_EQUAL(app.m2.poll1, 123);
764 BOOST_CHECK_EQUAL(app.m2.poll2, 123);
765 lk2.unlock();
766
767 // test queue overrun
768 BOOST_REQUIRE(lk1.try_lock());
769 for(int i = 0; i < 10; ++i) {
770 app.m1.out1 = 191 + i;
771 app.m1.out1.write();
772 app.m1.out2.write();
773 }
774 lk1.unlock();
775
776 test.stepApplication();
777
778 BOOST_REQUIRE(lk2.try_lock());
779 BOOST_CHECK_EQUAL(app.m2.poll1, 200);
780 BOOST_CHECK_EQUAL(app.m2.poll2, 200);
781 lk2.unlock();
782 }
783
784 // Case 2: ConsumingFanOut
785 // -----------------------
786 {
787 TestPollingThroughFanOutsApplication app;
788 app.m1.poll1 = {&app.m1, "/REG1", "", ""};
789 app.m2.push1 = {&app.m2, "/REG1", "", ""};
790 // app.dev("REG1") >> app.m1.poll1 >> app.m2.push1;
791
792 std::unique_lock<std::mutex> lk1(app.m1.mForChecking, std::defer_lock);
793 std::unique_lock<std::mutex> lk2(app.m2.mForChecking, std::defer_lock);
794
795 ctk::Device dev(dummySdm.data());
796 auto reg1 = dev.getScalarRegisterAccessor<int>("REG1.DUMMY_WRITEABLE");
797
798 ctk::TestFacility test{app};
799 test.runApplication();
800
801 reg1 = 42;
802 reg1.write();
803
804 BOOST_REQUIRE(lk1.try_lock());
805 app.m1.poll1.read();
806 BOOST_CHECK_EQUAL(app.m1.poll1, 42);
807 lk1.unlock();
808 BOOST_REQUIRE(lk2.try_lock());
809 BOOST_CHECK_NE(app.m2.push1, 42);
810 lk2.unlock();
811
812 test.stepApplication();
813
814 BOOST_REQUIRE(lk2.try_lock());
815 BOOST_CHECK_EQUAL(app.m2.push1, 42);
816 lk2.unlock();
817 }
818
819 // Case 3: ThreadedFanOut
820 // ----------------------
821 {
822 std::cout << "=== Case 3" << std::endl;
823 TestPollingThroughFanOutsApplication app;
824 std::cout << " HIER 1" << std::endl;
825 app.m1.poll2 = {&app.m1, "poll1", "", ""};
826 std::cout << " HIER 2" << std::endl;
827 app.m1.push1 = {&app.m1, "/m2/out2", "", ""};
828 std::cout << " HIER 3" << std::endl;
829
830 std::unique_lock<std::mutex> lk1(app.m1.mForChecking, std::defer_lock);
831 std::unique_lock<std::mutex> lk2(app.m2.mForChecking, std::defer_lock);
832
833 ctk::TestFacility test{app};
834
835 auto var = test.getScalar<int>("/m1/poll1");
836 app.getModel().writeGraphViz("testPollingThroughFanOuts.dot");
837 test.runApplication();
838
839 // test with single value
840 var = 666;
841 var.write();
842 BOOST_REQUIRE(lk2.try_lock());
843 app.m2.out2.write();
844 lk2.unlock();
845
846 test.stepApplication();
847
848 BOOST_REQUIRE(lk1.try_lock());
849 app.m1.poll1.read();
850 BOOST_CHECK_EQUAL(app.m1.poll1, 666);
851 app.m1.poll2.read();
852 BOOST_CHECK_EQUAL(app.m1.poll2, 666);
853 lk1.unlock();
854
855 // test with queue overrun
856 for(int i = 0; i < 10; ++i) {
857 var = 691 + i;
858 var.write();
859 }
860 BOOST_REQUIRE(lk2.try_lock());
861 app.m2.out2.write();
862 lk2.unlock();
863
864 test.stepApplication();
865
866 BOOST_REQUIRE(lk1.try_lock());
867 app.m1.poll1.read();
868 BOOST_CHECK_EQUAL(app.m1.poll1, 700);
869 app.m1.poll2.read();
870 BOOST_CHECK_EQUAL(app.m1.poll2, 700);
871 lk1.unlock();
872 }
873 }
874
875 /********************************************************************************************************************/
876 /* test device variables */
877
878 struct TestDeviceApplication : public ctk::Application {
879 TestDeviceApplication() : Application("testApplication") {}
880 ~TestDeviceApplication() override { shutdown(); }
881
882 ctk::DeviceModule dev{this, dummySdm.data(), "/fakeTriggerToSatisfyUnusedRegister"};
883 PollingReadModule pollingReadModule{this, "pollingReadModule", "Module for testing poll-type transfers"};
884 };
885
886 BOOST_AUTO_TEST_CASE(testDevice) {
887 std::cout << "***************************************************************"
888 "******************************************************"
889 << std::endl;
890 std::cout << "==> testDevice" << std::endl;
891
892 TestDeviceApplication app;
893 app.pollingReadModule.poll = {&app.pollingReadModule, "/REG1", "cm", "A poll-type input"};
894
895 ctk::TestFacility test(app);
896 auto push = test.getScalar<int32_t>("/pollingReadModule/push");
897 auto push2 = test.getScalar<int32_t>("/pollingReadModule/push2");
898 auto valuePoll = test.getScalar<int32_t>("/pollingReadModule/valuePoll");
899
900 ctk::Device dev(dummySdm.data());
901 auto r1 = dev.getScalarRegisterAccessor<int32_t>("/REG1.DUMMY_WRITEABLE");
902
903 test.runApplication();
904
905 // this is state 1 in PollingReadModule -> read()
906 r1 = 42;
907 r1.write();
908 push.write();
909 test.stepApplication();
910 valuePoll.read();
911 BOOST_CHECK_EQUAL(valuePoll, 42);
912
913 // this is state 2 in PollingReadModule -> readNonBlocking()
914 r1 = 43;
915 r1.write();
916 push2.write();
917 test.stepApplication();
918 valuePoll.read();
919 BOOST_CHECK_EQUAL(valuePoll, 43);
920
921 // this is state 2 in PollingReadModule -> readLatest()
922 r1 = 44;
923 r1.write();
924 push2.write();
925 test.stepApplication();
926 valuePoll.read();
927 BOOST_CHECK_EQUAL(valuePoll, 44);
928 }
929
930 /********************************************************************************************************************/
931 /* test initial values (from control system variables) */
932
933 struct TestInitialApplication : public ctk::Application {
934 TestInitialApplication() : Application("AnotherTestApplication") {}
935 ~TestInitialApplication() override { shutdown(); }
936
937 PollingThroughFanoutsModule m1{this, "m1", ""};
938 PollingThroughFanoutsModule m2{this, "m2", ""};
939 };
940
941 BOOST_AUTO_TEST_CASE(testInitialValues) {
942 std::cout << "***************************************************************"
943 "******************************************************"
944 << std::endl;
945 std::cout << "==> testInitialValues" << std::endl;
946
947 TestInitialApplication app;
948 // app.findTag(".*").connectTo(app.cs);
949
950 std::unique_lock<std::mutex> lk1(app.m1.mForChecking, std::defer_lock);
951 std::unique_lock<std::mutex> lk2(app.m2.mForChecking, std::defer_lock);
952
953 ctk::TestFacility test{app};
954
955 test.setScalarDefault<int>("/m1/push1", 42);
956 test.setScalarDefault<int>("/m1/poll1", 43);
957 test.setScalarDefault<int>("/m2/poll2", 44);
958
959 test.runApplication();
960
961 BOOST_REQUIRE(lk1.try_lock());
962 BOOST_CHECK(!app.m1.hasRead);
963 BOOST_CHECK_EQUAL(app.m1.push1, 42);
964 BOOST_CHECK_EQUAL(app.m1.poll1, 43);
965 BOOST_CHECK_EQUAL(app.m1.poll2, 0);
966 lk1.unlock();
967 BOOST_REQUIRE(lk2.try_lock());
968 BOOST_CHECK(!app.m2.hasRead);
969 BOOST_CHECK_EQUAL(app.m2.push1, 0);
970 BOOST_CHECK_EQUAL(app.m2.poll1, 0);
971 BOOST_CHECK_EQUAL(app.m2.poll2, 44);
972 lk2.unlock();
973 }
974
975 /********************************************************************************************************************/
976
990 BOOST_AUTO_TEST_CASE(TestableModeLockShared) {
991 std::cout << "TestableModeLockShared" << std::endl;
992
993 const static std::string CDD1 = "(ExceptionDummy:1?map=recoveryGroups.map)";
994 static std::latch blockInitHandler{2};
995
996 class MyApp : public ctk::Application {
997 public:
998 using Application::Application;
999 ~MyApp() { shutdown(); }
1000
1001 class MyMod : public ctk::ApplicationModule {
1002 public:
1003 using ApplicationModule::ApplicationModule;
1004 ctk::ScalarOutput<int32_t> reg2{this, "/MyModule/actuator", "", ""};
1005 void mainLoop() override {
1006 blockInitHandler.arrive_and_wait();
1007 reg2.setAndWrite(42);
1008 }
1009 } myMod{this, "MyMod", ""};
1010
1011 ctk::DeviceModule dev1{this, CDD1, "/trigger", [&](ctk::Device&) { blockInitHandler.arrive_and_wait(); }};
1012 } myApp{"MyApp"};
1013
1014 ctk::Device dev(CDD1);
1015
1016 ctk::TestFacility test(myApp);
1017
1018 test.runApplication();
1019
1020 CHECK_EQUAL_TIMEOUT(dev.read<int32_t>("/MyModule/actuator"), 42, 30000);
1021 }
1022
1023 /********************************************************************************************************************/
1024
1025} // namespace Tests::testTestFacilities
check_timeout.h
CHECK_EQUAL_TIMEOUT
#define CHECK_EQUAL_TIMEOUT(left, right, maxMilliseconds)
Definition check_timeout.h:19
ChimeraTK::Application::getModel
Model::RootProxy getModel()
Return the root of the application model.
Definition Application.h:75
ChimeraTK::Application::run
void run() override
Execute the module.
Definition Application.cc:132
ChimeraTK::Application::initialise
void initialise() override
Definition Application.cc:104
ChimeraTK::Application::shutdown
void shutdown() override
This will remove the global pointer to the instance and allows creating another instance afterwards.
Definition Application.cc:211
ChimeraTK::ApplicationModule::decrementDataFaultCounter
void decrementDataFaultCounter() override
Decrement the fault counter and set the data validity flag to ok if the counter has reached 0.
Definition ApplicationModule.cc:193
ChimeraTK::ApplicationModule::incrementDataFaultCounter
void incrementDataFaultCounter() override
Set the data validity flag to fault and increment the fault counter.
Definition ApplicationModule.cc:189
ChimeraTK::Model::RootProxy::writeGraphViz
void writeGraphViz(const std::string &filename, Args... args) const
Implementations of RootProxy.
Definition Model.h:1789
ChimeraTK::ModuleGroup::Application
friend class Application
Definition ModuleGroup.h:47
ChimeraTK::Module::readAnyGroup
ChimeraTK::ReadAnyGroup readAnyGroup()
Create a ChimeraTK::ReadAnyGroup for all readable variables in this Module.
Definition Module.cc:54
ChimeraTK::Module::writeAll
void writeAll(bool includeReturnChannels=false)
Just call write() on all writable variables in the group.
Definition Module.cc:157
ChimeraTK::ScalarAccessor::write
bool write(ChimeraTK::VersionNumber versionNumber)=delete
ChimeraTK::ScalarAccessor::setAndWrite
void setAndWrite(UserType newValue, VersionNumber versionNumber)=delete
ChimeraTK::ScalarOutput
Convenience class for output scalar accessors (always UpdateMode::push)
Definition ScalarAccessor.h:97
ChimeraTK::ScalarPollInput
Convenience class for input scalar accessors with UpdateMode::poll.
Definition ScalarAccessor.h:84
ChimeraTK::ScalarPushInput
Convenience class for input scalar accessors with UpdateMode::push.
Definition ScalarAccessor.h:72
ChimeraTK::TestFacility
Helper class to facilitate tests of applications based on ApplicationCore.
Definition TestFacility.h:36
ChimeraTK::TestFacility::stepApplication
void stepApplication(bool waitForDeviceInitialisation=true) const
Perform a "step" of the application.
Definition TestFacility.cc:113
ChimeraTK::TestFacility::getScalar
ChimeraTK::ScalarRegisterAccessor< T > getScalar(const ChimeraTK::RegisterPath &name) const
Obtain a scalar process variable from the application, which is published to the control system.
Definition TestFacility.h:155
ChimeraTK::TestFacility::runApplication
void runApplication() const
Start the application in testable mode.
Definition TestFacility.cc:28
ChimeraTK
InvalidityTracer application module.
Definition spec_dataValidityPropagation.dox:2
Tests::testTestFacilities::BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testNoDecorator)
Definition testTestFacilities.cc:206
Tests::testTestFacilities::dummySdm
constexpr std::string_view dummySdm
Definition testTestFacilities.cc:31
Tests::testTestFacilities::BlockingReadTestModule::mainLoop
void mainLoop() override
To be implemented by the user: function called in a separate thread executing the main loop of the mo...
Definition testTestFacilities.cc:42
Tests::testTestFacilities::PollingReadModule::prepare
void prepare() override
Prepare the execution of the module.
Definition testTestFacilities.cc:124
Tests::testTestFacilities::PollingReadModule::mainLoop
void mainLoop() override
To be implemented by the user: function called in a separate thread executing the main loop of the mo...
Definition testTestFacilities.cc:130
Tests::testTestFacilities::PollingThroughFanoutsModule::mainLoop
void mainLoop() override
To be implemented by the user: function called in a separate thread executing the main loop of the mo...
Definition testTestFacilities.cc:182
Tests::testTestFacilities::PollingThroughFanoutsModule::prepare
void prepare() override
Prepare the execution of the module.
Definition testTestFacilities.cc:178
Tests::testTestFacilities::ReadAnyTestModule::prepare
void prepare() override
Prepare the execution of the module.
Definition testTestFacilities.cc:72
Tests::testTestFacilities::ReadAnyTestModule::mainLoop
void mainLoop() override
To be implemented by the user: function called in a separate thread executing the main loop of the mo...
Definition testTestFacilities.cc:78
CHECK_TIMEOUT
#define CHECK_TIMEOUT(condition, maxMilliseconds)
Definition testControlSystemAccessors.cc:28
mainLoop
void mainLoop() override
Definition testIllegalNetworks.cc:4