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