API
 
Loading...
Searching...
No Matches
indiCompRules_test.cpp
Go to the documentation of this file.
1#if(__cplusplus == 201703L)
2
3#include "../../../tests/catch2/catch.hpp"
4
5#include "../indiCompRules.hpp"
6
7
8SCENARIO( "basic INDI Property Element-value rules", "[stateRuleEngine::rules]" )
9{
10 GIVEN("string comparison")
11 {
12 pcf::IndiProperty prop1(pcf::IndiProperty::Text);
13 prop1.setDevice("ruleTest");
14 prop1.setName("prop1");
15 prop1.setPerm(pcf::IndiProperty::ReadWrite);
16 prop1.setState(pcf::IndiProperty::Idle);
17 prop1.add(pcf::IndiElement("current"));
18 prop1["current"] = "test";
19 prop1.add(pcf::IndiElement("target"));
20 prop1["target"] = "tset";
21
22 txtValRule rule1;
23
24 rule1.property(&prop1);
25 rule1.element("current");
26
27 WHEN("string should be equal and is")
28 {
29 rule1.comparison(ruleComparison::Eq);
30 rule1.target("test");
31
32 REQUIRE(rule1.value() == true);
33 }
34
35 WHEN("string should be equal and is not")
36 {
37 rule1.comparison(ruleComparison::Eq);
38 rule1.target("tset");
39
40 REQUIRE(rule1.value() == false);
41 }
42
43 WHEN("string should be not equal and is not equal")
44 {
45 rule1.comparison(ruleComparison::Neq);
46 rule1.target("tset");
47
48 REQUIRE(rule1.value() == true);
49 }
50
51 WHEN("string should be not equal and is equal")
52 {
53 rule1.comparison(ruleComparison::Neq);
54 rule1.target("test");
55
56 REQUIRE(rule1.value() == false);
57 }
58 }
59
60 GIVEN("float comparison")
61 {
62 pcf::IndiProperty prop1(pcf::IndiProperty::Number);
63 prop1.setDevice("ruleTest");
64 prop1.setName("prop1");
65 prop1.setPerm(pcf::IndiProperty::ReadWrite);
66 prop1.setState(pcf::IndiProperty::Idle);
67 prop1.add(pcf::IndiElement("current"));
68 prop1["current"].setValue(2.314159);
69 prop1.add(pcf::IndiElement("target"));
70 prop1["target"].setValue(1.567202);
71
72 numValRule rule1;
73
74 rule1.property(&prop1);
75 rule1.element("current");
76
77 WHEN("float should be equal and is")
78 {
79 rule1.comparison(ruleComparison::Eq);
80 rule1.target(2.314159);
81 REQUIRE(rule1.value() == true);
82 }
83
84 WHEN("float should be equal and aren't")
85 {
86 rule1.comparison(ruleComparison::Eq);
87 rule1.target(3.314159);
88 REQUIRE(rule1.value() == false);
89 }
90
91 WHEN("float should be equal and aren't within tol")
92 {
93 rule1.comparison(ruleComparison::Eq);
94 rule1.target(2.314158);
95
96 REQUIRE(rule1.value() == false);
97 }
98
99 WHEN("float should be equal and are within tol")
100 {
101 rule1.comparison(ruleComparison::Eq);
102 rule1.target(2.314158);
103 rule1.tol(1e-4);
104
105 REQUIRE(rule1.value() == true);
106 }
107
108 WHEN("float should be less than and is")
109 {
110 rule1.comparison(ruleComparison::Lt);
111 rule1.target(4.67892);
112 REQUIRE(rule1.value() == true);
113 }
114
115 WHEN("float should be less than but is not")
116 {
117 rule1.comparison(ruleComparison::Lt);
118 rule1.target(1.67892);
119 REQUIRE(rule1.value() == false);
120 }
121
122 WHEN("float should be greater than and is")
123 {
124 rule1.comparison(ruleComparison::Gt);
125 rule1.target(1.2);
126 REQUIRE(rule1.value() == true);
127 }
128
129 WHEN("float should be greater than but is not")
130 {
131 rule1.comparison(ruleComparison::Gt);
132 rule1.target(7.9);
133 REQUIRE(rule1.value() == false);
134 }
135
136 WHEN("float should be less-or-equal than and is less than")
137 {
138 rule1.comparison(ruleComparison::LtEq);
139 rule1.target(4.67892);
140 REQUIRE(rule1.value() == true);
141 }
142
143 WHEN("float should be less-or-equal than and is equal")
144 {
145 rule1.comparison(ruleComparison::LtEq);
146 rule1.target(2.314159);
147 REQUIRE(rule1.value() == true);
148 }
149
150 WHEN("float should be less-or-equal than but is not")
151 {
152 rule1.comparison(ruleComparison::LtEq);
153 rule1.target(0.789);
154 REQUIRE(rule1.value() == false);
155 }
156
157 WHEN("float should be greater-or-equal than and is greater than")
158 {
159 rule1.comparison(ruleComparison::GtEq);
160 rule1.target(2.05);
161 REQUIRE(rule1.value() == true);
162 }
163
164 WHEN("float should be greater-or-equal than and is equal")
165 {
166 rule1.comparison(ruleComparison::GtEq);
167 rule1.target(2.314159);
168 REQUIRE(rule1.value() == true);
169 }
170
171 WHEN("float should be greater-or-equal than but is not")
172 {
173 rule1.comparison(ruleComparison::GtEq);
174 rule1.target(3.789);
175 REQUIRE(rule1.value() == false);
176 }
177 }
178
179 GIVEN("switch comparison")
180 {
181 pcf::IndiProperty prop1(pcf::IndiProperty::Switch);
182 prop1.setDevice("ruleTest");
183 prop1.setName("prop1");
184 prop1.setPerm(pcf::IndiProperty::ReadWrite);
185 prop1.setState(pcf::IndiProperty::Idle);
186 prop1.add(pcf::IndiElement("toggle"));
187
188 swValRule rule1;
189
190 rule1.property(&prop1);
191 rule1.element("toggle");
192
193 WHEN("switch is on and should be equal and is")
194 {
195 prop1["toggle"].setSwitchState(pcf::IndiElement::On);
196 rule1.target("On");
197 rule1.comparison(ruleComparison::Eq);
198 REQUIRE(rule1.value() == true);
199 }
200
201 WHEN("switch is on and should be equal but isn't")
202 {
203 prop1["toggle"].setSwitchState(pcf::IndiElement::On);
204 rule1.target("Off");
205 rule1.comparison(ruleComparison::Eq);
206 REQUIRE(rule1.value() == false);
207 }
208
209 WHEN("switch is on and should be not equal and is not")
210 {
211 prop1["toggle"].setSwitchState(pcf::IndiElement::On);
212 rule1.target("Off");
213 rule1.comparison(ruleComparison::Neq);
214 REQUIRE(rule1.value() == true);
215 }
216
217 WHEN("switch is on and should be not equal but is")
218 {
219 prop1["toggle"].setSwitchState(pcf::IndiElement::On);
220 rule1.target("On");
221 rule1.comparison(ruleComparison::Neq);
222 REQUIRE(rule1.value() == false);
223 }
224
225 WHEN("switch is off and should be equal and is")
226 {
227 prop1["toggle"].setSwitchState(pcf::IndiElement::Off);
228 rule1.target("Off");
229 rule1.comparison(ruleComparison::Eq);
230 REQUIRE(rule1.value() == true);
231 }
232
233 WHEN("switch is off and should be equal but isn't")
234 {
235 prop1["toggle"].setSwitchState(pcf::IndiElement::Off);
236 rule1.target("On");
237 rule1.comparison(ruleComparison::Eq);
238 REQUIRE(rule1.value() == false);
239 }
240
241 WHEN("switch is off and should be not equal and is not")
242 {
243 prop1["toggle"].setSwitchState(pcf::IndiElement::Off);
244 rule1.target("On");
245 rule1.comparison(ruleComparison::Neq);
246 REQUIRE(rule1.value() == true);
247 }
248
249 WHEN("switch is off and should be not equal but is")
250 {
251 prop1["toggle"].setSwitchState(pcf::IndiElement::Off);
252 rule1.target("Off");
253 rule1.comparison(ruleComparison::Neq);
254 REQUIRE(rule1.value() == false);
255 }
256 }
257}
258
259SCENARIO( "INDI element comparison", "[stateRuleEngine::rules]" )
260{
261 GIVEN("string comparison within same property")
262 {
263 pcf::IndiProperty prop1(pcf::IndiProperty::Text);
264 prop1.setDevice("ruleTest");
265 prop1.setName("prop1");
266 prop1.setPerm(pcf::IndiProperty::ReadWrite);
267 prop1.setState(pcf::IndiProperty::Idle);
268 prop1.add(pcf::IndiElement("current"));
269 prop1.add(pcf::IndiElement("target"));
270
271 elCompTxtRule rule1;
272 rule1.property1(&prop1);
273 rule1.property2(&prop1);
274 rule1.element1("current");
275 rule1.element2("target");
276
277 WHEN("string elements wihtin same property should be equal and are")
278 {
279 prop1["current"] = "test";
280 prop1["target"] = "test";
281 rule1.comparison(ruleComparison::Eq);
282
283 REQUIRE(rule1.value() == true);
284 }
285
286 WHEN("string elements within same property should be equal and are not")
287 {
288 prop1["current"] = "test";
289 prop1["target"] = "tset";
290 rule1.comparison(ruleComparison::Eq);
291
292 REQUIRE(rule1.value() == false);
293 }
294
295 WHEN("string elements within same property should not be equal and are not")
296 {
297 prop1["current"] = "test";
298 prop1["target"] = "tset";
299 rule1.comparison(ruleComparison::Neq);
300
301 REQUIRE(rule1.value() == true);
302 }
303
304 WHEN("string elements within same property should not be equal and are")
305 {
306 prop1["current"] = "test";
307 prop1["target"] = "test";
308 rule1.comparison(ruleComparison::Neq);
309
310 REQUIRE(rule1.value() == false);
311 }
312 }
313
314 GIVEN("switch comparison")
315 {
316 pcf::IndiProperty prop1(pcf::IndiProperty::Switch);
317 prop1.setDevice("ruleTest1");
318 prop1.setName("prop1");
319 prop1.setPerm(pcf::IndiProperty::ReadWrite);
320 prop1.setState(pcf::IndiProperty::Idle);
321 prop1.add(pcf::IndiElement("nameTest"));
322
323 pcf::IndiProperty prop2(pcf::IndiProperty::Switch);
324 prop2.setDevice("ruleTest2");
325 prop2.setName("prop2");
326 prop2.setPerm(pcf::IndiProperty::ReadWrite);
327 prop2.setState(pcf::IndiProperty::Idle);
328 prop2.add(pcf::IndiElement("badgeTest"));
329
330 elCompSwRule rule1;
331 rule1.property1(&prop1);
332 rule1.property2(&prop2);
333 rule1.element1("nameTest");
334 rule1.element2("badgeTest");
335
336 WHEN("switches should be On and equal and are")
337 {
338 prop1["nameTest"].setSwitchState(pcf::IndiElement::On);
339 prop2["badgeTest"].setSwitchState(pcf::IndiElement::On);
340 rule1.comparison(ruleComparison::Eq);
341
342 REQUIRE(rule1.value() == true);
343 }
344
345 WHEN("switches should be On and equal but are not")
346 {
347 prop1["nameTest"].setSwitchState(pcf::IndiElement::On);
348 prop2["badgeTest"].setSwitchState(pcf::IndiElement::Off);
349 rule1.comparison(ruleComparison::Eq);
350
351 REQUIRE(rule1.value() == false);
352 }
353
354 WHEN("switches should be On and not equal and are not")
355 {
356 prop1["nameTest"].setSwitchState(pcf::IndiElement::On);
357 prop2["badgeTest"].setSwitchState(pcf::IndiElement::Off);
358 rule1.comparison(ruleComparison::Neq);
359
360 REQUIRE(rule1.value() == true);
361 }
362
363 WHEN("switches should be On and not equal but are")
364 {
365 prop1["nameTest"].setSwitchState(pcf::IndiElement::On);
366 prop2["badgeTest"].setSwitchState(pcf::IndiElement::On);
367 rule1.comparison(ruleComparison::Neq);
368
369 REQUIRE(rule1.value() == false);
370 }
371
372 WHEN("switches should be Off and equal and are")
373 {
374 prop1["nameTest"].setSwitchState(pcf::IndiElement::Off);
375 prop2["badgeTest"].setSwitchState(pcf::IndiElement::Off);
376 rule1.comparison(ruleComparison::Eq);
377
378 REQUIRE(rule1.value() == true);
379 }
380
381 WHEN("switches should be Off and equal but are not")
382 {
383 prop1["nameTest"].setSwitchState(pcf::IndiElement::Off);
384 prop2["badgeTest"].setSwitchState(pcf::IndiElement::On);
385 rule1.comparison(ruleComparison::Eq);
386
387 REQUIRE(rule1.value() == false);
388 }
389
390 WHEN("switches should be Off and not equal and are not")
391 {
392 prop1["nameTest"].setSwitchState(pcf::IndiElement::Off);
393 prop2["badgeTest"].setSwitchState(pcf::IndiElement::On);
394 rule1.comparison(ruleComparison::Neq);
395
396 REQUIRE(rule1.value() == true);
397 }
398
399 WHEN("switches should be Off and not equal but are")
400 {
401 prop1["nameTest"].setSwitchState(pcf::IndiElement::Off);
402 prop2["badgeTest"].setSwitchState(pcf::IndiElement::Off);
403 rule1.comparison(ruleComparison::Neq);
404
405 REQUIRE(rule1.value() == false);
406 }
407 }
408 GIVEN("numeric comparison")
409 {
410 pcf::IndiProperty prop1(pcf::IndiProperty::Number);
411 prop1.setDevice("ruleTest1");
412 prop1.setName("prop1");
413 prop1.setPerm(pcf::IndiProperty::ReadWrite);
414 prop1.setState(pcf::IndiProperty::Idle);
415 prop1.add(pcf::IndiElement("nameTest"));
416
417 pcf::IndiProperty prop2(pcf::IndiProperty::Number);
418 prop2.setDevice("ruleTest2");
419 prop2.setName("prop2");
420 prop2.setPerm(pcf::IndiProperty::ReadWrite);
421 prop2.setState(pcf::IndiProperty::Idle);
422 prop2.add(pcf::IndiElement("badgeTest"));
423
424 elCompNumRule rule1;
425 rule1.property1(&prop1);
426 rule1.property2(&prop2);
427 rule1.element1("nameTest");
428 rule1.element2("badgeTest");
429
430 WHEN("numbers should be equal and are")
431 {
432 prop1["nameTest"].set(2.5);
433 prop2["badgeTest"].set(2.5);
434 rule1.comparison(ruleComparison::Eq);
435
436 REQUIRE(rule1.value() == true);
437 }
438
439 WHEN("numbers should be equal but are not")
440 {
441 prop1["nameTest"].set(2.5);
442 prop2["badgeTest"].set(2.6);
443 rule1.comparison(ruleComparison::Eq);
444
445 REQUIRE(rule1.value() == false);
446 }
447 }
448}
449
450
451SCENARIO( "basic rule comparisons", "[stateRuleEngine::rules]" )
452{
453 GIVEN("INDI Property rule comparison")
454 {
455 WHEN("two strings should be equal and are")
456 {
457 pcf::IndiProperty prop1(pcf::IndiProperty::Text);
458 prop1.setDevice("ruleTest");
459 prop1.setName("prop1");
460 prop1.setPerm(pcf::IndiProperty::ReadWrite);
461 prop1.setState(pcf::IndiProperty::Idle);
462 prop1.add(pcf::IndiElement("current"));
463 prop1["current"] = "test";
464 prop1.add(pcf::IndiElement("target"));
465 prop1["target"] = "tset";
466
467 txtValRule rule1;
468
469 rule1.property(&prop1);
470 rule1.element("current");
471 rule1.comparison(ruleComparison::Eq);
472 rule1.target("test");
473
474
475 pcf::IndiProperty prop2(pcf::IndiProperty::Text);
476 prop2.setDevice("ruleTest2");
477 prop2.setName("prop2");
478 prop2.setPerm(pcf::IndiProperty::ReadWrite);
479 prop2.setState(pcf::IndiProperty::Idle);
480 prop2.add(pcf::IndiElement("current"));
481 prop2["current"] = "fail";
482 prop2.add(pcf::IndiElement("target"));
483 prop2["target"] = "liaf";
484
485 txtValRule rule2;
486
487 rule2.property(&prop2);
488 rule2.element("target");
489 rule2.comparison(ruleComparison::Eq);
490 rule2.target("liaf");
491
492
493 ruleCompRule rule3;
494 rule3.rule1(&rule1);
495 rule3.rule2(&rule2);
496 rule3.comparison(ruleComparison::And);
497
498 REQUIRE(rule3.value() == true);
499
500 }
501 }
502}
503
504SCENARIO( "compound rule compariaons", "[stateRuleEngine::rules]" )
505{
506 GIVEN("(A && B) || C")
507 {
508 pcf::IndiProperty prop1(pcf::IndiProperty::Text);
509 prop1.setDevice("ruleTest");
510 prop1.setName("prop1");
511 prop1.setPerm(pcf::IndiProperty::ReadWrite);
512 prop1.setState(pcf::IndiProperty::Idle);
513 prop1.add(pcf::IndiElement("current"));
514 prop1["current"] = "test";
515 prop1.add(pcf::IndiElement("target"));
516 prop1["target"] = "tset";
517
518 txtValRule rule1; //A
519
520 rule1.property(&prop1);
521 rule1.element("current");
522 rule1.comparison(ruleComparison::Eq);
523
524 pcf::IndiProperty prop2(pcf::IndiProperty::Text);
525 prop2.setDevice("ruleTest2");
526 prop2.setName("prop2");
527 prop2.setPerm(pcf::IndiProperty::ReadWrite);
528 prop2.setState(pcf::IndiProperty::Idle);
529 prop2.add(pcf::IndiElement("current"));
530 prop2["current"] = "fail";
531 prop2.add(pcf::IndiElement("target"));
532 prop2["target"] = "liaf";
533
534 txtValRule rule2; //B
535
536 rule2.property(&prop2);
537 rule2.element("target");
538 rule2.comparison(ruleComparison::Eq);
539
540 ruleCompRule rule3; //A&&B
541 rule3.rule1(&rule1);
542 rule3.rule2(&rule2);
543 rule3.comparison(ruleComparison::And);
544
545 pcf::IndiProperty prop3(pcf::IndiProperty::Text);
546 prop3.setDevice("ruleTest3");
547 prop3.setName("prop3");
548 prop3.setPerm(pcf::IndiProperty::ReadWrite);
549 prop3.setState(pcf::IndiProperty::Idle);
550 prop3.add(pcf::IndiElement("current"));
551 prop3["current"] = "pass";
552 prop3.add(pcf::IndiElement("target"));
553 prop3["target"] = "ssap";
554
555 txtValRule rule4; //C
556
557 rule4.property(&prop3);
558 rule4.element("current");
559 rule4.comparison(ruleComparison::Eq);
560
561 ruleCompRule rule5; // (A&&B) || C
562 rule5.rule1(&rule3); // A&&B
563 rule5.rule2(&rule4); // C
564 rule5.comparison(ruleComparison::Or);
565
566 WHEN("A==1, B==0, C==1")
567 {
568 rule1.target("test"); //A==1
569 rule2.target("fail"); //B==0
570 rule4.target("pass"); //C==1
571
572 //(A && B) || C
573 REQUIRE(rule5.value() == true);
574
575 }
576
577 WHEN("A==0, B==0, C==1")
578 {
579 rule1.target("tset"); //A==0
580 rule2.target("fail"); //B==0
581 rule4.target("pass"); //C==1
582
583 //(A && B) || C
584 REQUIRE(rule5.value() == true);
585 }
586
587 WHEN("A==1, B==0, C==0")
588 {
589 rule1.target("test"); //A==1
590 rule2.target("fail"); //B==0
591 rule4.target("ssap"); //C==0
592
593 //(A && B) || C
594 REQUIRE(rule5.value() == false);
595 }
596
597 WHEN("A==1, B==1, C==0")
598 {
599 rule1.target("test"); //A==1
600 rule2.target("liaf"); //B==1
601 rule4.target("ssap"); //C==0
602
603 //(A && B) || C
604 REQUIRE(rule5.value() == true);
605 }
606 }
607}
608
609#endif
GIVEN
#define GIVEN(desc)
Definition catch.hpp:17763
WHEN
#define WHEN(desc)
Definition catch.hpp:17765
SCENARIO
#define SCENARIO(...)
Definition catch.hpp:17760
REQUIRE
#define REQUIRE(...)
Definition catch.hpp:17676
ruleComparison::Gt
@ Gt
Greater than.
ruleComparison::Or
@ Or
boolean or
ruleComparison::Lt
@ Lt
Less than.
ruleComparison::LtEq
@ LtEq
Less than or equal to.
ruleComparison::GtEq
@ GtEq
Greater than or equal to.
ruleComparison::And
@ And
boolean and
ruleComparison::Neq
@ Neq
Not equal.
elCompNumRule
Compare two elements based on their numeric values.
Definition indiCompRules.hpp:849
elCompNumRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:899
elCompSwRule
Compare two elements based on their switch values.
Definition indiCompRules.hpp:958
elCompSwRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:978
elCompTxtRule
Compare two elements based on their text values.
Definition indiCompRules.hpp:919
elCompTxtRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:938
indiCompRule::comparison
void comparison(const ruleComparison &c)
Set the comparison for this rule.
Definition indiCompRules.hpp:198
numValRule
Compare the value of a number element to a target.
Definition indiCompRules.hpp:615
numValRule::target
void target(const double &tgt)
Set the target for the comparison.
Definition indiCompRules.hpp:634
numValRule::tol
void tol(const double &t)
Set the tolerance.
Definition indiCompRules.hpp:654
numValRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:682
onePropRule::property
void property(pcf::IndiProperty *property)
Set the property pointer.
Definition indiCompRules.hpp:391
onePropRule::element
void element(const std::string &el)
Set the element name.
Definition indiCompRules.hpp:416
ruleCompRule
A rule to compare two rules.
Definition indiCompRules.hpp:1001
ruleCompRule::rule2
void rule2(indiCompRule *r)
Set the pointer to the second rule.
Definition indiCompRules.hpp:1038
ruleCompRule::rule1
void rule1(indiCompRule *r)
Set the pointer to the first rule.
Definition indiCompRules.hpp:1023
ruleCompRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:1098
swValRule
Compare the value of a switch to a target value.
Definition indiCompRules.hpp:768
swValRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:829
swValRule::target
void target(const pcf::IndiElement::SwitchStateType &ss)
Set the target for the comparison.
Definition indiCompRules.hpp:785
twoPropRule::property1
void property1(pcf::IndiProperty *property)
Set the first property pointer.
Definition indiCompRules.hpp:487
twoPropRule::element2
void element2(const std::string &el)
Set the second element name.
Definition indiCompRules.hpp:556
twoPropRule::element1
void element1(const std::string &el)
Set the first element name.
Definition indiCompRules.hpp:512
twoPropRule::property2
void property2(pcf::IndiProperty *property)
Set the second property pointer.
Definition indiCompRules.hpp:531
txtValRule
Compare the value of a text element to a target value.
Definition indiCompRules.hpp:706
txtValRule::target
void target(const std::string &target)
Set the target for the comparison.
Definition indiCompRules.hpp:723
txtValRule::value
virtual bool value()
Get the value of this rule.
Definition indiCompRules.hpp:746