API
 
Loading...
Searching...
No Matches
outletController_test.cpp
Go to the documentation of this file.
1//#define CATCH_CONFIG_MAIN
2#include "../../../../tests/catch2/catch.hpp"
3
4#include <mx/sys/timeUtils.hpp>
5
6#define OUTLET_CTRL_TEST_NOINDI
7#define OUTLET_CTRL_TEST_NOLOG
8#include "../outletController.hpp"
9
10/** \defgroup outletController_tests libXWC::app::dev::outletController Unit Tests
11 * \ingroup app_dev_unit_tests
12*/
13namespace outletController_tests
14{
15
16struct outletControllerTest : public MagAOX::app::dev::outletController<outletControllerTest>
17{
18 std::vector<double> m_timestamps;
19
20 outletControllerTest()
21 {
22 setNumberOfOutlets(4);
23 m_timestamps.resize(4,0);
24 turnOutletOff(0);
25 turnOutletOff(1);
26 turnOutletOff(2);
27 turnOutletOff(3);
28 }
29
30 virtual int updateOutletState( int outletNum )
31 {
32 return m_outletStates[outletNum];
33 }
34
35
36 virtual int turnOutletOn( int outletNum )
37 {
38 m_outletStates[outletNum] = 2;
39 mx::sys::nanoSleep(1);
40 m_timestamps[outletNum] = mx::sys::get_curr_time();
41
42 return 0;
43 }
44
45 virtual int turnOutletOff( int outletNum )
46 {
47 m_outletStates[outletNum] = 0;
48 mx::sys::nanoSleep(1);
49 m_timestamps[outletNum] = mx::sys::get_curr_time();
50
51 return 0;
52 }
53
54};
55
56/// outletController Configuration
57/**
58 * \ingroup outletController_tests
59 */
60SCENARIO( "outletController Configuration", "[outletController]" )
61{
62 GIVEN("a config file with 4 channels for 4 outlets")
63 {
64 WHEN("using outlet keyword, only outlet specified")
65 {
66 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2", "channel3", "channel4"},
67 {"outlet", "outlet", "outlet", "outlet"},
68 {"0", "1", "2", "3"} );
69
70 mx::app::appConfigurator config;
71 config.readConfig("/tmp/outletController_test.conf");
72
73 outletControllerTest pdt;
74 int rv;
75 rv = pdt.setupConfig(config);
76 REQUIRE( rv == 0);
77
78 rv = pdt.loadConfig(config);
79 REQUIRE( rv == 0);
80 REQUIRE( pdt.numChannels() == 4);
81
82 std::vector<size_t> outlets, onOrder, offOrder;
83 std::vector<unsigned> onDelays, offDelays;
84 outlets = pdt.channelOutlets("channel1");
85 REQUIRE( outlets.size() == 1);
86 REQUIRE( outlets[0] == 0 );
87
88 onOrder = pdt.channelOnOrder("channel1");
89 REQUIRE( onOrder.size() == 0);
90 offOrder = pdt.channelOffOrder("channel1");
91 REQUIRE( offOrder.size() == 0);
92 onDelays = pdt.channelOnDelays("channel1");
93 REQUIRE( onDelays.size() == 0);
94 offDelays = pdt.channelOffDelays("channel1");
95 REQUIRE( offDelays.size() == 0);
96
97 outlets = pdt.channelOutlets("channel2");
98 REQUIRE( outlets.size() == 1);
99 REQUIRE( outlets[0] == 1 );
100
101 onOrder = pdt.channelOnOrder("channel2");
102 REQUIRE( onOrder.size() == 0);
103 offOrder = pdt.channelOffOrder("channel2");
104 REQUIRE( offOrder.size() == 0);
105 onDelays = pdt.channelOnDelays("channel2");
106 REQUIRE( onDelays.size() == 0);
107 offDelays = pdt.channelOffDelays("channel2");
108 REQUIRE( offDelays.size() == 0);
109
110 outlets = pdt.channelOutlets("channel3");
111 REQUIRE( outlets.size() == 1);
112 REQUIRE( outlets[0] == 2 );
113
114 onOrder = pdt.channelOnOrder("channel3");
115 REQUIRE( onOrder.size() == 0);
116 offOrder = pdt.channelOffOrder("channel3");
117 REQUIRE( offOrder.size() == 0);
118 onDelays = pdt.channelOnDelays("channel3");
119 REQUIRE( onDelays.size() == 0);
120 offDelays = pdt.channelOffDelays("channel3");
121 REQUIRE( offDelays.size() == 0);
122
123 outlets = pdt.channelOutlets("channel4");
124 REQUIRE( outlets.size() == 1);
125 REQUIRE( outlets[0] == 3 );
126
127 onOrder = pdt.channelOnOrder("channel4");
128 REQUIRE( onOrder.size() == 0);
129 offOrder = pdt.channelOffOrder("channel4");
130 REQUIRE( offOrder.size() == 0);
131 onDelays = pdt.channelOnDelays("channel4");
132 REQUIRE( onDelays.size() == 0);
133 offDelays = pdt.channelOffDelays("channel4");
134 REQUIRE( offDelays.size() == 0);
135
136 }
137
138 WHEN("using outlet keyword, all specified")
139 {
140 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel1", "channel1", "channel2", "channel2", "channel2", "channel2", "channel2", "channel3", "channel3", "channel3", "channel3", "channel3", "channel4", "channel4", "channel4", "channel4", "channel4" },
141 {"outlet", "onOrder", "offOrder", "onDelays", "offDelays", "outlet", "onOrder", "offOrder", "onDelays", "offDelays", "outlet", "onOrder", "offOrder", "onDelays", "offDelays", "outlet", "onOrder", "offOrder", "onDelays", "offDelays" },
142 {"0", "0", "0", "100", "120", "1", "0", "0", "105", "130", "2", "0", "0", "107", "132", "3", "0", "0", "108", "133"});
143
144 mx::app::appConfigurator config;
145 config.readConfig("/tmp/outletController_test.conf");
146
147 outletControllerTest pdt;
148 int rv;
149 rv = pdt.setupConfig(config);
150 REQUIRE( rv == 0);
151
152 rv = pdt.loadConfig(config);
153 REQUIRE( rv == 0);
154 REQUIRE( pdt.numChannels() == 4);
155
156 std::vector<size_t> outlets, onOrder, offOrder;
157 std::vector<unsigned> onDelays, offDelays;
158
159 outlets = pdt.channelOutlets("channel1");
160 REQUIRE( outlets.size() == 1);
161 REQUIRE( outlets[0] == 0 );
162
163 onOrder = pdt.channelOnOrder("channel1");
164 REQUIRE( onOrder.size() == 1);
165 REQUIRE( onOrder[0] == 0);
166 offOrder = pdt.channelOffOrder("channel1");
167 REQUIRE( offOrder.size() == 1);
168 REQUIRE( offOrder[0] == 0);
169 onDelays = pdt.channelOnDelays("channel1");
170 REQUIRE( onDelays.size() == 1);
171 REQUIRE( onDelays[0] == 100);
172 offDelays = pdt.channelOffDelays("channel1");
173 REQUIRE( offDelays.size() == 1);
174 REQUIRE( offDelays[0] == 120);
175
176 outlets = pdt.channelOutlets("channel2");
177 REQUIRE( outlets.size() == 1);
178 REQUIRE( outlets[0] == 1 );
179
180 onOrder = pdt.channelOnOrder("channel2");
181 REQUIRE( onOrder.size() == 1);
182 REQUIRE( onOrder[0] == 0);
183 offOrder = pdt.channelOffOrder("channel2");
184 REQUIRE( offOrder.size() == 1);
185 REQUIRE( offOrder[0] == 0);
186 onDelays = pdt.channelOnDelays("channel2");
187 REQUIRE( onDelays.size() == 1);
188 REQUIRE( onDelays[0] == 105);
189 offDelays = pdt.channelOffDelays("channel2");
190 REQUIRE( offDelays.size() == 1);
191 REQUIRE( offDelays[0] == 130);
192
193 outlets = pdt.channelOutlets("channel3");
194 REQUIRE( outlets.size() == 1);
195 REQUIRE( outlets[0] == 2 );
196
197 onOrder = pdt.channelOnOrder("channel3");
198 REQUIRE( onOrder.size() == 1);
199 REQUIRE( onOrder[0] == 0);
200 offOrder = pdt.channelOffOrder("channel3");
201 REQUIRE( offOrder.size() == 1);
202 REQUIRE( offOrder[0] == 0);
203 onDelays = pdt.channelOnDelays("channel3");
204 REQUIRE( onDelays.size() == 1);
205 REQUIRE( onDelays[0] == 107);
206 offDelays = pdt.channelOffDelays("channel3");
207 REQUIRE( offDelays.size() == 1);
208 REQUIRE( offDelays[0] == 132);
209
210 outlets = pdt.channelOutlets("channel4");
211 REQUIRE( outlets.size() == 1);
212 REQUIRE( outlets[0] == 3 );
213
214 onOrder = pdt.channelOnOrder("channel4");
215 REQUIRE( onOrder.size() == 1);
216 REQUIRE( onOrder[0] == 0);
217 offOrder = pdt.channelOffOrder("channel4");
218 REQUIRE( offOrder.size() == 1);
219 REQUIRE( offOrder[0] == 0);
220 onDelays = pdt.channelOnDelays("channel4");
221 REQUIRE( onDelays.size() == 1);
222 REQUIRE( onDelays[0] == 108);
223 offDelays = pdt.channelOffDelays("channel4");
224 REQUIRE( offDelays.size() == 1);
225 REQUIRE( offDelays[0] == 133);
226 }
227
228 WHEN("using outlets keyword, only outlet specified")
229 {
230 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2", "channel3", "channel4"},
231 {"outlets", "outlets", "outlets", "outlets"},
232 {"0", "1", "2", "3"} );
233
234 mx::app::appConfigurator config;
235 config.readConfig("/tmp/outletController_test.conf");
236
237 outletControllerTest pdt;
238 int rv;
239 rv = pdt.setupConfig(config);
240 REQUIRE( rv == 0);
241
242 rv = pdt.loadConfig(config);
243 REQUIRE( rv == 0);
244 REQUIRE( pdt.numChannels() == 4);
245
246 std::vector<size_t> outlets, onOrder, offOrder;
247 std::vector<unsigned> onDelays, offDelays;
248 outlets = pdt.channelOutlets("channel1");
249 REQUIRE( outlets.size() == 1);
250 REQUIRE( outlets[0] == 0 );
251
252 onOrder = pdt.channelOnOrder("channel1");
253 REQUIRE( onOrder.size() == 0);
254 offOrder = pdt.channelOffOrder("channel1");
255 REQUIRE( offOrder.size() == 0);
256 onDelays = pdt.channelOnDelays("channel1");
257 REQUIRE( onDelays.size() == 0);
258 offDelays = pdt.channelOffDelays("channel1");
259 REQUIRE( offDelays.size() == 0);
260
261 outlets = pdt.channelOutlets("channel2");
262 REQUIRE( outlets.size() == 1);
263 REQUIRE( outlets[0] == 1 );
264
265 onOrder = pdt.channelOnOrder("channel2");
266 REQUIRE( onOrder.size() == 0);
267 offOrder = pdt.channelOffOrder("channel2");
268 REQUIRE( offOrder.size() == 0);
269 onDelays = pdt.channelOnDelays("channel2");
270 REQUIRE( onDelays.size() == 0);
271 offDelays = pdt.channelOffDelays("channel2");
272 REQUIRE( offDelays.size() == 0);
273
274 outlets = pdt.channelOutlets("channel3");
275 REQUIRE( outlets.size() == 1);
276 REQUIRE( outlets[0] == 2 );
277
278 onOrder = pdt.channelOnOrder("channel3");
279 REQUIRE( onOrder.size() == 0);
280 offOrder = pdt.channelOffOrder("channel3");
281 REQUIRE( offOrder.size() == 0);
282 onDelays = pdt.channelOnDelays("channel3");
283 REQUIRE( onDelays.size() == 0);
284 offDelays = pdt.channelOffDelays("channel3");
285 REQUIRE( offDelays.size() == 0);
286
287 outlets = pdt.channelOutlets("channel4");
288 REQUIRE( outlets.size() == 1);
289 REQUIRE( outlets[0] == 3 );
290
291 onOrder = pdt.channelOnOrder("channel4");
292 REQUIRE( onOrder.size() == 0);
293 offOrder = pdt.channelOffOrder("channel4");
294 REQUIRE( offOrder.size() == 0);
295 onDelays = pdt.channelOnDelays("channel4");
296 REQUIRE( onDelays.size() == 0);
297 offDelays = pdt.channelOffDelays("channel4");
298 REQUIRE( offDelays.size() == 0);
299 }
300
301 WHEN("using outlets keyword, all specified")
302 {
303 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel1", "channel1", "channel2", "channel2", "channel2", "channel2", "channel2", "channel3", "channel3", "channel3", "channel3", "channel3", "channel4", "channel4", "channel4", "channel4", "channel4" },
304 {"outlets", "onOrder", "offOrder", "onDelays", "offDelays", "outlets", "onOrder", "offOrder", "onDelays", "offDelays", "outlets", "onOrder", "offOrder", "onDelays", "offDelays", "outlets", "onOrder", "offOrder", "onDelays", "offDelays" },
305 {"0", "0", "0", "100", "120", "1", "0", "0", "105", "130", "2", "0", "0", "107", "132", "3", "0", "0", "108", "133"});
306
307 mx::app::appConfigurator config;
308 config.readConfig("/tmp/outletController_test.conf");
309
310 outletControllerTest pdt;
311 int rv;
312 rv = pdt.setupConfig(config);
313 REQUIRE( rv == 0);
314
315 rv = pdt.loadConfig(config);
316 REQUIRE( rv == 0);
317 REQUIRE( pdt.numChannels() == 4);
318
319 std::vector<size_t> outlets, onOrder, offOrder;
320 std::vector<unsigned> onDelays, offDelays;
321
322 outlets = pdt.channelOutlets("channel1");
323 REQUIRE( outlets.size() == 1);
324 REQUIRE( outlets[0] == 0 );
325
326 onOrder = pdt.channelOnOrder("channel1");
327 REQUIRE( onOrder.size() == 1);
328 REQUIRE( onOrder[0] == 0);
329 offOrder = pdt.channelOffOrder("channel1");
330 REQUIRE( offOrder.size() == 1);
331 REQUIRE( offOrder[0] == 0);
332 onDelays = pdt.channelOnDelays("channel1");
333 REQUIRE( onDelays.size() == 1);
334 REQUIRE( onDelays[0] == 100);
335 offDelays = pdt.channelOffDelays("channel1");
336 REQUIRE( offDelays.size() == 1);
337 REQUIRE( offDelays[0] == 120);
338
339 outlets = pdt.channelOutlets("channel2");
340 REQUIRE( outlets.size() == 1);
341 REQUIRE( outlets[0] == 1 );
342
343 onOrder = pdt.channelOnOrder("channel2");
344 REQUIRE( onOrder.size() == 1);
345 REQUIRE( onOrder[0] == 0);
346 offOrder = pdt.channelOffOrder("channel2");
347 REQUIRE( offOrder.size() == 1);
348 REQUIRE( offOrder[0] == 0);
349 onDelays = pdt.channelOnDelays("channel2");
350 REQUIRE( onDelays.size() == 1);
351 REQUIRE( onDelays[0] == 105);
352 offDelays = pdt.channelOffDelays("channel2");
353 REQUIRE( offDelays.size() == 1);
354 REQUIRE( offDelays[0] == 130);
355
356 outlets = pdt.channelOutlets("channel3");
357 REQUIRE( outlets.size() == 1);
358 REQUIRE( outlets[0] == 2 );
359
360 onOrder = pdt.channelOnOrder("channel3");
361 REQUIRE( onOrder.size() == 1);
362 REQUIRE( onOrder[0] == 0);
363 offOrder = pdt.channelOffOrder("channel3");
364 REQUIRE( offOrder.size() == 1);
365 REQUIRE( offOrder[0] == 0);
366 onDelays = pdt.channelOnDelays("channel3");
367 REQUIRE( onDelays.size() == 1);
368 REQUIRE( onDelays[0] == 107);
369 offDelays = pdt.channelOffDelays("channel3");
370 REQUIRE( offDelays.size() == 1);
371 REQUIRE( offDelays[0] == 132);
372
373 outlets = pdt.channelOutlets("channel4");
374 REQUIRE( outlets.size() == 1);
375 REQUIRE( outlets[0] == 3 );
376
377 onOrder = pdt.channelOnOrder("channel4");
378 REQUIRE( onOrder.size() == 1);
379 REQUIRE( onOrder[0] == 0);
380 offOrder = pdt.channelOffOrder("channel4");
381 REQUIRE( offOrder.size() == 1);
382 REQUIRE( offOrder[0] == 0);
383 onDelays = pdt.channelOnDelays("channel4");
384 REQUIRE( onDelays.size() == 1);
385 REQUIRE( onDelays[0] == 108);
386 offDelays = pdt.channelOffDelays("channel4");
387 REQUIRE( offDelays.size() == 1);
388 REQUIRE( offDelays[0] == 133);
389 }
390 }
391
392 GIVEN("a config file with 2 channels for 4 outlets")
393 {
394 WHEN("using outlet keyword, only outlet specified")
395 {
396 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2" },
397 {"outlet", "outlet" },
398 {"0,1", "2,3" } );
399
400 mx::app::appConfigurator config;
401 config.readConfig("/tmp/outletController_test.conf");
402
403 outletControllerTest pdt;
404 int rv;
405 rv = pdt.setupConfig(config);
406 REQUIRE( rv == 0);
407
408 rv = pdt.loadConfig(config);
409 REQUIRE( rv == 0);
410 REQUIRE( pdt.numChannels() == 2);
411
412 std::vector<size_t> outlets, onOrder, offOrder;
413 std::vector<unsigned> onDelays, offDelays;
414 outlets = pdt.channelOutlets("channel1");
415 REQUIRE( outlets.size() == 2);
416 REQUIRE( outlets[0] == 0 );
417 REQUIRE( outlets[1] == 1 );
418
419 onOrder = pdt.channelOnOrder("channel1");
420 REQUIRE( onOrder.size() == 0);
421 offOrder = pdt.channelOffOrder("channel1");
422 REQUIRE( offOrder.size() == 0);
423 onDelays = pdt.channelOnDelays("channel1");
424 REQUIRE( onDelays.size() == 0);
425 offDelays = pdt.channelOffDelays("channel1");
426 REQUIRE( offDelays.size() == 0);
427
428 outlets = pdt.channelOutlets("channel2");
429 REQUIRE( outlets.size() == 2);
430 REQUIRE( outlets[0] == 2 );
431 REQUIRE( outlets[1] == 3 );
432
433 onOrder = pdt.channelOnOrder("channel2");
434 REQUIRE( onOrder.size() == 0);
435 offOrder = pdt.channelOffOrder("channel2");
436 REQUIRE( offOrder.size() == 0);
437 onDelays = pdt.channelOnDelays("channel2");
438 REQUIRE( onDelays.size() == 0);
439 offDelays = pdt.channelOffDelays("channel2");
440 REQUIRE( offDelays.size() == 0);
441
442
443 }
444
445 WHEN("using outlet keyword, all specified")
446 {
447 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1","channel1", "channel1", "channel1", "channel1", "channel2", "channel2", "channel2", "channel2", "channel2" },
448 {"outlet", "onOrder", "offOrder", "onDelays", "offDelays", "outlet", "onOrder", "offOrder", "onDelays", "offDelays" },
449 {"0,1", "0,1", "1,0", "0,105", "0,107", "2,3", "1,0", "0,1", "0,106", "0,108" } );
450
451 mx::app::appConfigurator config;
452 config.readConfig("/tmp/outletController_test.conf");
453
454 outletControllerTest pdt;
455 int rv;
456 rv = pdt.setupConfig(config);
457 REQUIRE( rv == 0);
458
459 rv = pdt.loadConfig(config);
460 REQUIRE( rv == 0);
461 REQUIRE( pdt.numChannels() == 2);
462
463 std::vector<size_t> outlets, onOrder, offOrder;
464 std::vector<unsigned> onDelays, offDelays;
465 outlets = pdt.channelOutlets("channel1");
466 REQUIRE( outlets.size() == 2);
467 REQUIRE( outlets[0] == 0 );
468 REQUIRE( outlets[1] == 1 );
469
470 onOrder = pdt.channelOnOrder("channel1");
471 REQUIRE( onOrder.size() == 2);
472 REQUIRE( onOrder[0] == 0 );
473 REQUIRE( onOrder[1] == 1 );
474 offOrder = pdt.channelOffOrder("channel1");
475 REQUIRE( offOrder.size() == 2);
476 REQUIRE( offOrder[0] == 1 );
477 REQUIRE( offOrder[1] == 0 );
478 onDelays = pdt.channelOnDelays("channel1");
479 REQUIRE( onDelays.size() == 2);
480 REQUIRE( onDelays[0] == 0 );
481 REQUIRE( onDelays[1] == 105 );
482 offDelays = pdt.channelOffDelays("channel1");
483 REQUIRE( offDelays.size() == 2);
484 REQUIRE( offDelays[0] == 0 );
485 REQUIRE( offDelays[1] == 107 );
486
487 outlets = pdt.channelOutlets("channel2");
488 REQUIRE( outlets.size() == 2);
489 REQUIRE( outlets[0] == 2 );
490 REQUIRE( outlets[1] == 3 );
491
492 onOrder = pdt.channelOnOrder("channel2");
493 REQUIRE( onOrder.size() == 2);
494 REQUIRE( onOrder[0] == 1 );
495 REQUIRE( onOrder[1] == 0 );
496 offOrder = pdt.channelOffOrder("channel2");
497 REQUIRE( offOrder.size() == 2);
498 REQUIRE( offOrder[0] == 0 );
499 REQUIRE( offOrder[1] == 1 );
500 onDelays = pdt.channelOnDelays("channel2");
501 REQUIRE( onDelays.size() == 2);
502 REQUIRE( onDelays[0] == 0 );
503 REQUIRE( onDelays[1] == 106 );
504 offDelays = pdt.channelOffDelays("channel2");
505 REQUIRE( offDelays.size() == 2);
506 REQUIRE( offDelays[0] == 0 );
507 REQUIRE( offDelays[1] == 108 );
508 }
509
510 WHEN("using outlets keyword, only outlet specified")
511 {
512 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2" },
513 {"outlets", "outlets" },
514 {"0,1", "2,3" } );
515
516 mx::app::appConfigurator config;
517 config.readConfig("/tmp/outletController_test.conf");
518
519 outletControllerTest pdt;
520 int rv;
521 rv = pdt.setupConfig(config);
522 REQUIRE( rv == 0);
523
524 rv = pdt.loadConfig(config);
525 REQUIRE( rv == 0);
526 REQUIRE( pdt.numChannels() == 2);
527
528 std::vector<size_t> outlets, onOrder, offOrder;
529 std::vector<unsigned> onDelays, offDelays;
530 outlets = pdt.channelOutlets("channel1");
531 REQUIRE( outlets.size() == 2);
532 REQUIRE( outlets[0] == 0 );
533 REQUIRE( outlets[1] == 1 );
534
535 onOrder = pdt.channelOnOrder("channel1");
536 REQUIRE( onOrder.size() == 0);
537 offOrder = pdt.channelOffOrder("channel1");
538 REQUIRE( offOrder.size() == 0);
539 onDelays = pdt.channelOnDelays("channel1");
540 REQUIRE( onDelays.size() == 0);
541 offDelays = pdt.channelOffDelays("channel1");
542 REQUIRE( offDelays.size() == 0);
543
544
545 outlets = pdt.channelOutlets("channel2");
546 REQUIRE( outlets.size() == 2);
547 REQUIRE( outlets[0] == 2 );
548 REQUIRE( outlets[1] == 3 );
549
550 onOrder = pdt.channelOnOrder("channel2");
551 REQUIRE( onOrder.size() == 0);
552 offOrder = pdt.channelOffOrder("channel2");
553 REQUIRE( offOrder.size() == 0);
554 onDelays = pdt.channelOnDelays("channel2");
555 REQUIRE( onDelays.size() == 0);
556 offDelays = pdt.channelOffDelays("channel2");
557 REQUIRE( offDelays.size() == 0);
558 }
559
560 WHEN("using outlets keyword, all specified")
561 {
562 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1","channel1", "channel1", "channel1", "channel1", "channel2", "channel2", "channel2", "channel2", "channel2" },
563 {"outlets", "onOrder", "offOrder", "onDelays", "offDelays", "outlets", "onOrder", "offOrder", "onDelays", "offDelays" },
564 {"0,2", "0,1", "1,0", "0,105", "0,107", "1,3", "1,0", "0,1", "0,106", "0,108" } );
565
566 mx::app::appConfigurator config;
567 config.readConfig("/tmp/outletController_test.conf");
568
569 outletControllerTest pdt;
570 int rv;
571 rv = pdt.setupConfig(config);
572 REQUIRE( rv == 0);
573
574 rv = pdt.loadConfig(config);
575 REQUIRE( rv == 0);
576 REQUIRE( pdt.numChannels() == 2);
577
578 std::vector<size_t> outlets, onOrder, offOrder;
579 std::vector<unsigned> onDelays, offDelays;
580 outlets = pdt.channelOutlets("channel1");
581 REQUIRE( outlets.size() == 2);
582 REQUIRE( outlets[0] == 0 );
583 REQUIRE( outlets[1] == 2 );
584
585 onOrder = pdt.channelOnOrder("channel1");
586 REQUIRE( onOrder.size() == 2);
587 REQUIRE( onOrder[0] == 0 );
588 REQUIRE( onOrder[1] == 1 );
589 offOrder = pdt.channelOffOrder("channel1");
590 REQUIRE( offOrder.size() == 2);
591 REQUIRE( offOrder[0] == 1 );
592 REQUIRE( offOrder[1] == 0 );
593 onDelays = pdt.channelOnDelays("channel1");
594 REQUIRE( onDelays.size() == 2);
595 REQUIRE( onDelays[0] == 0 );
596 REQUIRE( onDelays[1] == 105 );
597 offDelays = pdt.channelOffDelays("channel1");
598 REQUIRE( offDelays.size() == 2);
599 REQUIRE( offDelays[0] == 0 );
600 REQUIRE( offDelays[1] == 107 );
601
602 outlets = pdt.channelOutlets("channel2");
603 REQUIRE( outlets.size() == 2);
604 REQUIRE( outlets[0] == 1 );
605 REQUIRE( outlets[1] == 3 );
606
607 onOrder = pdt.channelOnOrder("channel2");
608 REQUIRE( onOrder.size() == 2);
609 REQUIRE( onOrder[0] == 1 );
610 REQUIRE( onOrder[1] == 0 );
611 offOrder = pdt.channelOffOrder("channel2");
612 REQUIRE( offOrder.size() == 2);
613 REQUIRE( offOrder[0] == 0 );
614 REQUIRE( offOrder[1] == 1 );
615 onDelays = pdt.channelOnDelays("channel2");
616 REQUIRE( onDelays.size() == 2);
617 REQUIRE( onDelays[0] == 0 );
618 REQUIRE( onDelays[1] == 106 );
619 offDelays = pdt.channelOffDelays("channel2");
620 REQUIRE( offDelays.size() == 2);
621 REQUIRE( offDelays[0] == 0 );
622 REQUIRE( offDelays[1] == 108 );
623 }
624 }
625}
626
627/// outletController Operation
628/**
629 * \ingroup outletController_tests
630 */
631SCENARIO( "outletController Operation", "[outletController]" )
632{
633 GIVEN("a config file with 4 channels for 4 outlets, only outlet specified")
634 {
635 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2", "channel3", "channel4"},
636 {"outlet", "outlet", "outlet", "outlet"},
637 {"0", "1", "2", "3"} );
638
639 mx::app::appConfigurator config;
640 config.readConfig("/tmp/outletController_test.conf");
641
642 outletControllerTest pdt;
643 pdt.setupConfig(config);
644 pdt.loadConfig(config);
645
646 WHEN("test device startup outlet states")
647 {
648 //Verify outlet startup state
649 REQUIRE( pdt.outletState(0) == 0 );
650 REQUIRE( pdt.outletState(1) == 0 );
651 REQUIRE( pdt.outletState(2) == 0 );
652 REQUIRE( pdt.outletState(3) == 0 );
653
654 //Verify channel state at startup
655 REQUIRE( pdt.channelState("channel1") == 0 );
656 REQUIRE( pdt.channelState("channel2") == 0 );
657 REQUIRE( pdt.channelState("channel3") == 0 );
658 REQUIRE( pdt.channelState("channel4") == 0 );
659 }
660 WHEN("operating a single channel")
661 {
662 //Turn on channel1
663 pdt.turnChannelOn("channel1");
664
665 //Verify outlet state
666 REQUIRE( pdt.outletState(0) == 2 );
667 REQUIRE( pdt.outletState(1) == 0 );
668 REQUIRE( pdt.outletState(2) == 0 );
669 REQUIRE( pdt.outletState(3) == 0 );
670
671 //Verify channel state
672 REQUIRE( pdt.channelState("channel1") == 2 );
673 REQUIRE( pdt.channelState("channel2") == 0 );
674 REQUIRE( pdt.channelState("channel3") == 0 );
675 REQUIRE( pdt.channelState("channel4") == 0 );
676
677 //Turn off channel1
678 pdt.turnChannelOff("channel1");
679
680 //Verify outlet state
681 REQUIRE( pdt.outletState(0) == 0 );
682 REQUIRE( pdt.outletState(1) == 0 );
683 REQUIRE( pdt.outletState(2) == 0 );
684 REQUIRE( pdt.outletState(3) == 0 );
685
686 //Verify channel state
687 REQUIRE( pdt.channelState("channel1") == 0 );
688 REQUIRE( pdt.channelState("channel2") == 0 );
689 REQUIRE( pdt.channelState("channel3") == 0 );
690 REQUIRE( pdt.channelState("channel4") == 0 );
691
692 //Turn on channel2
693 pdt.turnChannelOn("channel2");
694
695 //Verify outlet state
696 REQUIRE( pdt.outletState(0) == 0 );
697 REQUIRE( pdt.outletState(1) == 2 );
698 REQUIRE( pdt.outletState(2) == 0 );
699 REQUIRE( pdt.outletState(3) == 0 );
700
701 //Verify channel state
702 REQUIRE( pdt.channelState("channel1") == 0 );
703 REQUIRE( pdt.channelState("channel2") == 2 );
704 REQUIRE( pdt.channelState("channel3") == 0 );
705 REQUIRE( pdt.channelState("channel4") == 0 );
706
707 //Turn off channel1
708 pdt.turnChannelOff("channel2");
709
710 //Verify outlet state
711 REQUIRE( pdt.outletState(0) == 0 );
712 REQUIRE( pdt.outletState(1) == 0 );
713 REQUIRE( pdt.outletState(2) == 0 );
714 REQUIRE( pdt.outletState(3) == 0 );
715
716 //Verify channel state
717 REQUIRE( pdt.channelState("channel1") == 0 );
718 REQUIRE( pdt.channelState("channel2") == 0 );
719 REQUIRE( pdt.channelState("channel3") == 0 );
720 REQUIRE( pdt.channelState("channel4") == 0 );
721
722 //Turn on channel3
723 pdt.turnChannelOn("channel3");
724
725 //Verify outlet state
726 REQUIRE( pdt.outletState(0) == 0 );
727 REQUIRE( pdt.outletState(1) == 0 );
728 REQUIRE( pdt.outletState(2) == 2 );
729 REQUIRE( pdt.outletState(3) == 0 );
730
731 //Verify channel state
732 REQUIRE( pdt.channelState("channel1") == 0 );
733 REQUIRE( pdt.channelState("channel2") == 0 );
734 REQUIRE( pdt.channelState("channel3") == 2 );
735 REQUIRE( pdt.channelState("channel4") == 0 );
736
737 //Turn off channel1
738 pdt.turnChannelOff("channel3");
739
740 //Verify outlet state
741 REQUIRE( pdt.outletState(0) == 0 );
742 REQUIRE( pdt.outletState(1) == 0 );
743 REQUIRE( pdt.outletState(2) == 0 );
744 REQUIRE( pdt.outletState(3) == 0 );
745
746 //Verify channel state
747 REQUIRE( pdt.channelState("channel1") == 0 );
748 REQUIRE( pdt.channelState("channel2") == 0 );
749 REQUIRE( pdt.channelState("channel3") == 0 );
750 REQUIRE( pdt.channelState("channel4") == 0 );
751
752 //Turn on channel4
753 pdt.turnChannelOn("channel4");
754
755 //Verify outlet state
756 REQUIRE( pdt.outletState(0) == 0 );
757 REQUIRE( pdt.outletState(1) == 0 );
758 REQUIRE( pdt.outletState(2) == 0 );
759 REQUIRE( pdt.outletState(3) == 2 );
760
761 //Verify channel state
762 REQUIRE( pdt.channelState("channel1") == 0 );
763 REQUIRE( pdt.channelState("channel2") == 0 );
764 REQUIRE( pdt.channelState("channel3") == 0 );
765 REQUIRE( pdt.channelState("channel4") == 2 );
766
767 //Turn off channel1
768 pdt.turnChannelOff("channel4");
769
770 //Verify outlet startup state
771 REQUIRE( pdt.outletState(0) == 0 );
772 REQUIRE( pdt.outletState(1) == 0 );
773 REQUIRE( pdt.outletState(2) == 0 );
774 REQUIRE( pdt.outletState(3) == 0 );
775
776 //Verify channel state at startup
777 REQUIRE( pdt.channelState("channel1") == 0 );
778 REQUIRE( pdt.channelState("channel2") == 0 );
779 REQUIRE( pdt.channelState("channel3") == 0 );
780 REQUIRE( pdt.channelState("channel4") == 0 );
781 }
782 WHEN("operating multiple channels")
783 {
784 //Turn on channel1&2
785 pdt.turnChannelOn("channel1");
786 pdt.turnChannelOn("channel2");
787
788 //Verify outlet state
789 REQUIRE( pdt.outletState(0) == 2 );
790 REQUIRE( pdt.outletState(1) == 2 );
791 REQUIRE( pdt.outletState(2) == 0 );
792 REQUIRE( pdt.outletState(3) == 0 );
793
794 //Verify channel state
795 REQUIRE( pdt.channelState("channel1") == 2 );
796 REQUIRE( pdt.channelState("channel2") == 2 );
797 REQUIRE( pdt.channelState("channel3") == 0 );
798 REQUIRE( pdt.channelState("channel4") == 0 );
799
800 //Turn off channel1&2
801 pdt.turnChannelOff("channel1");
802 pdt.turnChannelOff("channel2");
803
804 //Verify outlet state
805 REQUIRE( pdt.outletState(0) == 0 );
806 REQUIRE( pdt.outletState(1) == 0 );
807 REQUIRE( pdt.outletState(2) == 0 );
808 REQUIRE( pdt.outletState(3) == 0 );
809
810 //Verify channel state
811 REQUIRE( pdt.channelState("channel1") == 0 );
812 REQUIRE( pdt.channelState("channel2") == 0 );
813 REQUIRE( pdt.channelState("channel3") == 0 );
814 REQUIRE( pdt.channelState("channel4") == 0 );
815
816 //Turn on channel3&4
817 pdt.turnChannelOn("channel3");
818 pdt.turnChannelOn("channel4");
819
820 //Verify outlet state
821 REQUIRE( pdt.outletState(0) == 0 );
822 REQUIRE( pdt.outletState(1) == 0 );
823 REQUIRE( pdt.outletState(2) == 2 );
824 REQUIRE( pdt.outletState(3) == 2 );
825
826 //Verify channel state
827 REQUIRE( pdt.channelState("channel1") == 0 );
828 REQUIRE( pdt.channelState("channel2") == 0 );
829 REQUIRE( pdt.channelState("channel3") == 2 );
830 REQUIRE( pdt.channelState("channel4") == 2 );
831
832 //Turn off channel2&4
833 pdt.turnChannelOff("channel3");
834 pdt.turnChannelOff("channel4");
835
836 //Verify outlet state
837 REQUIRE( pdt.outletState(0) == 0 );
838 REQUIRE( pdt.outletState(1) == 0 );
839 REQUIRE( pdt.outletState(2) == 0 );
840 REQUIRE( pdt.outletState(3) == 0 );
841
842 //Verify channel state
843 REQUIRE( pdt.channelState("channel1") == 0 );
844 REQUIRE( pdt.channelState("channel2") == 0 );
845 REQUIRE( pdt.channelState("channel3") == 0 );
846 REQUIRE( pdt.channelState("channel4") == 0 );
847
848 //Turn on channel1&3
849 pdt.turnChannelOn("channel1");
850 pdt.turnChannelOn("channel3");
851
852 //Verify outlet state
853 REQUIRE( pdt.outletState(0) == 2 );
854 REQUIRE( pdt.outletState(1) == 0 );
855 REQUIRE( pdt.outletState(2) == 2 );
856 REQUIRE( pdt.outletState(3) == 0 );
857
858 //Verify channel state
859 REQUIRE( pdt.channelState("channel1") == 2 );
860 REQUIRE( pdt.channelState("channel2") == 0 );
861 REQUIRE( pdt.channelState("channel3") == 2 );
862 REQUIRE( pdt.channelState("channel4") == 0 );
863
864 //Turn off channel1&3
865 pdt.turnChannelOff("channel1");
866 pdt.turnChannelOff("channel3");
867
868 //Verify outlet state
869 REQUIRE( pdt.outletState(0) == 0 );
870 REQUIRE( pdt.outletState(1) == 0 );
871 REQUIRE( pdt.outletState(2) == 0 );
872 REQUIRE( pdt.outletState(3) == 0 );
873
874 //Verify channel state
875 REQUIRE( pdt.channelState("channel1") == 0 );
876 REQUIRE( pdt.channelState("channel2") == 0 );
877 REQUIRE( pdt.channelState("channel3") == 0 );
878 REQUIRE( pdt.channelState("channel4") == 0 );
879
880 //Turn on channel2&4
881 pdt.turnChannelOn("channel2");
882 pdt.turnChannelOn("channel4");
883
884 //Verify outlet state
885 REQUIRE( pdt.outletState(0) == 0 );
886 REQUIRE( pdt.outletState(1) == 2 );
887 REQUIRE( pdt.outletState(2) == 0 );
888 REQUIRE( pdt.outletState(3) == 2 );
889
890 //Verify channel state
891 REQUIRE( pdt.channelState("channel1") == 0 );
892 REQUIRE( pdt.channelState("channel2") == 2 );
893 REQUIRE( pdt.channelState("channel3") == 0 );
894 REQUIRE( pdt.channelState("channel4") == 2 );
895
896 //Turn off channel2&4
897 pdt.turnChannelOff("channel2");
898 pdt.turnChannelOff("channel4");
899
900 //Verify outlet startup state
901 REQUIRE( pdt.outletState(0) == 0 );
902 REQUIRE( pdt.outletState(1) == 0 );
903 REQUIRE( pdt.outletState(2) == 0 );
904 REQUIRE( pdt.outletState(3) == 0 );
905
906 //Verify channel state at startup
907 REQUIRE( pdt.channelState("channel1") == 0 );
908 REQUIRE( pdt.channelState("channel2") == 0 );
909 REQUIRE( pdt.channelState("channel3") == 0 );
910 REQUIRE( pdt.channelState("channel4") == 0 );
911 }
912 WHEN("outlets intermediate")
913 {
914 pdt.m_outletStates[0] = 1;
915
916 //Verify outlet state
917 REQUIRE( pdt.outletState(0) == 1 );
918 REQUIRE( pdt.outletState(1) == 0 );
919 REQUIRE( pdt.outletState(2) == 0 );
920 REQUIRE( pdt.outletState(3) == 0 );
921
922 //Verify channel state
923 REQUIRE( pdt.channelState("channel1") == 1 );
924 REQUIRE( pdt.channelState("channel2") == 0 );
925 REQUIRE( pdt.channelState("channel3") == 0 );
926 REQUIRE( pdt.channelState("channel4") == 0 );
927
928 pdt.m_outletStates[0] = 0;
929
930 pdt.m_outletStates[1] = 1;
931
932 //Verify outlet state
933 REQUIRE( pdt.outletState(0) == 0 );
934 REQUIRE( pdt.outletState(1) == 1 );
935 REQUIRE( pdt.outletState(2) == 0 );
936 REQUIRE( pdt.outletState(3) == 0 );
937
938 //Verify channel state
939 REQUIRE( pdt.channelState("channel1") == 0 );
940 REQUIRE( pdt.channelState("channel2") == 1 );
941 REQUIRE( pdt.channelState("channel3") == 0 );
942 REQUIRE( pdt.channelState("channel4") == 0 );
943
944 pdt.m_outletStates[1] = 0;
945
946 pdt.m_outletStates[2] = 1;
947
948 //Verify outlet state
949 REQUIRE( pdt.outletState(0) == 0 );
950 REQUIRE( pdt.outletState(1) == 0 );
951 REQUIRE( pdt.outletState(2) == 1 );
952 REQUIRE( pdt.outletState(3) == 0 );
953
954 //Verify channel state
955 REQUIRE( pdt.channelState("channel1") == 0 );
956 REQUIRE( pdt.channelState("channel2") == 0 );
957 REQUIRE( pdt.channelState("channel3") == 1 );
958 REQUIRE( pdt.channelState("channel4") == 0 );
959
960 pdt.m_outletStates[2] = 0;
961
962 pdt.m_outletStates[3] = 1;
963
964 //Verify outlet state
965 REQUIRE( pdt.outletState(0) == 0 );
966 REQUIRE( pdt.outletState(1) == 0 );
967 REQUIRE( pdt.outletState(2) == 0 );
968 REQUIRE( pdt.outletState(3) == 1 );
969
970 //Verify channel state
971 REQUIRE( pdt.channelState("channel1") == 0 );
972 REQUIRE( pdt.channelState("channel2") == 0 );
973 REQUIRE( pdt.channelState("channel3") == 0 );
974 REQUIRE( pdt.channelState("channel4") == 1 );
975
976 pdt.m_outletStates[3] = 0;
977 }
978
979 }
980
981 GIVEN("a config file with 2 channels for 4 outlets, only outlet specified")
982 {
983 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel2" },
984 {"outlet", "outlet" },
985 {"0,1", "2,3" } );
986
987 mx::app::appConfigurator config;
988 config.readConfig("/tmp/outletController_test.conf");
989
990 outletControllerTest pdt;
991 pdt.setupConfig(config);
992 pdt.loadConfig(config);
993
994 WHEN("test device startup outlet states")
995 {
996 //Verify outlet startup state
997 REQUIRE( pdt.outletState(0) == 0 );
998 REQUIRE( pdt.outletState(1) == 0 );
999 REQUIRE( pdt.outletState(2) == 0 );
1000 REQUIRE( pdt.outletState(3) == 0 );
1001
1002 //Verify channel state at startup
1003 REQUIRE( pdt.channelState("channel1") == 0 );
1004 REQUIRE( pdt.channelState("channel2") == 0 );
1005 }
1006 WHEN("operating a single channel")
1007 {
1008 //Turn on channel1
1009 pdt.turnChannelOn("channel1");
1010
1011 //Verify outlet state
1012 REQUIRE( pdt.outletState(0) == 2 );
1013 REQUIRE( pdt.outletState(1) == 2 );
1014 REQUIRE( pdt.outletState(2) == 0 );
1015 REQUIRE( pdt.outletState(3) == 0 );
1016
1017 //verify outlet order
1018 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1019
1020 //Verify channel state
1021 REQUIRE( pdt.channelState("channel1") == 2 );
1022 REQUIRE( pdt.channelState("channel2") == 0 );
1023
1024 //Turn off channel1
1025 pdt.turnChannelOff("channel1");
1026
1027 //Verify outlet state
1028 REQUIRE( pdt.outletState(0) == 0 );
1029 REQUIRE( pdt.outletState(1) == 0 );
1030 REQUIRE( pdt.outletState(2) == 0 );
1031 REQUIRE( pdt.outletState(3) == 0 );
1032
1033 //Verify channel state
1034 REQUIRE( pdt.channelState("channel1") == 0 );
1035 REQUIRE( pdt.channelState("channel2") == 0 );
1036
1037 //Turn on channel2
1038 pdt.turnChannelOn("channel2");
1039
1040 //Verify outlet state
1041 REQUIRE( pdt.outletState(0) == 0 );
1042 REQUIRE( pdt.outletState(1) == 0 );
1043 REQUIRE( pdt.outletState(2) == 2 );
1044 REQUIRE( pdt.outletState(3) == 2 );
1045
1046 //verify outlet order
1047 REQUIRE( pdt.m_timestamps[3] > pdt.m_timestamps[2]);
1048
1049 //Verify channel state
1050 REQUIRE( pdt.channelState("channel1") == 0 );
1051 REQUIRE( pdt.channelState("channel2") == 2 );
1052
1053 //Turn off channel2
1054 pdt.turnChannelOff("channel2");
1055
1056 //Verify outlet state
1057 REQUIRE( pdt.outletState(0) == 0 );
1058 REQUIRE( pdt.outletState(1) == 0 );
1059 REQUIRE( pdt.outletState(2) == 0 );
1060 REQUIRE( pdt.outletState(3) == 0 );
1061
1062 //Verify channel state
1063 REQUIRE( pdt.channelState("channel1") == 0 );
1064 REQUIRE( pdt.channelState("channel2") == 0 );
1065 }
1066 WHEN("operating two channels")
1067 {
1068 //Turn on channels
1069 pdt.turnChannelOn("channel1");
1070 pdt.turnChannelOn("channel2");
1071
1072 //Verify outlet state
1073 REQUIRE( pdt.outletState(0) == 2 );
1074 REQUIRE( pdt.outletState(1) == 2 );
1075 REQUIRE( pdt.outletState(2) == 2 );
1076 REQUIRE( pdt.outletState(3) == 2 );
1077
1078 //Verify channel state
1079 REQUIRE( pdt.channelState("channel1") == 2 );
1080 REQUIRE( pdt.channelState("channel2") == 2 );
1081
1082 //Turn off channel1&2
1083 pdt.turnChannelOff("channel1");
1084 pdt.turnChannelOff("channel2");
1085
1086 //Verify outlet state
1087 REQUIRE( pdt.outletState(0) == 0 );
1088 REQUIRE( pdt.outletState(1) == 0 );
1089 REQUIRE( pdt.outletState(2) == 0 );
1090 REQUIRE( pdt.outletState(3) == 0 );
1091
1092 //Verify channel state
1093 REQUIRE( pdt.channelState("channel1") == 0 );
1094 REQUIRE( pdt.channelState("channel2") == 0 );
1095
1096 }
1097 WHEN("outlets intermediate")
1098 {
1099 pdt.m_outletStates[0] = 2;
1100
1101 //Verify outlet state
1102 REQUIRE( pdt.outletState(0) == 2 );
1103 REQUIRE( pdt.outletState(1) == 0 );
1104 REQUIRE( pdt.outletState(2) == 0 );
1105 REQUIRE( pdt.outletState(3) == 0 );
1106
1107 REQUIRE( pdt.channelState("channel1") == 1);
1108 REQUIRE( pdt.channelState("channel2") == 0);
1109
1110 pdt.turnChannelOn("channel2");
1111
1112 //Verify outlet state
1113 REQUIRE( pdt.outletState(0) == 2 );
1114 REQUIRE( pdt.outletState(1) == 0 );
1115 REQUIRE( pdt.outletState(2) == 2 );
1116 REQUIRE( pdt.outletState(3) == 2 );
1117
1118 REQUIRE( pdt.channelState("channel1") == 1);
1119 REQUIRE( pdt.channelState("channel2") == 2);
1120
1121 pdt.m_outletStates[0] = 0;
1122
1123 REQUIRE( pdt.channelState("channel1") == 0);
1124 REQUIRE( pdt.channelState("channel2") == 2);
1125
1126 pdt.turnChannelOff("channel2");
1127
1128 //Verify outlet state
1129 REQUIRE( pdt.outletState(0) == 0 );
1130 REQUIRE( pdt.outletState(1) == 0 );
1131 REQUIRE( pdt.outletState(2) == 0 );
1132 REQUIRE( pdt.outletState(3) == 0 );
1133
1134 REQUIRE( pdt.channelState("channel1") == 0);
1135 REQUIRE( pdt.channelState("channel2") == 0);
1136
1137
1138 pdt.m_outletStates[2] = 1;
1139
1140 //Verify outlet state
1141 REQUIRE( pdt.outletState(0) == 0 );
1142 REQUIRE( pdt.outletState(1) == 0 );
1143 REQUIRE( pdt.outletState(2) == 1 );
1144 REQUIRE( pdt.outletState(3) == 0 );
1145
1146 REQUIRE( pdt.channelState("channel1") == 0);
1147 REQUIRE( pdt.channelState("channel2") == 1);
1148
1149 pdt.turnChannelOn("channel1");
1150
1151 //Verify outlet state
1152 REQUIRE( pdt.outletState(0) == 2 );
1153 REQUIRE( pdt.outletState(1) == 2 );
1154 REQUIRE( pdt.outletState(2) == 1 );
1155 REQUIRE( pdt.outletState(3) == 0 );
1156
1157 REQUIRE( pdt.channelState("channel1") == 2);
1158 REQUIRE( pdt.channelState("channel2") == 1);
1159
1160 pdt.m_outletStates[2] = 0;
1161
1162 REQUIRE( pdt.channelState("channel1") == 2);
1163 REQUIRE( pdt.channelState("channel2") == 0);
1164
1165 pdt.turnChannelOff("channel1");
1166
1167 //Verify outlet state
1168 REQUIRE( pdt.outletState(0) == 0 );
1169 REQUIRE( pdt.outletState(1) == 0 );
1170 REQUIRE( pdt.outletState(2) == 0 );
1171 REQUIRE( pdt.outletState(3) == 0 );
1172
1173 REQUIRE( pdt.channelState("channel1") == 0);
1174 REQUIRE( pdt.channelState("channel2") == 0);
1175 }
1176 }
1177 GIVEN("a config file with 2 channels for 4 outlets, onOrder specified")
1178 {
1179 //Here we are just testing order, so we don't need to verify outlet state anymore
1180
1181 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel2", "channel2" },
1182 {"outlet", "onOrder", "outlet", "onOrder" },
1183 {"0,1", "0,1", "2,3", "0,1" } );
1184
1185 mx::app::appConfigurator config;
1186 config.readConfig("/tmp/outletController_test.conf");
1187
1188 outletControllerTest pdt;
1189 pdt.setupConfig(config);
1190 pdt.loadConfig(config);
1191
1192 WHEN("test device startup channel states")
1193 {
1194 //Verify channel state at startup
1195 REQUIRE( pdt.channelState("channel1") == 0 );
1196 REQUIRE( pdt.channelState("channel2") == 0 );
1197 }
1198 WHEN("operating a single channel")
1199 {
1200 //Turn on channel1
1201 pdt.turnChannelOn("channel1");
1202
1203 //verify outlet order
1204 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1205
1206 //Verify channel state
1207 REQUIRE( pdt.channelState("channel1") == 2 );
1208 REQUIRE( pdt.channelState("channel2") == 0 );
1209
1210 //Turn off channel1
1211 pdt.turnChannelOff("channel1");
1212
1213 //Verify channel state
1214 REQUIRE( pdt.channelState("channel1") == 0 );
1215 REQUIRE( pdt.channelState("channel2") == 0 );
1216
1217 //Turn on channel2
1218 pdt.turnChannelOn("channel2");
1219
1220 //verify outlet order
1221 REQUIRE( pdt.m_timestamps[3] > pdt.m_timestamps[2]);
1222
1223 //Verify channel state
1224 REQUIRE( pdt.channelState("channel1") == 0 );
1225 REQUIRE( pdt.channelState("channel2") == 2 );
1226
1227 //Turn off channel2
1228 pdt.turnChannelOff("channel2");
1229
1230 //Verify channel state
1231 REQUIRE( pdt.channelState("channel1") == 0 );
1232 REQUIRE( pdt.channelState("channel2") == 0 );
1233 }
1234 }
1235 GIVEN("a config file with 2 channels for 4 outlets, onOrder reversed")
1236 {
1237 //Here we are just testing order, so we don't need to verify outlet state anymore
1238
1239 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel2", "channel2" },
1240 {"outlet", "onOrder", "outlet", "onOrder" },
1241 {"0,1", "1,0", "2,3", "1,0" } );
1242
1243 mx::app::appConfigurator config;
1244 config.readConfig("/tmp/outletController_test.conf");
1245
1246 outletControllerTest pdt;
1247 pdt.setupConfig(config);
1248 pdt.loadConfig(config);
1249
1250 WHEN("test device startup channel states")
1251 {
1252 //Verify channel state at startup
1253 REQUIRE( pdt.channelState("channel1") == 0 );
1254 REQUIRE( pdt.channelState("channel2") == 0 );
1255 }
1256 WHEN("operating a single channel")
1257 {
1258 //Turn on channel1
1259 pdt.turnChannelOn("channel1");
1260
1261 //verify outlet order
1262 REQUIRE( pdt.m_timestamps[0] > pdt.m_timestamps[1]);
1263
1264 //Verify channel state
1265 REQUIRE( pdt.channelState("channel1") == 2 );
1266 REQUIRE( pdt.channelState("channel2") == 0 );
1267
1268 //Turn off channel1
1269 pdt.turnChannelOff("channel1");
1270
1271 //Verify channel state
1272 REQUIRE( pdt.channelState("channel1") == 0 );
1273 REQUIRE( pdt.channelState("channel2") == 0 );
1274
1275 //Turn on channel2
1276 pdt.turnChannelOn("channel2");
1277
1278 //verify outlet order
1279 REQUIRE( pdt.m_timestamps[2] > pdt.m_timestamps[3]);
1280
1281 //Verify channel state
1282 REQUIRE( pdt.channelState("channel1") == 0 );
1283 REQUIRE( pdt.channelState("channel2") == 2 );
1284
1285 //Turn off channel2
1286 pdt.turnChannelOff("channel2");
1287
1288 //Verify channel state
1289 REQUIRE( pdt.channelState("channel1") == 0 );
1290 REQUIRE( pdt.channelState("channel2") == 0 );
1291 }
1292 }
1293 GIVEN("a config file with 2 channels for 4 outlets, onOrder and offOrder specified, the same")
1294 {
1295 //Here we are just testing order, so we don't need to verify outlet state anymore
1296
1297 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel2", "channel2", "channel2" },
1298 {"outlet", "onOrder", "offOrder", "outlet", "onOrder", "offOrder" },
1299 {"0,1", "0,1", "0,1", "2,3", "0,1" , "0,1" } );
1300
1301 mx::app::appConfigurator config;
1302 config.readConfig("/tmp/outletController_test.conf");
1303
1304 outletControllerTest pdt;
1305 pdt.setupConfig(config);
1306 pdt.loadConfig(config);
1307
1308 WHEN("test device startup channel states")
1309 {
1310 //Verify channel state at startup
1311 REQUIRE( pdt.channelState("channel1") == 0 );
1312 REQUIRE( pdt.channelState("channel2") == 0 );
1313 }
1314 WHEN("operating a single channel")
1315 {
1316 //Turn on channel1
1317 pdt.turnChannelOn("channel1");
1318
1319 //verify outlet order
1320 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1321
1322 //Verify channel state
1323 REQUIRE( pdt.channelState("channel1") == 2 );
1324 REQUIRE( pdt.channelState("channel2") == 0 );
1325
1326 //Turn off channel1
1327 pdt.turnChannelOff("channel1");
1328
1329 //verify outlet order
1330 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1331
1332 //Verify channel state
1333 REQUIRE( pdt.channelState("channel1") == 0 );
1334 REQUIRE( pdt.channelState("channel2") == 0 );
1335
1336 //Turn on channel2
1337 pdt.turnChannelOn("channel2");
1338
1339 //verify outlet order
1340 REQUIRE( pdt.m_timestamps[3] > pdt.m_timestamps[2]);
1341
1342 //Verify channel state
1343 REQUIRE( pdt.channelState("channel1") == 0 );
1344 REQUIRE( pdt.channelState("channel2") == 2 );
1345
1346 //Turn off channel2
1347 pdt.turnChannelOff("channel2");
1348
1349 REQUIRE( pdt.m_timestamps[3] >= pdt.m_timestamps[2]);
1350
1351 //Verify channel state
1352 REQUIRE( pdt.channelState("channel1") == 0 );
1353 REQUIRE( pdt.channelState("channel2") == 0 );
1354 }
1355 }
1356 GIVEN("a config file with 2 channels for 4 outlets, onOrder and offOrder specified, different")
1357 {
1358 //Here we are just testing order, so we don't need to verify outlet state anymore
1359
1360 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel2", "channel2", "channel2" },
1361 {"outlet", "onOrder", "offOrder", "outlet", "onOrder", "offOrder" },
1362 {"0,1", "0,1", "1,0", "2,3", "0,1" , "1,0" } );
1363
1364 mx::app::appConfigurator config;
1365 config.readConfig("/tmp/outletController_test.conf");
1366
1367 outletControllerTest pdt;
1368 pdt.setupConfig(config);
1369 pdt.loadConfig(config);
1370
1371 WHEN("test device startup channel states")
1372 {
1373 //Verify channel state at startup
1374 REQUIRE( pdt.channelState("channel1") == 0 );
1375 REQUIRE( pdt.channelState("channel2") == 0 );
1376 }
1377 WHEN("operating a single channel")
1378 {
1379 //Turn on channel1
1380 pdt.turnChannelOn("channel1");
1381
1382 //verify outlet order
1383 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1384
1385 //Verify channel state
1386 REQUIRE( pdt.channelState("channel1") == 2 );
1387 REQUIRE( pdt.channelState("channel2") == 0 );
1388
1389
1390 //Turn off channel1
1391 pdt.turnChannelOff("channel1");
1392
1393 //verify outlet order
1394 REQUIRE( pdt.m_timestamps[0] > pdt.m_timestamps[1]);
1395
1396 //Verify channel state
1397 REQUIRE( pdt.channelState("channel1") == 0 );
1398 REQUIRE( pdt.channelState("channel2") == 0 );
1399
1400 //Turn on channel2
1401 pdt.turnChannelOn("channel2");
1402
1403
1404 //verify outlet order
1405 REQUIRE( pdt.m_timestamps[3] > pdt.m_timestamps[2]);
1406
1407 //Verify channel state
1408 REQUIRE( pdt.channelState("channel1") == 0 );
1409 REQUIRE( pdt.channelState("channel2") == 2 );
1410
1411 //Turn off channel2
1412 pdt.turnChannelOff("channel2");
1413
1414 //verify outlet order
1415 REQUIRE( pdt.m_timestamps[2] > pdt.m_timestamps[3]);
1416
1417 //Verify channel state
1418 REQUIRE( pdt.channelState("channel1") == 0 );
1419 REQUIRE( pdt.channelState("channel2") == 0 );
1420 }
1421 }
1422 GIVEN("a config file with 2 channels for 4 outlets, onOrder and offOrder specified, different, reversed")
1423 {
1424 //Here we are just testing order, so we don't need to verify outlet state anymore
1425
1426 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel2", "channel2", "channel2" },
1427 {"outlet", "onOrder", "offOrder", "outlet", "onOrder", "offOrder" },
1428 {"0,1", "1,0", "0,1", "2,3", "1,0" , "0,1" } );
1429
1430 mx::app::appConfigurator config;
1431 config.readConfig("/tmp/outletController_test.conf");
1432
1433 outletControllerTest pdt;
1434 pdt.setupConfig(config);
1435 pdt.loadConfig(config);
1436
1437 WHEN("test device startup channel states")
1438 {
1439 //Verify channel state at startup
1440 REQUIRE( pdt.channelState("channel1") == 0 );
1441 REQUIRE( pdt.channelState("channel2") == 0 );
1442 }
1443 WHEN("operating a single channel")
1444 {
1445 //Turn on channel1
1446 pdt.turnChannelOn("channel1");
1447
1448 //verify outlet order
1449 REQUIRE( pdt.m_timestamps[0] > pdt.m_timestamps[1]);
1450
1451 //Verify channel state
1452 REQUIRE( pdt.channelState("channel1") == 2 );
1453 REQUIRE( pdt.channelState("channel2") == 0 );
1454
1455
1456 //Turn off channel1
1457 pdt.turnChannelOff("channel1");
1458
1459 //verify outlet order
1460 REQUIRE( pdt.m_timestamps[1] > pdt.m_timestamps[0]);
1461
1462 //Verify channel state
1463 REQUIRE( pdt.channelState("channel1") == 0 );
1464 REQUIRE( pdt.channelState("channel2") == 0 );
1465
1466 //Turn on channel2
1467 pdt.turnChannelOn("channel2");
1468
1469
1470 //verify outlet order
1471 REQUIRE( pdt.m_timestamps[2] > pdt.m_timestamps[3]);
1472
1473 //Verify channel state
1474 REQUIRE( pdt.channelState("channel1") == 0 );
1475 REQUIRE( pdt.channelState("channel2") == 2 );
1476
1477 //Turn off channel2
1478 pdt.turnChannelOff("channel2");
1479
1480 //verify outlet order
1481 REQUIRE( pdt.m_timestamps[3] > pdt.m_timestamps[2]);
1482
1483 //Verify channel state
1484 REQUIRE( pdt.channelState("channel1") == 0 );
1485 REQUIRE( pdt.channelState("channel2") == 0 );
1486 }
1487 }
1488}
1489
1490SCENARIO( "outletController Operation with delays", "[outletController]" )
1491{
1492 std::cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
1493 std::cout << "[outletController] Testing delays ... \n";
1494 GIVEN("a config file with 2 channels for 4 outlets, onDelays specified")
1495 {
1496 //Here we are just testing delays, so we don't need to verify outlet state anymore
1497
1498 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel2", "channel2" },
1499 {"outlet", "onDelays", "outlet", "onDelays" },
1500 {"0,1", "0,350", "2,3", "0,150" } );
1501
1502 mx::app::appConfigurator config;
1503 config.readConfig("/tmp/outletController_test.conf");
1504
1505 outletControllerTest pdt;
1506 pdt.setupConfig(config);
1507 pdt.loadConfig(config);
1508
1509 WHEN("operating a single channel")
1510 {
1511 //Turn on channel1
1512 pdt.turnChannelOn("channel1");
1513
1514 //verify outlet delay
1515 REQUIRE( pdt.m_timestamps[1] >= Approx(pdt.m_timestamps[0]+0.350));
1516 std::cout << "Ch1 On Delay was " << (pdt.m_timestamps[1] - pdt.m_timestamps[0])*1000 << " msec, expected 350.\n";
1517
1518 //Verify channel state
1519 REQUIRE( pdt.channelState("channel1") == 2 );
1520 REQUIRE( pdt.channelState("channel2") == 0 );
1521
1522 //Turn off channel1
1523 pdt.turnChannelOff("channel1");
1524 std::cout << "Ch1 Off Delay was " << (pdt.m_timestamps[1] - pdt.m_timestamps[0])*1000 << " msec, expected ~0.\n";
1525
1526 //Verify channel state
1527 REQUIRE( pdt.channelState("channel1") == 0 );
1528 REQUIRE( pdt.channelState("channel2") == 0 );
1529
1530 //Turn on channel2
1531 pdt.turnChannelOn("channel2");
1532
1533
1534 //verify outlet delay
1535 REQUIRE( pdt.m_timestamps[3] >= Approx(pdt.m_timestamps[2]+0.150));
1536 std::cout << "Ch2 On Delay was " << (pdt.m_timestamps[3] - pdt.m_timestamps[2])*1000 << " msec, expected 150.\n";
1537
1538 //Verify channel state
1539 REQUIRE( pdt.channelState("channel1") == 0 );
1540 REQUIRE( pdt.channelState("channel2") == 2 );
1541
1542 //Turn off channel2
1543 pdt.turnChannelOff("channel2");
1544 std::cout << "Ch2 Off Delay was " << (pdt.m_timestamps[3] - pdt.m_timestamps[2])*1000 << " msec, expected ~0.\n";
1545
1546 //Verify channel state
1547 REQUIRE( pdt.channelState("channel1") == 0 );
1548 REQUIRE( pdt.channelState("channel2") == 0 );
1549 }
1550 }
1551 GIVEN("a config file with 2 channels for 4 outlets, offDelays specified")
1552 {
1553 //Here we are just testing delays, so we don't need to verify outlet state anymore
1554
1555 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel2", "channel2" },
1556 {"outlet", "offDelays", "outlet", "offDelays" },
1557 {"0,1", "0,550", "2,3", "0,750" } );
1558
1559 mx::app::appConfigurator config;
1560 config.readConfig("/tmp/outletController_test.conf");
1561
1562 outletControllerTest pdt;
1563 pdt.setupConfig(config);
1564 pdt.loadConfig(config);
1565
1566 WHEN("operating a single channel")
1567 {
1568 //Turn on channel1
1569 pdt.turnChannelOn("channel1");
1570
1571 std::cout << "Ch1 On Delay was " << (pdt.m_timestamps[1] - pdt.m_timestamps[0])*1000 << " msec, expected ~0.\n";
1572
1573 //Verify channel state
1574 REQUIRE( pdt.channelState("channel1") == 2 );
1575 REQUIRE( pdt.channelState("channel2") == 0 );
1576
1577 //Turn off channel1
1578 pdt.turnChannelOff("channel1");
1579
1580 REQUIRE( pdt.m_timestamps[1] >= Approx(pdt.m_timestamps[0]+0.550));
1581 std::cout << "Ch1 Off Delay was " << (pdt.m_timestamps[1] - pdt.m_timestamps[0])*1000 << " msec, expected 550.\n";
1582
1583
1584 //Verify channel state
1585 REQUIRE( pdt.channelState("channel1") == 0 );
1586 REQUIRE( pdt.channelState("channel2") == 0 );
1587
1588 //Turn on channel2
1589 pdt.turnChannelOn("channel2");
1590
1591
1592 //verify outlet delay
1593 std::cout << "Ch1 On Delay was " << (pdt.m_timestamps[3] - pdt.m_timestamps[2])*1000 << " msec, expected ~0.\n";
1594
1595 //Verify channel state
1596 REQUIRE( pdt.channelState("channel1") == 0 );
1597 REQUIRE( pdt.channelState("channel2") == 2 );
1598
1599 //Turn off channel2
1600 pdt.turnChannelOff("channel2");
1601 REQUIRE( pdt.m_timestamps[3] >= Approx(pdt.m_timestamps[2]+0.750));
1602 std::cout << "Ch1 On Delay was " << (pdt.m_timestamps[3] - pdt.m_timestamps[2])*1000 << " msec, expected 750.\n";
1603
1604 //Verify channel state
1605 REQUIRE( pdt.channelState("channel1") == 0 );
1606 REQUIRE( pdt.channelState("channel2") == 0 );
1607 }
1608 }
1609 GIVEN("a config file with 2 channels for 4 outlets, onDelays and offDelays specified, off order reversed")
1610 {
1611 //Here we are just testing delays, so we don't need to verify outlet state anymore
1612
1613 mx::app::writeConfigFile( "/tmp/outletController_test.conf", {"channel1", "channel1", "channel1", "channel1", "channel1", "channel2", "channel2", "channel2", "channel2", "channel2" },
1614 {"outlet", "onOrder", "onDelays", "offOrder", "offDelays", "outlet", "onOrder", "onDelays", "offOrder", "offDelays" },
1615 {"0,1", "0,1", "0,350", "1,0", "0,450", "2,3", "0,1", "0,150", "1,0", "0,75" } );
1616
1617 mx::app::appConfigurator config;
1618 config.readConfig("/tmp/outletController_test.conf");
1619
1620 outletControllerTest pdt;
1621 pdt.setupConfig(config);
1622 pdt.loadConfig(config);
1623
1624 WHEN("operating a single channel")
1625 {
1626 //Turn on channel1
1627 pdt.turnChannelOn("channel1");
1628
1629 //verify outlet delay
1630 REQUIRE( pdt.m_timestamps[1] >= Approx(pdt.m_timestamps[0]+0.350));
1631 std::cout << "Ch1 On Delay was " << (pdt.m_timestamps[1] - pdt.m_timestamps[0])*1000 << " msec, expected 350.\n";
1632
1633 //Verify channel state
1634 REQUIRE( pdt.channelState("channel1") == 2 );
1635 REQUIRE( pdt.channelState("channel2") == 0 );
1636
1637 //Turn off channel1
1638 pdt.turnChannelOff("channel1");
1639 REQUIRE( pdt.m_timestamps[0] >= Approx(pdt.m_timestamps[1]+0.450));
1640 std::cout << "Ch1 Off Delay was " << (pdt.m_timestamps[0] - pdt.m_timestamps[1])*1000 << " msec, expected 450.\n";
1641
1642 //Verify channel state
1643 REQUIRE( pdt.channelState("channel1") == 0 );
1644 REQUIRE( pdt.channelState("channel2") == 0 );
1645
1646 //Turn on channel2
1647 pdt.turnChannelOn("channel2");
1648
1649
1650 //verify outlet delay
1651 REQUIRE( pdt.m_timestamps[3] >= Approx(pdt.m_timestamps[2]+0.150));
1652 std::cout << "Ch2 On Delay was " << (pdt.m_timestamps[3] - pdt.m_timestamps[2])*1000 << " msec, expected 150.\n";
1653
1654 //Verify channel state
1655 REQUIRE( pdt.channelState("channel1") == 0 );
1656 REQUIRE( pdt.channelState("channel2") == 2 );
1657
1658 //Turn off channel2
1659 pdt.turnChannelOff("channel2");
1660 REQUIRE( pdt.m_timestamps[2] >= Approx(pdt.m_timestamps[3]+0.075));
1661 std::cout << "Ch2 Off Delay was " << (pdt.m_timestamps[2] - pdt.m_timestamps[3])*1000 << " msec, expected 75.\n";
1662
1663 //Verify channel state
1664 REQUIRE( pdt.channelState("channel1") == 0 );
1665 REQUIRE( pdt.channelState("channel2") == 0 );
1666 }
1667 }
1668 std::cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
1669}
1670
1671} //namespace outletController_tests
outletController_tests::SCENARIO
SCENARIO("outletController Configuration", "[outletController]")
outletController Configuration
Definition outletController_test.cpp:60
outletController_tests
Definition outletController_test.cpp:14
MagAOX::app::dev::outletController
A generic outlet controller.
Definition outletController.hpp:69
MagAOX::app::dev::outletController::outletState
int outletState(int outletNum)
Get the currently stored outlet state, without updating from device.
Definition outletController.hpp:424
MagAOX::app::dev::outletController::channelOffDelays
std::vector< unsigned > channelOffDelays(const std::string &channel)
Get the vector of outlet off delays for a channel.
Definition outletController.hpp:472
MagAOX::app::dev::outletController::turnChannelOn
int turnChannelOn(const std::string &channel)
Turn a channel on.
Definition outletController.hpp:491
MagAOX::app::dev::outletController::channelState
int channelState(const std::string &channel)
Get the state of a channel.
Definition outletController.hpp:478
MagAOX::app::dev::outletController::loadConfig
int loadConfig(mx::app::appConfigurator &config)
Load the [channel] sections from an application configurator.
Definition outletController.hpp:309
MagAOX::app::dev::outletController::numChannels
size_t numChannels()
Get the number of channels.
Definition outletController.hpp:442
MagAOX::app::dev::outletController::channelOnOrder
std::vector< size_t > channelOnOrder(const std::string &channel)
Get the vector of outlet on orders for a channel.
Definition outletController.hpp:454
MagAOX::app::dev::outletController::setupConfig
int setupConfig(mx::app::appConfigurator &config)
Setup an application configurator for an outletController.
Definition outletController.hpp:301
MagAOX::app::dev::outletController::turnChannelOff
int turnChannelOff(const std::string &channel)
Turn a channel off.
Definition outletController.hpp:564
MagAOX::app::dev::outletController::channelOutlets
std::vector< size_t > channelOutlets(const std::string &channel)
Get the vector of outlet indices for a channel.
Definition outletController.hpp:448
MagAOX::app::dev::outletController< outletControllerTest >::setNumberOfOutlets
int setNumberOfOutlets(int numOuts)
Sets the number of outlets. This should be called by the derived class constructor.
Definition outletController.hpp:417
MagAOX::app::dev::outletController::channelOnDelays
std::vector< unsigned > channelOnDelays(const std::string &channel)
Get the vector of outlet on delays for a channel.
Definition outletController.hpp:466
MagAOX::app::dev::outletController::channelOffOrder
std::vector< size_t > channelOffOrder(const std::string &channel)
Get the vector of outlet off orders for a channel.
Definition outletController.hpp:460
MagAOX::app::dev::outletController< outletControllerTest >::m_outletStates
std::vector< int > m_outletStates
The current states of each outlet. These MUST be updated by derived classes in the overridden updated...
Definition outletController.hpp:72
outletController_tests::outletControllerTest
Definition outletController_test.cpp:17
outletController_tests::outletControllerTest::m_timestamps
std::vector< double > m_timestamps
Definition outletController_test.cpp:18
outletController_tests::outletControllerTest::outletControllerTest
outletControllerTest()
Definition outletController_test.cpp:20
outletController_tests::outletControllerTest::turnOutletOff
virtual int turnOutletOff(int outletNum)
Turn an outlet off.
Definition outletController_test.cpp:45
outletController_tests::outletControllerTest::updateOutletState
virtual int updateOutletState(int outletNum)
Get the state of the outlet from the device.
Definition outletController_test.cpp:30
outletController_tests::outletControllerTest::turnOutletOn
virtual int turnOutletOn(int outletNum)
Turn an outlet on.
Definition outletController_test.cpp:36