1 #include "utils.hpp"
2 
3 #include <nlohmann/json.hpp>
4 
5 #include <string>
6 #include <variant>
7 
8 #include "gtest/gtest.h"
9 
10 using namespace std::string_literals;
11 
12 TEST(TemplateCharReplace, replaceOneInt)
13 {
14     nlohmann::json j = {{"foo", "$bus"}};
15     auto it = j.begin();
16     DBusInterface data;
17     data["BUS"] = 23;
18 
19     templateCharReplace(it, data, 0);
20 
21     nlohmann::json expected = 23;
22     EXPECT_EQ(expected, j["foo"]);
23 }
24 
25 TEST(TemplateCharReplace, replaceOneStr)
26 {
27     nlohmann::json j = {{"foo", "$TEST"}};
28     auto it = j.begin();
29     DBusInterface data;
30     data["TEST"] = std::string("Test");
31 
32     templateCharReplace(it, data, 0);
33 
34     nlohmann::json expected = "Test";
35     EXPECT_EQ(expected, j["foo"]);
36 }
37 
38 TEST(TemplateCharReplace, replaceSecondStr)
39 {
40     nlohmann::json j = {{"foo", "the $TEST"}};
41     auto it = j.begin();
42     DBusInterface data;
43     data["TEST"] = std::string("Test");
44 
45     templateCharReplace(it, data, 0);
46 
47     nlohmann::json expected = "the Test";
48     EXPECT_EQ(expected, j["foo"]);
49 }
50 
51 TEST(TemplateCharReplace, replaceMiddleStr)
52 {
53     nlohmann::json j = {{"foo", "the $TEST worked"}};
54     auto it = j.begin();
55     DBusInterface data;
56     data["TEST"] = std::string("Test");
57 
58     templateCharReplace(it, data, 0);
59 
60     nlohmann::json expected = "the Test worked";
61     EXPECT_EQ(expected, j["foo"]);
62 }
63 
64 TEST(TemplateCharReplace, replaceLastStr)
65 {
66     nlohmann::json j = {{"foo", "the Test $TEST"}};
67     auto it = j.begin();
68     DBusInterface data;
69     data["TEST"] = 23;
70 
71     templateCharReplace(it, data, 0);
72 
73     nlohmann::json expected = "the Test 23";
74     EXPECT_EQ(expected, j["foo"]);
75 }
76 
77 TEST(TemplateCharReplace, increment)
78 {
79     nlohmann::json j = {{"foo", "3 plus 1 equals $TEST + 1"}};
80     auto it = j.begin();
81     DBusInterface data;
82     data["TEST"] = 3;
83 
84     templateCharReplace(it, data, 0);
85 
86     nlohmann::json expected = "3 plus 1 equals 4";
87     EXPECT_EQ(expected, j["foo"]);
88 }
89 
90 TEST(TemplateCharReplace, decrement)
91 {
92     nlohmann::json j = {{"foo", "3 minus 1 equals $TEST - 1 !"}};
93     auto it = j.begin();
94     DBusInterface data;
95     data["TEST"] = 3;
96 
97     templateCharReplace(it, data, 0);
98 
99     nlohmann::json expected = "3 minus 1 equals 2 !";
100     EXPECT_EQ(expected, j["foo"]);
101 }
102 
103 TEST(TemplateCharReplace, modulus)
104 {
105     nlohmann::json j = {{"foo", "3 mod 2 equals $TEST % 2"}};
106     auto it = j.begin();
107     DBusInterface data;
108     data["TEST"] = 3;
109 
110     templateCharReplace(it, data, 0);
111 
112     nlohmann::json expected = "3 mod 2 equals 1";
113     EXPECT_EQ(expected, j["foo"]);
114 }
115 
116 TEST(TemplateCharReplace, multiply)
117 {
118     nlohmann::json j = {{"foo", "3 * 2 equals $TEST * 2"}};
119     auto it = j.begin();
120     DBusInterface data;
121     data["TEST"] = 3;
122 
123     templateCharReplace(it, data, 0);
124 
125     nlohmann::json expected = "3 * 2 equals 6";
126     EXPECT_EQ(expected, j["foo"]);
127 }
128 
129 TEST(TemplateCharReplace, divide)
130 {
131     nlohmann::json j = {{"foo", "4 / 2 equals $TEST / 2"}};
132     auto it = j.begin();
133     DBusInterface data;
134     data["TEST"] = 4;
135 
136     templateCharReplace(it, data, 0);
137 
138     nlohmann::json expected = "4 / 2 equals 2";
139     EXPECT_EQ(expected, j["foo"]);
140 }
141 
142 TEST(TemplateCharReplace, multiMath)
143 {
144     nlohmann::json j = {{"foo", "4 * 2 % 6 equals $TEST * 2 % 6"}};
145     auto it = j.begin();
146     DBusInterface data;
147     data["TEST"] = 4;
148 
149     templateCharReplace(it, data, 0);
150 
151     nlohmann::json expected = "4 * 2 % 6 equals 2";
152     EXPECT_EQ(expected, j["foo"]);
153 }
154 
155 TEST(TemplateCharReplace, twoReplacements)
156 {
157     nlohmann::json j = {{"foo", "$FOO $BAR"}};
158     auto it = j.begin();
159     DBusInterface data;
160     data["FOO"] = std::string("foo");
161     data["BAR"] = std::string("bar");
162 
163     templateCharReplace(it, data, 0);
164 
165     nlohmann::json expected = "foo bar";
166     EXPECT_EQ(expected, j["foo"]);
167 }
168 
169 TEST(TemplateCharReplace, twoReplacementsWithMath)
170 {
171     nlohmann::json j = {{"foo", "4 / 2 equals $TEST / 2 $BAR"}};
172     auto it = j.begin();
173     DBusInterface data;
174     data["TEST"] = 4;
175     data["BAR"] = std::string("bar");
176 
177     templateCharReplace(it, data, 0);
178 
179     nlohmann::json expected = "4 / 2 equals 2 bar";
180 }
181 
182 TEST(TemplateCharReplace, twoReplacementsWithMath2)
183 {
184     nlohmann::json j = {{"foo", "4 / 2 equals $ADDRESS / 2 $BAR"}};
185     auto it = j.begin();
186     DBusInterface data;
187     data["ADDRESS"] = 4;
188     data["BAR"] = std::string("bar");
189 
190     templateCharReplace(it, data, 0);
191 
192     nlohmann::json expected = "4 / 2 equals 2 bar";
193     EXPECT_EQ(expected, j["foo"]);
194 }
195 
196 TEST(TemplateCharReplace, hexAndWrongCase)
197 {
198     nlohmann::json j = {{"Address", "0x54"},
199                         {"Bus", 15},
200                         {"Name", "$bus sensor 0"},
201                         {"Type", "SomeType"}};
202 
203     DBusInterface data;
204     data["BUS"] = 15;
205 
206     for (auto it = j.begin(); it != j.end(); it++)
207     {
208         templateCharReplace(it, data, 0);
209     }
210     nlohmann::json expected = {{"Address", 84},
211                                {"Bus", 15},
212                                {"Name", "15 sensor 0"},
213                                {"Type", "SomeType"}};
214     EXPECT_EQ(expected, j);
215 }
216 
217 TEST(TemplateCharReplace, replaceSecondAsInt)
218 {
219     nlohmann::json j = {{"foo", "twelve is $TEST"}};
220     auto it = j.begin();
221     DBusInterface data;
222     data["test"] = 12;
223 
224     templateCharReplace(it, data, 0);
225 
226     nlohmann::json expected = "twelve is 12";
227     EXPECT_EQ(expected, j["foo"]);
228 }
229 
230 TEST(TemplateCharReplace, singleHex)
231 {
232     nlohmann::json j = {{"foo", "0x54"}};
233     auto it = j.begin();
234     DBusInterface data;
235 
236     templateCharReplace(it, data, 0);
237 
238     nlohmann::json expected = 84;
239     EXPECT_EQ(expected, j["foo"]);
240 }
241 
242 TEST(MatchProbe, stringEqString)
243 {
244     nlohmann::json j = R"("foo")"_json;
245     DBusValueVariant v = "foo"s;
246     EXPECT_TRUE(matchProbe(j, v));
247 }
248 
249 TEST(MatchProbe, stringRegexEqString)
250 {
251     nlohmann::json j = R"("foo*")"_json;
252     DBusValueVariant v = "foobar"s;
253     EXPECT_TRUE(matchProbe(j, v));
254 }
255 
256 TEST(MatchProbe, stringNeqString)
257 {
258     nlohmann::json j = R"("foobar")"_json;
259     DBusValueVariant v = "foo"s;
260     EXPECT_FALSE(matchProbe(j, v));
261 }
262 
263 TEST(MatchProbe, stringRegexError)
264 {
265     nlohmann::json j = R"("foo[")"_json;
266     DBusValueVariant v = "foobar"s;
267     EXPECT_FALSE(matchProbe(j, v));
268 }
269 
270 TEST(MatchProbe, stringRegexNotPrefix)
271 {
272     nlohmann::json j = R"("foo(?!bar)...foo")"_json;
273     DBusValueVariant v1 = "foobarfoo"s;
274     DBusValueVariant v2 = "foofoofoo"s;
275     EXPECT_FALSE(matchProbe(j, v1));
276     EXPECT_TRUE(matchProbe(j, v2));
277 }
278 
279 TEST(MatchProbe, stringZeroNeqFalse)
280 {
281     nlohmann::json j = R"("0")"_json;
282     DBusValueVariant v = false;
283     EXPECT_FALSE(matchProbe(j, v));
284 }
285 
286 TEST(MatchProbe, stringOneNeqTrue)
287 {
288     nlohmann::json j = R"("1")"_json;
289     DBusValueVariant v = true;
290     EXPECT_FALSE(matchProbe(j, v));
291 }
292 
293 TEST(MatchProbe, stringElevenNeqTrue)
294 {
295     nlohmann::json j = R"("11")"_json;
296     DBusValueVariant v = true;
297     EXPECT_FALSE(matchProbe(j, v));
298 }
299 
300 TEST(MatchProbe, stringFalseNeqFalse)
301 {
302     nlohmann::json j = R"("false")"_json;
303     DBusValueVariant v = false;
304     EXPECT_FALSE(matchProbe(j, v));
305 }
306 
307 TEST(MatchProbe, stringTrueNeqTrue)
308 {
309     nlohmann::json j = R"("true")"_json;
310     DBusValueVariant v = true;
311     EXPECT_FALSE(matchProbe(j, v));
312 }
313 
314 TEST(MatchProbe, stringFalseNeqTrue)
315 {
316     nlohmann::json j = R"("false")"_json;
317     DBusValueVariant v = true;
318     EXPECT_FALSE(matchProbe(j, v));
319 }
320 
321 TEST(MatchProbe, stringNeqUint8)
322 {
323     nlohmann::json j = R"("255")"_json;
324     DBusValueVariant v = uint8_t(255);
325     EXPECT_FALSE(matchProbe(j, v));
326 }
327 
328 TEST(MatchProbe, stringNeqUint8Overflow)
329 {
330     nlohmann::json j = R"("65535")"_json;
331     DBusValueVariant v = uint8_t(255);
332     EXPECT_FALSE(matchProbe(j, v));
333 }
334 
335 TEST(MatchProbe, stringFalseNeqUint8Zero)
336 {
337     nlohmann::json j = R"("false")"_json;
338     DBusValueVariant v = uint8_t(0);
339     EXPECT_FALSE(matchProbe(j, v));
340 }
341 
342 TEST(MatchProbe, stringTrueNeqUint8Zero)
343 {
344     nlohmann::json j = R"("true")"_json;
345     DBusValueVariant v = uint8_t(1);
346     EXPECT_FALSE(matchProbe(j, v));
347 }
348 
349 TEST(MatchProbe, stringNeqUint32)
350 {
351     nlohmann::json j = R"("11")"_json;
352     DBusValueVariant v = uint32_t(11);
353     EXPECT_FALSE(matchProbe(j, v));
354 }
355 
356 TEST(MatchProbe, stringNeqInt32)
357 {
358     nlohmann::json j = R"("-11")"_json;
359     DBusValueVariant v = int32_t(-11);
360     EXPECT_FALSE(matchProbe(j, v));
361 }
362 
363 TEST(MatchProbe, stringRegexNeqInt32)
364 {
365     nlohmann::json j = R"("1*4")"_json;
366     DBusValueVariant v = int32_t(124);
367     EXPECT_FALSE(matchProbe(j, v));
368 }
369 
370 TEST(MatchProbe, stringNeqUint64)
371 {
372     nlohmann::json j = R"("foo")"_json;
373     DBusValueVariant v = uint64_t(65535);
374     EXPECT_FALSE(matchProbe(j, v));
375 }
376 
377 TEST(MatchProbe, stringNeqDouble)
378 {
379     nlohmann::json j = R"("123.4")"_json;
380     DBusValueVariant v = double(123.4);
381     EXPECT_FALSE(matchProbe(j, v));
382 }
383 
384 TEST(MatchProbe, stringNeqEmpty)
385 {
386     nlohmann::json j = R"("-123.4")"_json;
387     DBusValueVariant v;
388     EXPECT_FALSE(matchProbe(j, v));
389 }
390 
391 TEST(MatchProbe, stringNeqArray)
392 {
393     nlohmann::json j = R"("-123.4")"_json;
394     DBusValueVariant v = std::vector<uint8_t>{1, 2};
395     EXPECT_FALSE(matchProbe(j, v));
396 }
397 
398 TEST(MatchProbe, boolNeqString)
399 {
400     nlohmann::json j = R"(false)"_json;
401     DBusValueVariant v = "false"s;
402     EXPECT_FALSE(matchProbe(j, v));
403 }
404 
405 TEST(MatchProbe, trueEqTrue)
406 {
407     nlohmann::json j = R"(true)"_json;
408     DBusValueVariant v = true;
409     EXPECT_TRUE(matchProbe(j, v));
410 }
411 
412 TEST(MatchProbe, falseEqFalse)
413 {
414     nlohmann::json j = R"(false)"_json;
415     DBusValueVariant v = false;
416     EXPECT_TRUE(matchProbe(j, v));
417 }
418 
419 TEST(MatchProbe, trueNeqFalse)
420 {
421     nlohmann::json j = R"(true)"_json;
422     DBusValueVariant v = false;
423     EXPECT_FALSE(matchProbe(j, v));
424 }
425 
426 TEST(MatchProbe, trueNeqInt32Zero)
427 {
428     nlohmann::json j = R"(true)"_json;
429     DBusValueVariant v = int32_t(0);
430     EXPECT_FALSE(matchProbe(j, v));
431 }
432 
433 TEST(MatchProbe, trueNeqInt32NegativeOne)
434 {
435     nlohmann::json j = R"(true)"_json;
436     DBusValueVariant v = int32_t(-1);
437     EXPECT_FALSE(matchProbe(j, v));
438 }
439 
440 TEST(MatchProbe, falseNeqUint32One)
441 {
442     nlohmann::json j = R"(false)"_json;
443     DBusValueVariant v = uint32_t(1);
444     EXPECT_FALSE(matchProbe(j, v));
445 }
446 
447 TEST(MatchProbe, falseNeqUint32Zero)
448 {
449     nlohmann::json j = R"(false)"_json;
450     DBusValueVariant v = uint32_t(0);
451     EXPECT_FALSE(matchProbe(j, v));
452 }
453 
454 TEST(MatchProbe, trueNeqDoubleNegativeOne)
455 {
456     nlohmann::json j = R"(true)"_json;
457     DBusValueVariant v = double(-1.1);
458     EXPECT_FALSE(matchProbe(j, v));
459 }
460 
461 TEST(MatchProbe, trueNeqDoubleOne)
462 {
463     nlohmann::json j = R"(true)"_json;
464     DBusValueVariant v = double(1.0);
465     EXPECT_FALSE(matchProbe(j, v));
466 }
467 
468 TEST(MatchProbe, falseNeqDoubleOne)
469 {
470     nlohmann::json j = R"(false)"_json;
471     DBusValueVariant v = double(1.0);
472     EXPECT_FALSE(matchProbe(j, v));
473 }
474 
475 TEST(MatchProbe, falseNeqDoubleZero)
476 {
477     nlohmann::json j = R"(false)"_json;
478     DBusValueVariant v = double(0.0);
479     EXPECT_FALSE(matchProbe(j, v));
480 }
481 
482 TEST(MatchProbe, falseNeqEmpty)
483 {
484     nlohmann::json j = R"(false)"_json;
485     DBusValueVariant v;
486     EXPECT_FALSE(matchProbe(j, v));
487 }
488 
489 TEST(MatchProbe, trueNeqEmpty)
490 {
491     nlohmann::json j = R"(true)"_json;
492     DBusValueVariant v;
493     EXPECT_FALSE(matchProbe(j, v));
494 }
495 
496 TEST(MatchProbe, trueNeqArray)
497 {
498     nlohmann::json j = R"(true)"_json;
499     DBusValueVariant v = std::vector<uint8_t>{1, 2};
500     EXPECT_FALSE(matchProbe(j, v));
501 }
502 
503 TEST(MatchProbe, uintNeqString)
504 {
505     nlohmann::json j = R"(11)"_json;
506     DBusValueVariant v = "11"s;
507     EXPECT_FALSE(matchProbe(j, v));
508 }
509 
510 TEST(MatchProbe, uintNeqTrue)
511 {
512     nlohmann::json j = R"(1)"_json;
513     DBusValueVariant v = true;
514     EXPECT_FALSE(matchProbe(j, v));
515 }
516 
517 TEST(MatchProbe, uintNeqFalse)
518 {
519     nlohmann::json j = R"(0)"_json;
520     DBusValueVariant v = false;
521     EXPECT_FALSE(matchProbe(j, v));
522 }
523 
524 TEST(MatchProbe, uintEqUint8)
525 {
526     nlohmann::json j = R"(11)"_json;
527     DBusValueVariant v = uint8_t(11);
528     EXPECT_TRUE(matchProbe(j, v));
529 }
530 
531 TEST(MatchProbe, uintNeqUint8)
532 {
533     nlohmann::json j = R"(11)"_json;
534     DBusValueVariant v = uint8_t(12);
535     EXPECT_FALSE(matchProbe(j, v));
536 }
537 
538 TEST(MatchProbe, uintNeqUint8Overflow)
539 {
540     nlohmann::json j = R"(65535)"_json;
541     DBusValueVariant v = uint8_t(255);
542     EXPECT_FALSE(matchProbe(j, v));
543 }
544 
545 TEST(MatchProbe, uintEqInt8)
546 {
547     nlohmann::json j = R"(11)"_json;
548     DBusValueVariant v = int8_t(11);
549     EXPECT_TRUE(matchProbe(j, v));
550 }
551 
552 TEST(MatchProbe, uintEqDouble)
553 {
554     nlohmann::json j = R"(11)"_json;
555     DBusValueVariant v = double(11.0);
556     EXPECT_TRUE(matchProbe(j, v));
557 }
558 
559 TEST(MatchProbe, uintNeqDouble)
560 {
561     nlohmann::json j = R"(11)"_json;
562     DBusValueVariant v = double(11.7);
563     EXPECT_FALSE(matchProbe(j, v));
564 }
565 
566 TEST(MatchProbe, uintNeqEmpty)
567 {
568     nlohmann::json j = R"(11)"_json;
569     DBusValueVariant v;
570     EXPECT_FALSE(matchProbe(j, v));
571 }
572 
573 TEST(MatchProbe, uintNeqArray)
574 {
575     nlohmann::json j = R"(11)"_json;
576     DBusValueVariant v = std::vector<uint8_t>{11};
577     EXPECT_FALSE(matchProbe(j, v));
578 }
579 
580 TEST(MatchProbe, intNeqString)
581 {
582     nlohmann::json j = R"(-11)"_json;
583     DBusValueVariant v = "-11"s;
584     EXPECT_FALSE(matchProbe(j, v));
585 }
586 
587 TEST(MatchProbe, intNeqTrue)
588 {
589     nlohmann::json j = R"(-1)"_json;
590     DBusValueVariant v = true;
591     EXPECT_FALSE(matchProbe(j, v));
592 }
593 
594 TEST(MatchProbe, intNeqUint8)
595 {
596     nlohmann::json j = R"(-11)"_json;
597     DBusValueVariant v = uint8_t(11);
598     EXPECT_FALSE(matchProbe(j, v));
599 }
600 
601 TEST(MatchProbe, intEqInt8)
602 {
603     nlohmann::json j = R"(-11)"_json;
604     DBusValueVariant v = int8_t(-11);
605     EXPECT_TRUE(matchProbe(j, v));
606 }
607 
608 TEST(MatchProbe, intNeqDouble)
609 {
610     nlohmann::json j = R"(-124)"_json;
611     DBusValueVariant v = double(-123.0);
612     EXPECT_FALSE(matchProbe(j, v));
613 }
614 
615 TEST(MatchProbe, intEqDouble)
616 {
617     nlohmann::json j = R"(-11)"_json;
618     DBusValueVariant v = double(-11.0);
619     EXPECT_TRUE(matchProbe(j, v));
620 }
621 
622 TEST(MatchProbe, intNeqDoubleRound)
623 {
624     nlohmann::json j = R"(-11)"_json;
625     DBusValueVariant v = double(-11.7);
626     EXPECT_FALSE(matchProbe(j, v));
627 }
628 
629 TEST(MatchProbe, intNeqEmpty)
630 {
631     nlohmann::json j = R"(-11)"_json;
632     DBusValueVariant v;
633     EXPECT_FALSE(matchProbe(j, v));
634 }
635 
636 TEST(MatchProbe, intNeqArray)
637 {
638     nlohmann::json j = R"(-11)"_json;
639     DBusValueVariant v = std::vector<uint8_t>{11};
640     EXPECT_FALSE(matchProbe(j, v));
641 }
642 
643 TEST(MatchProbe, doubleNeqString)
644 {
645     nlohmann::json j = R"(0.0)"_json;
646     DBusValueVariant v = "0.0"s;
647     EXPECT_FALSE(matchProbe(j, v));
648 }
649 
650 TEST(MatchProbe, doubleNeqFalse)
651 {
652     nlohmann::json j = R"(0.0)"_json;
653     DBusValueVariant v = false;
654     EXPECT_FALSE(matchProbe(j, v));
655 }
656 
657 TEST(MatchProbe, doubleNeqTrue)
658 {
659     nlohmann::json j = R"(1.0)"_json;
660     DBusValueVariant v = true;
661     EXPECT_FALSE(matchProbe(j, v));
662 }
663 
664 TEST(MatchProbe, doubleEqInt32)
665 {
666     nlohmann::json j = R"(-124.0)"_json;
667     DBusValueVariant v = int32_t(-124);
668     EXPECT_TRUE(matchProbe(j, v));
669 }
670 
671 TEST(MatchProbe, doubleNeqInt32)
672 {
673     nlohmann::json j = R"(-124.0)"_json;
674     DBusValueVariant v = int32_t(-123);
675     EXPECT_FALSE(matchProbe(j, v));
676 }
677 
678 TEST(MatchProbe, doubleRoundNeqInt)
679 {
680     nlohmann::json j = R"(124.7)"_json;
681     DBusValueVariant v = int32_t(124);
682     EXPECT_FALSE(matchProbe(j, v));
683 }
684 TEST(MatchProbe, doubleEqDouble)
685 {
686     nlohmann::json j = R"(-124.2)"_json;
687     DBusValueVariant v = double(-124.2);
688     EXPECT_TRUE(matchProbe(j, v));
689 }
690 
691 TEST(MatchProbe, doubleNeqDouble)
692 {
693     nlohmann::json j = R"(-124.3)"_json;
694     DBusValueVariant v = double(-124.2);
695     EXPECT_FALSE(matchProbe(j, v));
696 }
697 
698 TEST(MatchProbe, doubleNeqEmpty)
699 {
700     nlohmann::json j = R"(-11.0)"_json;
701     DBusValueVariant v;
702     EXPECT_FALSE(matchProbe(j, v));
703 }
704 
705 TEST(MatchProbe, doubleNeqArray)
706 {
707     nlohmann::json j = R"(-11.2)"_json;
708     DBusValueVariant v = std::vector<uint8_t>{11};
709     EXPECT_FALSE(matchProbe(j, v));
710 }
711 
712 TEST(MatchProbe, arrayNeqString)
713 {
714     nlohmann::json j = R"([1, 2])"_json;
715     DBusValueVariant v = "hello"s;
716     EXPECT_FALSE(matchProbe(j, v));
717 }
718 
719 TEST(MatchProbe, arrayNeqFalse)
720 {
721     nlohmann::json j = R"([1, 2])"_json;
722     DBusValueVariant v = false;
723     EXPECT_FALSE(matchProbe(j, v));
724 }
725 
726 TEST(MatchProbe, arrayNeqTrue)
727 {
728     nlohmann::json j = R"([1, 2])"_json;
729     DBusValueVariant v = true;
730     EXPECT_FALSE(matchProbe(j, v));
731 }
732 
733 TEST(MatchProbe, arrayNeqUint8)
734 {
735     nlohmann::json j = R"([1, 2])"_json;
736     DBusValueVariant v = uint8_t(1);
737     EXPECT_FALSE(matchProbe(j, v));
738 }
739 
740 TEST(MatchProbe, arrayNeqInt32)
741 {
742     nlohmann::json j = R"([1, 2])"_json;
743     DBusValueVariant v = int32_t(-1);
744     EXPECT_FALSE(matchProbe(j, v));
745 }
746 
747 TEST(MatchProbe, arrayNeqDouble)
748 {
749     nlohmann::json j = R"([1, 2])"_json;
750     DBusValueVariant v = double(1.1);
751     EXPECT_FALSE(matchProbe(j, v));
752 }
753 
754 TEST(MatchProbe, arrayEqArray)
755 {
756     nlohmann::json j = R"([1, 2])"_json;
757     DBusValueVariant v = std::vector<uint8_t>{1, 2};
758     EXPECT_TRUE(matchProbe(j, v));
759 }
760 
761 TEST(MatchProbe, arrayNeqArrayDiffSize1)
762 {
763     nlohmann::json j = R"([1, 2, 3])"_json;
764     DBusValueVariant v = std::vector<uint8_t>{1, 2};
765     EXPECT_FALSE(matchProbe(j, v));
766 }
767 
768 TEST(MatchProbe, arrayNeqArrayDiffSize2)
769 {
770     nlohmann::json j = R"([1, 2])"_json;
771     DBusValueVariant v = std::vector<uint8_t>{1, 2, 3};
772     EXPECT_FALSE(matchProbe(j, v));
773 }
774 
775 TEST(MatchProbe, emptyArrayEqEmptyArray)
776 {
777     nlohmann::json j = R"([])"_json;
778     DBusValueVariant v = std::vector<uint8_t>{};
779     EXPECT_TRUE(matchProbe(j, v));
780 }
781 
782 TEST(MatchProbe, emptyArrayNeqArray)
783 {
784     nlohmann::json j = R"([])"_json;
785     DBusValueVariant v = std::vector<uint8_t>{1};
786     EXPECT_FALSE(matchProbe(j, v));
787 }
788 
789 TEST(MatchProbe, arrayNeqEmptyArray)
790 {
791     nlohmann::json j = R"([1])"_json;
792     DBusValueVariant v = std::vector<uint8_t>{};
793     EXPECT_FALSE(matchProbe(j, v));
794 }
795 
796 TEST(MatchProbe, objNeqString)
797 {
798     nlohmann::json j = R"({"foo": "bar"})"_json;
799     DBusValueVariant v = "hello"s;
800     EXPECT_FALSE(matchProbe(j, v));
801 }
802 
803 TEST(MatchProbe, objNeqFalse)
804 {
805     nlohmann::json j = R"({"foo": "bar"})"_json;
806     DBusValueVariant v = false;
807     EXPECT_FALSE(matchProbe(j, v));
808 }
809 
810 TEST(MatchProbe, objNeqTrue)
811 {
812     nlohmann::json j = R"({"foo": "bar"})"_json;
813     DBusValueVariant v = true;
814     EXPECT_FALSE(matchProbe(j, v));
815 }
816 
817 TEST(MatchProbe, objNeqUint8)
818 {
819     nlohmann::json j = R"({"foo": "bar"})"_json;
820     DBusValueVariant v = uint8_t(1);
821     EXPECT_FALSE(matchProbe(j, v));
822 }
823 
824 TEST(MatchProbe, objNeqInt32)
825 {
826     nlohmann::json j = R"({"foo": "bar"})"_json;
827     DBusValueVariant v = int32_t(-1);
828     EXPECT_FALSE(matchProbe(j, v));
829 }
830 
831 TEST(MatchProbe, objNeqDouble)
832 {
833     nlohmann::json j = R"({"foo": "bar"})"_json;
834     DBusValueVariant v = double(1.1);
835     EXPECT_FALSE(matchProbe(j, v));
836 }
837 
838 TEST(MatchProbe, objNeqArray)
839 {
840     nlohmann::json j = R"({"foo": "bar"})"_json;
841     DBusValueVariant v = std::vector<uint8_t>{1, 2};
842     EXPECT_FALSE(matchProbe(j, v));
843 }
844 
845 TEST(MatchProbe, nullNeqString)
846 {
847     nlohmann::json j = R"(null)"_json;
848     DBusValueVariant v = "hello"s;
849     EXPECT_FALSE(matchProbe(j, v));
850 }
851 
852 TEST(MatchProbe, nullNeqFalse)
853 {
854     nlohmann::json j = R"(null)"_json;
855     DBusValueVariant v = false;
856     EXPECT_FALSE(matchProbe(j, v));
857 }
858 
859 TEST(MatchProbe, nullNeqTrue)
860 {
861     nlohmann::json j = R"(null)"_json;
862     DBusValueVariant v = true;
863     EXPECT_FALSE(matchProbe(j, v));
864 }
865 
866 TEST(MatchProbe, nullNeqUint8)
867 {
868     nlohmann::json j = R"(null)"_json;
869     DBusValueVariant v = uint8_t(1);
870     EXPECT_FALSE(matchProbe(j, v));
871 }
872 
873 TEST(MatchProbe, nullNeqInt32)
874 {
875     nlohmann::json j = R"(null)"_json;
876     DBusValueVariant v = int32_t(-1);
877     EXPECT_FALSE(matchProbe(j, v));
878 }
879 
880 TEST(MatchProbe, nullNeqDouble)
881 {
882     nlohmann::json j = R"(null)"_json;
883     DBusValueVariant v = double(1.1);
884     EXPECT_FALSE(matchProbe(j, v));
885 }
886 
887 TEST(MatchProbe, nullNeqArray)
888 {
889     nlohmann::json j = R"(null)"_json;
890     DBusValueVariant v = std::vector<uint8_t>{};
891     EXPECT_FALSE(matchProbe(j, v));
892 }
893