1 #include "led-test-map.hpp"
2 #include "manager.hpp"
3 
4 #include <sdbusplus/bus.hpp>
5 
6 #include <algorithm>
7 #include <set>
8 
9 #include <gtest/gtest.h>
10 using namespace phosphor::led;
11 class LedTest : public ::testing::Test
12 {
13   public:
14     sdbusplus::bus::bus bus;
15     LedTest() : bus(sdbusplus::bus::new_default())
16     {
17         // Nothing here
18     }
19     ~LedTest()
20     {
21         // Leaving up to auto cleanup.
22     }
23 };
24 
25 /** @brief Assert Single LED to On */
26 TEST_F(LedTest, assertSingleLedOn)
27 {
28     Manager manager(bus, singleLedOn);
29     {
30         // Assert the LEDs.
31         Manager::group ledsAssert{};
32         Manager::group ledsDeAssert{};
33 
34         auto group = "/xyz/openbmc_project/ledmanager/groups/SingleLed";
35         auto result =
36             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
37         EXPECT_EQ(true, result);
38 
39         // Need just the ledsAssserted populated with these.
40         std::set<Layout::LedAction> refAssert = {
41             {"One", phosphor::led::Layout::On, 0, 0,
42              phosphor::led::Layout::Blink},
43         };
44         EXPECT_EQ(refAssert.size(), ledsAssert.size());
45         EXPECT_EQ(0, ledsDeAssert.size());
46 
47         // difference of refAssert and ledsAssert must be null.
48         Manager::group temp{};
49         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
50                             refAssert.begin(), refAssert.end(),
51                             std::inserter(temp, temp.begin()));
52         EXPECT_EQ(0, temp.size());
53     }
54 }
55 
56 /** @brief Assert Single LED to Blink */
57 TEST_F(LedTest, assertSingleLedBlink)
58 {
59     Manager manager(bus, singleLedBlink);
60     {
61         // Assert the LEDs.
62         Manager::group ledsAssert{};
63         Manager::group ledsDeAssert{};
64 
65         auto group = "/xyz/openbmc_project/ledmanager/groups/SingleLed";
66         auto result =
67             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
68         EXPECT_EQ(true, result);
69 
70         // Need just the ledsAssserted populated with these.
71         std::set<Layout::LedAction> refAssert = {
72             {"One", phosphor::led::Layout::Blink, 0, 0,
73              phosphor::led::Layout::Blink},
74         };
75         EXPECT_EQ(refAssert.size(), ledsAssert.size());
76         EXPECT_EQ(0, ledsDeAssert.size());
77 
78         // difference of refAssert and ledsAssert must be null.
79         Manager::group temp{};
80         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
81                             refAssert.begin(), refAssert.end(),
82                             std::inserter(temp, temp.begin()));
83         EXPECT_EQ(0, temp.size());
84     }
85 }
86 
87 /** @brief Assert Single LED to On and Try Assert Again */
88 TEST_F(LedTest, assertSingleLedOnAndreAssert)
89 {
90     Manager manager(bus, singleLedOn);
91     {
92         // Assert the LEDs.
93         Manager::group ledsAssert{};
94         Manager::group ledsDeAssert{};
95 
96         auto group = "/xyz/openbmc_project/ledmanager/groups/SingleLed";
97         auto result =
98             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
99         EXPECT_EQ(true, result);
100 
101         // Need just the ledsAssserted populated with these.
102         std::set<Layout::LedAction> refAssert = {
103             {"One", phosphor::led::Layout::On, 0, 0,
104              phosphor::led::Layout::Blink},
105         };
106         EXPECT_EQ(refAssert.size(), ledsAssert.size());
107         EXPECT_EQ(0, ledsDeAssert.size());
108 
109         // difference of refAssert and ledsAssert must be null.
110         Manager::group temp{};
111         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
112                             refAssert.begin(), refAssert.end(),
113                             std::inserter(temp, temp.begin()));
114         EXPECT_EQ(0, temp.size());
115     }
116     {
117         // Assert the LEDs.
118         Manager::group ledsAssert{};
119         Manager::group ledsDeAssert{};
120 
121         auto group = "/xyz/openbmc_project/ledmanager/groups/SingleLed";
122         auto result =
123             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
124         EXPECT_EQ(true, result);
125 
126         EXPECT_EQ(0, ledsAssert.size());
127         EXPECT_EQ(0, ledsDeAssert.size());
128     }
129 }
130 
131 /** @brief Assert Multiple LEDs to On */
132 TEST_F(LedTest, assertMultipleLedOn)
133 {
134     Manager manager(bus, multipleLedsOn);
135     {
136         // Assert the LEDs.
137         Manager::group ledsAssert{};
138         Manager::group ledsDeAssert{};
139 
140         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
141         auto result =
142             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
143         EXPECT_EQ(true, result);
144 
145         // Need just the ledsAssserted populated with these.
146         std::set<Layout::LedAction> refAssert = {
147             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
148             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
149             {"Three", phosphor::led::Layout::On, 0, 0,
150              phosphor::led::Layout::On},
151         };
152         EXPECT_EQ(refAssert.size(), ledsAssert.size());
153         EXPECT_EQ(0, ledsDeAssert.size());
154 
155         // difference of refAssert and ledsAssert must be null.
156         Manager::group temp{};
157         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
158                             refAssert.begin(), refAssert.end(),
159                             std::inserter(temp, temp.begin()));
160         EXPECT_EQ(0, temp.size());
161     }
162 }
163 
164 /** @brief Assert Multiple LEDs to Blink */
165 TEST_F(LedTest, assertMultipleLedBlink)
166 {
167     Manager manager(bus, multipleLedsBlink);
168     {
169         // Assert the LEDs.
170         Manager::group ledsAssert{};
171         Manager::group ledsDeAssert{};
172 
173         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
174         auto result =
175             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
176         EXPECT_EQ(true, result);
177 
178         // Need just the ledsAssserted populated with these.
179         std::set<Layout::LedAction> refAssert = {
180             {"One", phosphor::led::Layout::Blink, 0, 0,
181              phosphor::led::Layout::Blink},
182             {"Two", phosphor::led::Layout::Blink, 0, 0,
183              phosphor::led::Layout::Blink},
184             {"Three", phosphor::led::Layout::Blink, 0, 0,
185              phosphor::led::Layout::Blink},
186         };
187         EXPECT_EQ(refAssert.size(), ledsAssert.size());
188         EXPECT_EQ(0, ledsDeAssert.size());
189 
190         // difference of refAssert and ledsAssert must be null.
191         Manager::group temp{};
192         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
193                             refAssert.begin(), refAssert.end(),
194                             std::inserter(temp, temp.begin()));
195         EXPECT_EQ(0, temp.size());
196     }
197 }
198 
199 /** @brief Assert Multiple LEDs to Blink, DeAssert */
200 TEST_F(LedTest, assertMultipleLedBlinkAndDeAssert)
201 {
202     Manager manager(bus, multipleLedsBlink);
203     {
204         // Assert the LEDs.
205         Manager::group ledsAssert{};
206         Manager::group ledsDeAssert{};
207 
208         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
209         auto result =
210             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
211         EXPECT_EQ(true, result);
212 
213         // Need just the ledsAssserted populated with these.
214         std::set<Layout::LedAction> refAssert = {
215             {"One", phosphor::led::Layout::Blink, 0, 0,
216              phosphor::led::Layout::Blink},
217             {"Two", phosphor::led::Layout::Blink, 0, 0,
218              phosphor::led::Layout::Blink},
219             {"Three", phosphor::led::Layout::Blink, 0, 0,
220              phosphor::led::Layout::Blink},
221         };
222         EXPECT_EQ(refAssert.size(), ledsAssert.size());
223         EXPECT_EQ(0, ledsDeAssert.size());
224 
225         // difference of refAssert and ledsAssert must be null.
226         Manager::group temp{};
227         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
228                             refAssert.begin(), refAssert.end(),
229                             std::inserter(temp, temp.begin()));
230         EXPECT_EQ(0, temp.size());
231     }
232     {
233         // Assert the LEDs.
234         Manager::group ledsAssert{};
235         Manager::group ledsDeAssert{};
236 
237         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
238         auto result =
239             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
240         EXPECT_EQ(false, result);
241 
242         // Need just the ledsAssserted populated with these.
243         std::set<Layout::LedAction> refDeAssert = {
244             {"One", phosphor::led::Layout::Blink, 0, 0,
245              phosphor::led::Layout::Blink},
246             {"Two", phosphor::led::Layout::Blink, 0, 0,
247              phosphor::led::Layout::Blink},
248             {"Three", phosphor::led::Layout::Blink, 0, 0,
249              phosphor::led::Layout::Blink},
250         };
251         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
252         EXPECT_EQ(0, ledsAssert.size());
253 
254         // difference of refDeAssert and ledsDeAssert must be null.
255         Manager::group temp{};
256         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
257                             refDeAssert.begin(), refDeAssert.end(),
258                             std::inserter(temp, temp.begin()));
259         EXPECT_EQ(0, temp.size());
260     }
261 }
262 
263 /** @brief Assert Multiple LEDs to Blink, DeAssert Twice */
264 TEST_F(LedTest, assertMultipleLedBlinkAndDeAssertTwice)
265 {
266     Manager manager(bus, multipleLedsBlink);
267     {
268         // Assert the LEDs.
269         Manager::group ledsAssert{};
270         Manager::group ledsDeAssert{};
271 
272         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
273         auto result =
274             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
275         EXPECT_EQ(true, result);
276 
277         // Need just the ledsAssserted populated with these.
278         std::set<Layout::LedAction> refAssert = {
279             {"One", phosphor::led::Layout::Blink, 0, 0,
280              phosphor::led::Layout::Blink},
281             {"Two", phosphor::led::Layout::Blink, 0, 0,
282              phosphor::led::Layout::Blink},
283             {"Three", phosphor::led::Layout::Blink, 0, 0,
284              phosphor::led::Layout::Blink},
285         };
286         EXPECT_EQ(refAssert.size(), ledsAssert.size());
287         EXPECT_EQ(0, ledsDeAssert.size());
288 
289         // difference of refAssert and ledsAssert must be null.
290         Manager::group temp{};
291         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
292                             refAssert.begin(), refAssert.end(),
293                             std::inserter(temp, temp.begin()));
294         EXPECT_EQ(0, temp.size());
295     }
296     {
297         // DeAssert the LEDs.
298         Manager::group ledsAssert{};
299         Manager::group ledsDeAssert{};
300 
301         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
302         auto result =
303             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
304         EXPECT_EQ(false, result);
305 
306         // Need just the ledsAssserted populated with these.
307         std::set<Layout::LedAction> refDeAssert = {
308             {"One", phosphor::led::Layout::Blink, 0, 0,
309              phosphor::led::Layout::Blink},
310             {"Two", phosphor::led::Layout::Blink, 0, 0,
311              phosphor::led::Layout::Blink},
312             {"Three", phosphor::led::Layout::Blink, 0, 0,
313              phosphor::led::Layout::Blink},
314         };
315         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
316         EXPECT_EQ(0, ledsAssert.size());
317 
318         // difference of refDeAssert and ledsDeAssert must be null.
319         Manager::group temp{};
320         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
321                             refDeAssert.begin(), refDeAssert.end(),
322                             std::inserter(temp, temp.begin()));
323         EXPECT_EQ(0, temp.size());
324     }
325     {
326         // DeAssert the LEDs.
327         Manager::group ledsAssert{};
328         Manager::group ledsDeAssert{};
329 
330         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLeds";
331         auto result =
332             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
333         EXPECT_EQ(false, result);
334         EXPECT_EQ(0, ledsDeAssert.size());
335         EXPECT_EQ(0, ledsAssert.size());
336     }
337 }
338 
339 /** @brief Assert Multiple LEDs to mix of On and Blink */
340 TEST_F(LedTest, assertMultipleLedOnAndBlink)
341 {
342     Manager manager(bus, multipleLedsOnAndBlink);
343     {
344         // Assert the LEDs.
345         Manager::group ledsAssert{};
346         Manager::group ledsDeAssert{};
347 
348         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsMix";
349         auto result =
350             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
351         EXPECT_EQ(true, result);
352 
353         // Need just the ledsAssserted populated with these.
354         std::set<Layout::LedAction> refAssert = {
355             {"One", phosphor::led::Layout::Blink, 0, 0,
356              phosphor::led::Layout::Blink},
357             {"Two", phosphor::led::Layout::On, 0, 0,
358              phosphor::led::Layout::Blink},
359             {"Three", phosphor::led::Layout::Blink, 0, 0,
360              phosphor::led::Layout::On},
361             {"Four", phosphor::led::Layout::On, 0, 0,
362              phosphor::led::Layout::Blink},
363             {"Five", phosphor::led::Layout::On, 0, 0,
364              phosphor::led::Layout::Blink},
365         };
366         EXPECT_EQ(refAssert.size(), ledsAssert.size());
367         EXPECT_EQ(0, ledsDeAssert.size());
368 
369         // difference of refAssert and ledsAssert must be null.
370         Manager::group temp{};
371         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
372                             refAssert.begin(), refAssert.end(),
373                             std::inserter(temp, temp.begin()));
374         EXPECT_EQ(0, temp.size());
375     }
376 }
377 
378 /** @brief Assert 2 groups having distinct LEDs */
379 TEST_F(LedTest, assertTwoGroupsOnWithDistinctLEDOn)
380 {
381     Manager manager(bus, twoGroupsWithDistinctLEDsOn);
382     {
383         // Assert Set-A
384         Manager::group ledsAssert{};
385         Manager::group ledsDeAssert{};
386 
387         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
388         auto result =
389             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
390         EXPECT_EQ(true, result);
391 
392         // Need just the ledsAssserted populated with these.
393         std::set<Layout::LedAction> refAssert = {
394             {"One", phosphor::led::Layout::On, 0, 0,
395              phosphor::led::Layout::Blink},
396             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
397             {"Three", phosphor::led::Layout::On, 0, 0,
398              phosphor::led::Layout::Blink},
399         };
400         EXPECT_EQ(refAssert.size(), ledsAssert.size());
401         EXPECT_EQ(0, ledsDeAssert.size());
402 
403         // difference of refAssert and ledsAssert must be null.
404         Manager::group temp{};
405         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
406                             refAssert.begin(), refAssert.end(),
407                             std::inserter(temp, temp.begin()));
408         EXPECT_EQ(0, temp.size());
409     }
410     {
411         // Assert Set-B
412         Manager::group ledsAssert{};
413         Manager::group ledsDeAssert{};
414 
415         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
416         auto result =
417             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
418         EXPECT_EQ(true, result);
419 
420         // Need just the ledsAssserted populated with these.
421         std::set<Layout::LedAction> refAssert = {
422             {"Four", phosphor::led::Layout::On, 0, 0,
423              phosphor::led::Layout::Blink},
424             {"Five", phosphor::led::Layout::On, 0, 0,
425              phosphor::led::Layout::Blink},
426             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
427         };
428         EXPECT_EQ(refAssert.size(), ledsAssert.size());
429         EXPECT_EQ(0, ledsDeAssert.size());
430 
431         // difference of refAssert and ledsAssert must be null.
432         Manager::group temp{};
433         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
434                             refAssert.begin(), refAssert.end(),
435                             std::inserter(temp, temp.begin()));
436         EXPECT_EQ(0, temp.size());
437     }
438 }
439 
440 /** @brief Assert 2 groups having one of the LEDs common */
441 TEST_F(LedTest, asserttwoGroupsWithOneComonLEDOn)
442 {
443     Manager manager(bus, twoGroupsWithOneComonLEDOn);
444     {
445         // Assert Set-A
446         Manager::group ledsAssert{};
447         Manager::group ledsDeAssert{};
448 
449         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
450         auto result =
451             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
452         EXPECT_EQ(true, result);
453 
454         // Need just the ledsAssserted populated with these.
455         std::set<Layout::LedAction> refAssert = {
456             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
457             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
458             {"Three", phosphor::led::Layout::On, 0, 0,
459              phosphor::led::Layout::On},
460         };
461         EXPECT_EQ(refAssert.size(), ledsAssert.size());
462         EXPECT_EQ(0, ledsDeAssert.size());
463 
464         // difference of refAssert and ledsAssert must be null.
465         Manager::group temp{};
466         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
467                             refAssert.begin(), refAssert.end(),
468                             std::inserter(temp, temp.begin()));
469         EXPECT_EQ(0, temp.size());
470     }
471     {
472         // Assert Set-B
473         Manager::group ledsAssert{};
474         Manager::group ledsDeAssert{};
475 
476         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
477         auto result =
478             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
479         EXPECT_EQ(true, result);
480 
481         // Need just the ledsAssserted populated with these.
482         std::set<Layout::LedAction> refAssert = {
483             {"Four", phosphor::led::Layout::On, 0, 0,
484              phosphor::led::Layout::On},
485             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
486         };
487         EXPECT_EQ(refAssert.size(), ledsAssert.size());
488         EXPECT_EQ(0, ledsDeAssert.size());
489 
490         // difference of refAssert and ledsAssert must be null.
491         Manager::group temp{};
492         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
493                             refAssert.begin(), refAssert.end(),
494                             std::inserter(temp, temp.begin()));
495         EXPECT_EQ(0, temp.size());
496     }
497 }
498 
499 /** @brief Assert 2 groups having one of the LEDs common but having Blink as
500  * priority and Deassert*/
501 TEST_F(LedTest, asserttwoGroupsWithOneComonLEDOnOneLEDBlinkPriorityAndDeAssertB)
502 {
503     Manager manager(bus, twoGroupsWithOneComonLEDOnOneLEDBlinkPriority);
504     {
505         // Assert Set-A
506         Manager::group ledsAssert{};
507         Manager::group ledsDeAssert{};
508 
509         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
510         auto result =
511             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
512         EXPECT_EQ(true, result);
513 
514         // Need just the ledsAssserted populated with these.
515         std::set<Layout::LedAction> refAssert = {
516             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
517             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
518             {"Three", phosphor::led::Layout::Blink, 0, 0,
519              phosphor::led::Layout::Blink},
520         };
521         EXPECT_EQ(refAssert.size(), ledsAssert.size());
522         EXPECT_EQ(0, ledsDeAssert.size());
523 
524         // difference of refAssert and ledsAssert must be null.
525         Manager::group temp{};
526         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
527                             refAssert.begin(), refAssert.end(),
528                             std::inserter(temp, temp.begin()));
529         EXPECT_EQ(0, temp.size());
530     }
531     {
532         // Assert Set-B
533         Manager::group ledsAssert{};
534         Manager::group ledsDeAssert{};
535 
536         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
537         auto result =
538             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
539         EXPECT_EQ(true, result);
540 
541         // Need just the ledsAssserted populated with these.
542         // Does not action on [Three] since  priority is [Blink]
543         std::set<Layout::LedAction> refAssert = {
544             {"Four", phosphor::led::Layout::On, 0, 0,
545              phosphor::led::Layout::On},
546             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
547         };
548         EXPECT_EQ(refAssert.size(), ledsAssert.size());
549         EXPECT_EQ(0, ledsDeAssert.size());
550 
551         // difference of refAssert and ledsAssert must be null.
552         Manager::group temp{};
553         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
554                             refAssert.begin(), refAssert.end(),
555                             std::inserter(temp, temp.begin()));
556         EXPECT_EQ(0, temp.size());
557     }
558     {
559         // De-Assert Set-B
560         Manager::group ledsAssert{};
561         Manager::group ledsDeAssert{};
562 
563         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
564         auto result =
565             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
566         EXPECT_EQ(false, result);
567 
568         // Need just the ledsDeAssserted populated with these.
569         std::set<Layout::LedAction> refDeAssert = {
570             {"Four", phosphor::led::Layout::On, 0, 0,
571              phosphor::led::Layout::On},
572             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
573         };
574         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
575         EXPECT_EQ(0, ledsAssert.size());
576 
577         // difference of refDeAssert and ledsDeAssert must be null.
578         // [Three] is not touched since its already [Blink]
579         Manager::group temp{};
580         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
581                             refDeAssert.begin(), refDeAssert.end(),
582                             std::inserter(temp, temp.begin()));
583         EXPECT_EQ(0, temp.size());
584     }
585 }
586 
587 /** @brief Assert 2 groups having one of the LEDs common but having Blink as
588  * priority and Deassert A */
589 TEST_F(LedTest, asserttwoGroupsWithOneComonLEDOnOneLEDBlinkPriorityAndDeAssertA)
590 {
591     Manager manager(bus, twoGroupsWithOneComonLEDOnOneLEDBlinkPriority);
592     {
593         // Assert Set-A
594         Manager::group ledsAssert{};
595         Manager::group ledsDeAssert{};
596 
597         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
598         auto result =
599             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
600         EXPECT_EQ(true, result);
601 
602         // Need just the ledsAssserted populated with these.
603         std::set<Layout::LedAction> refAssert = {
604             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
605             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
606             {"Three", phosphor::led::Layout::Blink, 0, 0,
607              phosphor::led::Layout::Blink},
608         };
609         EXPECT_EQ(refAssert.size(), ledsAssert.size());
610         EXPECT_EQ(0, ledsDeAssert.size());
611 
612         // difference of refAssert and ledsAssert must be null.
613         Manager::group temp{};
614         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
615                             refAssert.begin(), refAssert.end(),
616                             std::inserter(temp, temp.begin()));
617         EXPECT_EQ(0, temp.size());
618     }
619     {
620         // Assert Set-B
621         Manager::group ledsAssert{};
622         Manager::group ledsDeAssert{};
623 
624         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
625         auto result =
626             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
627         EXPECT_EQ(true, result);
628 
629         // Need just the ledsAssserted populated with these.
630         // [Three] does not get actioned since it has Blink priority
631         std::set<Layout::LedAction> refAssert = {
632             {"Four", phosphor::led::Layout::On, 0, 0,
633              phosphor::led::Layout::On},
634             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
635         };
636         EXPECT_EQ(refAssert.size(), ledsAssert.size());
637         EXPECT_EQ(0, ledsDeAssert.size());
638 
639         // difference of refAssert and ledsAssert must be null.
640         Manager::group temp{};
641         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
642                             refAssert.begin(), refAssert.end(),
643                             std::inserter(temp, temp.begin()));
644         EXPECT_EQ(0, temp.size());
645     }
646     {
647         // De-Assert Set-A
648         Manager::group ledsAssert{};
649         Manager::group ledsDeAssert{};
650 
651         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
652         auto result =
653             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
654         EXPECT_EQ(false, result);
655 
656         // Need just the ledsDeAssserted populated with these.
657         std::set<Layout::LedAction> refDeAssert = {
658             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
659             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
660         };
661         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
662 
663         // difference of refDeAssert and ledsDeAssert must be null.
664         Manager::group temp{};
665         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
666                             refDeAssert.begin(), refDeAssert.end(),
667                             std::inserter(temp, temp.begin()));
668         EXPECT_EQ(0, temp.size());
669 
670         // Need just the ledsAssert populated with these.
671         std::set<Layout::LedAction> refAssert = {
672             {"Three", phosphor::led::Layout::On, 0, 0,
673              phosphor::led::Layout::Blink},
674         };
675         EXPECT_EQ(refAssert.size(), ledsAssert.size());
676 
677         // difference of refAssert and ledsAssert must be null.
678         Manager::group temp1{};
679         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
680                             refAssert.begin(), refAssert.end(),
681                             std::inserter(temp1, temp1.begin()));
682         EXPECT_EQ(0, temp1.size());
683     }
684 }
685 
686 /** @brief Assert 2 groups having one of the LEDs common but having ON as
687  * priority And Deassert A */
688 TEST_F(LedTest, asserttwoGroupsWithOneComonLEDOnOneLEDOnPriorityAndDeAssertA)
689 {
690     Manager manager(bus, twoGroupsWithOneComonLEDOnPriority);
691     {
692         // Assert Set-A
693         Manager::group ledsAssert{};
694         Manager::group ledsDeAssert{};
695 
696         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
697         auto result =
698             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
699         EXPECT_EQ(true, result);
700 
701         // Need just the ledsAssserted populated with these.
702         std::set<Layout::LedAction> refAssert = {
703             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
704             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
705             {"Three", phosphor::led::Layout::Blink, 0, 0,
706              phosphor::led::Layout::On},
707         };
708         EXPECT_EQ(refAssert.size(), ledsAssert.size());
709         EXPECT_EQ(0, ledsDeAssert.size());
710 
711         // difference of refAssert and ledsAssert must be null.
712         Manager::group temp{};
713         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
714                             refAssert.begin(), refAssert.end(),
715                             std::inserter(temp, temp.begin()));
716         EXPECT_EQ(0, temp.size());
717     }
718     {
719         // Assert Set-B
720         Manager::group ledsAssert{};
721         Manager::group ledsDeAssert{};
722 
723         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
724         auto result =
725             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
726         EXPECT_EQ(true, result);
727 
728         // Need just the ledsAssserted populated with these.
729         // Three is set to ON due to ON priority.
730         std::set<Layout::LedAction> refAssert = {
731             {"Three", phosphor::led::Layout::On, 0, 0,
732              phosphor::led::Layout::On},
733             {"Four", phosphor::led::Layout::On, 0, 0,
734              phosphor::led::Layout::On},
735             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
736         };
737         EXPECT_EQ(refAssert.size(), ledsAssert.size());
738         EXPECT_EQ(0, ledsDeAssert.size());
739 
740         // difference of refAssert and ledsAssert must be null.
741         Manager::group temp{};
742         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
743                             refAssert.begin(), refAssert.end(),
744                             std::inserter(temp, temp.begin()));
745     }
746     {
747         // De-Assert Set-A
748         Manager::group ledsAssert{};
749         Manager::group ledsDeAssert{};
750 
751         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
752         auto result =
753             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
754         EXPECT_EQ(false, result);
755 
756         // Need just the ledsDeAssserted populated with these.
757         // [Three] stays in [On] since [B] has it [On]
758         std::set<Layout::LedAction> refDeAssert = {
759             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
760             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
761         };
762         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
763         EXPECT_EQ(0, ledsAssert.size());
764 
765         // difference of refDeAssert and ledsDeAssert must be null.
766         Manager::group temp{};
767         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
768                             refDeAssert.begin(), refDeAssert.end(),
769                             std::inserter(temp, temp.begin()));
770         EXPECT_EQ(0, temp.size());
771     }
772 }
773 
774 /** @brief Assert 2 groups having one of the LEDs common but having ON as
775  * priority And Deassert B */
776 TEST_F(LedTest, asserttwoGroupsWithOneComonLEDOnOneLEDOnPriorityAndDeAssertB)
777 {
778     Manager manager(bus, twoGroupsWithOneComonLEDOnPriority);
779     {
780         // Assert Set-A
781         Manager::group ledsAssert{};
782         Manager::group ledsDeAssert{};
783 
784         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
785         auto result =
786             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
787         EXPECT_EQ(true, result);
788 
789         // Need just the ledsAssserted populated with these.
790         std::set<Layout::LedAction> refAssert = {
791             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
792             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
793             {"Three", phosphor::led::Layout::Blink, 0, 0,
794              phosphor::led::Layout::On},
795         };
796         EXPECT_EQ(refAssert.size(), ledsAssert.size());
797         EXPECT_EQ(0, ledsDeAssert.size());
798 
799         // difference of refAssert and ledsAssert must be null.
800         Manager::group temp{};
801         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
802                             refAssert.begin(), refAssert.end(),
803                             std::inserter(temp, temp.begin()));
804         EXPECT_EQ(0, temp.size());
805     }
806     {
807         // Assert Set-B
808         Manager::group ledsAssert{};
809         Manager::group ledsDeAssert{};
810 
811         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
812         auto result =
813             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
814         EXPECT_EQ(true, result);
815 
816         // Need just the ledsAssserted populated with these.
817         // Three is set to ON due to ON priority.
818         std::set<Layout::LedAction> refAssert = {
819             {"Three", phosphor::led::Layout::On, 0, 0,
820              phosphor::led::Layout::On},
821             {"Four", phosphor::led::Layout::On, 0, 0,
822              phosphor::led::Layout::On},
823             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
824         };
825         EXPECT_EQ(refAssert.size(), ledsAssert.size());
826         EXPECT_EQ(0, ledsDeAssert.size());
827 
828         // difference of refAssert and ledsAssert must be null.
829         Manager::group temp{};
830         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
831                             refAssert.begin(), refAssert.end(),
832                             std::inserter(temp, temp.begin()));
833     }
834     {
835         // De-Assert Set-B
836         Manager::group ledsAssert{};
837         Manager::group ledsDeAssert{};
838 
839         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
840         auto result =
841             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
842         EXPECT_EQ(false, result);
843 
844         // Need just the ledsDeAssserted populated with these.
845         std::set<Layout::LedAction> refDeAssert = {
846             {"Four", phosphor::led::Layout::On, 0, 0,
847              phosphor::led::Layout::On},
848             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
849         };
850         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
851 
852         // difference of refDeAssert and ledsDeAssert must be null.
853         Manager::group temp{};
854         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
855                             refDeAssert.begin(), refDeAssert.end(),
856                             std::inserter(temp, temp.begin()));
857         EXPECT_EQ(0, temp.size());
858 
859         // Need just the ledsAssert populated with these.
860         // Since [Three] stood [On], need to go back to [Blink]
861         std::set<Layout::LedAction> refAssert = {
862             {"Three", phosphor::led::Layout::Blink, 0, 0,
863              phosphor::led::Layout::On},
864         };
865         EXPECT_EQ(refAssert.size(), ledsAssert.size());
866 
867         // difference of refAssert and ledsAssert must be null.
868         Manager::group temp1{};
869         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
870                             refAssert.begin(), refAssert.end(),
871                             std::inserter(temp, temp.begin()));
872         EXPECT_EQ(0, temp.size());
873     }
874 }
875 
876 /** @brief Assert 2 groups having multiple common LEDs in Same State */
877 TEST_F(LedTest, assertTwoGroupsWithMultiplComonLEDOnAndDeAssert)
878 {
879     Manager manager(bus, twoGroupsWithMultiplComonLEDOn);
880     {
881         // Assert Set-B
882         Manager::group ledsAssert{};
883         Manager::group ledsDeAssert{};
884 
885         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
886         auto result =
887             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
888         EXPECT_EQ(true, result);
889 
890         // Need just the ledsAssserted populated with these.
891         std::set<Layout::LedAction> refAssert = {
892             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
893             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
894             {"Three", phosphor::led::Layout::On, 0, 0,
895              phosphor::led::Layout::On},
896             {"Seven", phosphor::led::Layout::On, 0, 0,
897              phosphor::led::Layout::On},
898         };
899         EXPECT_EQ(refAssert.size(), ledsAssert.size());
900         EXPECT_EQ(0, ledsDeAssert.size());
901 
902         // difference of refAssert and ledsAssert must be null.
903         Manager::group temp{};
904         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
905                             refAssert.begin(), refAssert.end(),
906                             std::inserter(temp, temp.begin()));
907         EXPECT_EQ(0, temp.size());
908     }
909     {
910         // Assert Set-A
911         Manager::group ledsAssert{};
912         Manager::group ledsDeAssert{};
913 
914         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
915         auto result =
916             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
917         EXPECT_EQ(true, result);
918 
919         // Need just the ledsAssserted populated with these.
920         std::set<Layout::LedAction> refAssert = {
921             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
922         };
923         EXPECT_EQ(refAssert.size(), ledsAssert.size());
924         EXPECT_EQ(0, ledsDeAssert.size());
925 
926         // difference of refAssert and ledsAssert must be null.
927         Manager::group temp{};
928         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
929                             refAssert.begin(), refAssert.end(),
930                             std::inserter(temp, temp.begin()));
931         EXPECT_EQ(0, temp.size());
932     }
933     {
934         // De-Assert Set-B
935         Manager::group ledsAssert{};
936         Manager::group ledsDeAssert{};
937 
938         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
939         auto result =
940             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
941         EXPECT_EQ(false, result);
942 
943         // Need just the ledsDeAssserted populated with these.
944         std::set<Layout::LedAction> refDeAssert = {
945             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
946             {"Seven", phosphor::led::Layout::On, 0, 0,
947              phosphor::led::Layout::On},
948         };
949         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
950         EXPECT_EQ(0, ledsAssert.size());
951 
952         // difference of refDeAssert and ledsDeAssert must be null.
953         Manager::group temp{};
954         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
955                             refDeAssert.begin(), refDeAssert.end(),
956                             std::inserter(temp, temp.begin()));
957         EXPECT_EQ(0, temp.size());
958     }
959 }
960 
961 /** @brief Assert 2 groups having multiple LEDs common in different state */
962 TEST_F(LedTest, assertTwoGroupsWithMultipleComonLEDInDifferentStateBandA)
963 {
964     Manager manager(bus, twoGroupsWithMultipleComonLEDInDifferentState);
965     {
966         // Assert Set-B
967         Manager::group ledsAssert{};
968         Manager::group ledsDeAssert{};
969 
970         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
971         auto result =
972             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
973         EXPECT_EQ(true, result);
974 
975         // Need just the ledsAssserted populated with these.
976         std::set<Layout::LedAction> refAssert = {
977             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
978             {"Three", phosphor::led::Layout::Blink, 0, 0,
979              phosphor::led::Layout::On},
980             {"Five", phosphor::led::Layout::On, 0, 0,
981              phosphor::led::Layout::On},
982             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
983         };
984         EXPECT_EQ(refAssert.size(), ledsAssert.size());
985         EXPECT_EQ(0, ledsDeAssert.size());
986 
987         // difference of refAssert and ledsAssert must be null.
988         Manager::group temp{};
989         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
990                             refAssert.begin(), refAssert.end(),
991                             std::inserter(temp, temp.begin()));
992         EXPECT_EQ(0, temp.size());
993     }
994     {
995         // Assert Set-A
996         Manager::group ledsAssert{};
997         Manager::group ledsDeAssert{};
998 
999         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1000         auto result =
1001             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1002         EXPECT_EQ(true, result);
1003 
1004         // Need just the ledsAssserted populated with these
1005         // [Two] remains [On] due to higher priority.
1006         // [Three] remains [Blink]
1007         std::set<Layout::LedAction> refAssert = {
1008             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1009             {"Four", phosphor::led::Layout::On, 0, 0,
1010              phosphor::led::Layout::On},
1011         };
1012         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1013         EXPECT_EQ(0, ledsDeAssert.size());
1014 
1015         // difference of refAssert and ledsAssert must be null.
1016         Manager::group temp{};
1017         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1018                             refAssert.begin(), refAssert.end(),
1019                             std::inserter(temp, temp.begin()));
1020         EXPECT_EQ(0, temp.size());
1021     }
1022 }
1023 
1024 /** @brief Assert 2 groups having multiple LEDs common in different state */
1025 TEST_F(LedTest, assertTwoGroupsWithMultipleComonLEDInDifferentStateAtoB)
1026 {
1027     Manager manager(bus, twoGroupsWithMultipleComonLEDInDifferentState);
1028     {
1029         // Assert Set-A
1030         Manager::group ledsAssert{};
1031         Manager::group ledsDeAssert{};
1032 
1033         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1034         auto result =
1035             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1036         EXPECT_EQ(true, result);
1037 
1038         // Need just the ledsAssserted populated with these.'Two' gets to Blink
1039         // due to higher priority.
1040         std::set<Layout::LedAction> refAssert = {
1041             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1042             {"Two", phosphor::led::Layout::Blink, 0, 0,
1043              phosphor::led::Layout::On},
1044             {"Three", phosphor::led::Layout::Blink, 0, 0,
1045              phosphor::led::Layout::On},
1046             {"Four", phosphor::led::Layout::On, 0, 0,
1047              phosphor::led::Layout::On},
1048         };
1049         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1050         EXPECT_EQ(0, ledsDeAssert.size());
1051 
1052         // difference of refAssert and ledsAssert must be null.
1053         Manager::group temp{};
1054         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1055                             refAssert.begin(), refAssert.end(),
1056                             std::inserter(temp, temp.begin()));
1057         EXPECT_EQ(0, temp.size());
1058     }
1059     {
1060         // Assert Set-B
1061         Manager::group ledsAssert{};
1062         Manager::group ledsDeAssert{};
1063 
1064         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1065         auto result =
1066             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1067         EXPECT_EQ(true, result);
1068 
1069         // Need just the ledsAssserted populated with these.
1070         // [Three] remains [Blink] from previous
1071         // [Two] moves to [On] from [Blink] due to [On] priority
1072         std::set<Layout::LedAction> refAssert = {
1073             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1074             {"Five", phosphor::led::Layout::On, 0, 0,
1075              phosphor::led::Layout::On},
1076             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1077         };
1078         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1079         EXPECT_EQ(0, ledsDeAssert.size());
1080 
1081         // difference of refAssert and ledsAssert must be null.
1082         Manager::group temp{};
1083         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1084                             refAssert.begin(), refAssert.end(),
1085                             std::inserter(temp, temp.begin()));
1086         EXPECT_EQ(0, temp.size());
1087     }
1088 }
1089 
1090 /** @brief Assert 2 groups having multiple LEDs common in different state
1091  *  DeAssert twice
1092  */
1093 TEST_F(LedTest,
1094        assertTwoGroupsWithMultipleComonLEDInDifferentStateAtoBDeAssertTwice)
1095 {
1096     Manager manager(bus, twoGroupsWithMultipleComonLEDInDifferentState);
1097     {
1098         // Assert Set-A
1099         Manager::group ledsAssert{};
1100         Manager::group ledsDeAssert{};
1101 
1102         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1103         auto result =
1104             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1105         EXPECT_EQ(true, result);
1106 
1107         // Need just the ledsAssserted populated with these.
1108         std::set<Layout::LedAction> refAssert = {
1109             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1110             {"Two", phosphor::led::Layout::Blink, 0, 0,
1111              phosphor::led::Layout::On},
1112             {"Three", phosphor::led::Layout::Blink, 0, 0,
1113              phosphor::led::Layout::On},
1114             {"Four", phosphor::led::Layout::On, 0, 0,
1115              phosphor::led::Layout::On},
1116         };
1117         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1118         EXPECT_EQ(0, ledsDeAssert.size());
1119 
1120         // difference of refAssert and ledsAssert must be null.
1121         Manager::group temp{};
1122         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1123                             refAssert.begin(), refAssert.end(),
1124                             std::inserter(temp, temp.begin()));
1125         EXPECT_EQ(0, temp.size());
1126     }
1127     {
1128         // Assert Set-B
1129         Manager::group ledsAssert{};
1130         Manager::group ledsDeAssert{};
1131 
1132         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1133         auto result =
1134             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1135         EXPECT_EQ(true, result);
1136 
1137         // Need just the ledsAssserted populated with these.
1138         // [Two] turns [On] due to priority
1139         // [Three] remains [Blink]
1140         std::set<Layout::LedAction> refAssert = {
1141             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1142             {"Five", phosphor::led::Layout::On, 0, 0,
1143              phosphor::led::Layout::On},
1144             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1145         };
1146         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1147         EXPECT_EQ(0, ledsDeAssert.size());
1148 
1149         // difference of refAssert and ledsAssert must be null.
1150         Manager::group temp{};
1151         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1152                             refAssert.begin(), refAssert.end(),
1153                             std::inserter(temp, temp.begin()));
1154         EXPECT_EQ(0, temp.size());
1155     }
1156     {
1157         // DeAssert Set-B
1158         Manager::group ledsAssert{};
1159         Manager::group ledsDeAssert{};
1160 
1161         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1162         auto result =
1163             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1164         EXPECT_EQ(false, result);
1165 
1166         // Need just the ledsAssserted populated with these.
1167         std::set<Layout::LedAction> refDeAssert = {
1168             {"Five", phosphor::led::Layout::On, 0, 0,
1169              phosphor::led::Layout::On},
1170             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1171         };
1172         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1173 
1174         // difference of refDeAssert and ledsDeAssert must be null.
1175         Manager::group temp{};
1176         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
1177                             refDeAssert.begin(), refDeAssert.end(),
1178                             std::inserter(temp, temp.begin()));
1179         EXPECT_EQ(0, temp.size());
1180 
1181         // Need just the ledsAssert populated with these.
1182         // [Two] will go back to [Blink] from [On]
1183         std::set<Layout::LedAction> refAssert = {
1184             {"Two", phosphor::led::Layout::Blink, 0, 0,
1185              phosphor::led::Layout::On},
1186         };
1187         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1188 
1189         // difference of refAssert and ledsAssert must be null.
1190         Manager::group temp1{};
1191         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1192                             refAssert.begin(), refAssert.end(),
1193                             std::inserter(temp1, temp1.begin()));
1194         EXPECT_EQ(0, temp1.size());
1195     }
1196     {
1197         // DeAssert Set-A
1198         Manager::group ledsAssert{};
1199         Manager::group ledsDeAssert{};
1200 
1201         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1202         auto result =
1203             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1204         EXPECT_EQ(false, result);
1205 
1206         // Need just the ledsAssserted populated with these.
1207         std::set<Layout::LedAction> refDeAssert = {
1208             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1209             {"Two", phosphor::led::Layout::Blink, 0, 0,
1210              phosphor::led::Layout::On},
1211             {"Three", phosphor::led::Layout::Blink, 0, 0,
1212              phosphor::led::Layout::On},
1213             {"Four", phosphor::led::Layout::On, 0, 0,
1214              phosphor::led::Layout::On},
1215         };
1216         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1217         EXPECT_EQ(0, ledsAssert.size());
1218 
1219         // difference of refDeAssert and ledsDeAssert must be null.
1220         Manager::group temp{};
1221         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
1222                             refDeAssert.begin(), refDeAssert.end(),
1223                             std::inserter(temp, temp.begin()));
1224         EXPECT_EQ(0, temp.size());
1225     }
1226     {
1227         // DeAssert Set-A again and make sure we get all empty
1228         Manager::group ledsAssert{};
1229         Manager::group ledsDeAssert{};
1230 
1231         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1232         auto result =
1233             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1234         EXPECT_EQ(false, result);
1235         EXPECT_EQ(0, ledsDeAssert.size());
1236         EXPECT_EQ(0, ledsAssert.size());
1237     }
1238 }
1239 
1240 /** @brief Assert 2 groups having multiple LEDs common in different state and
1241  *  mixed priority. DeAssert-A
1242  */
1243 TEST_F(LedTest,
1244        assertTwoGroupsWithMultipleComonLEDInDifferentStateDiffPriorityAandB)
1245 {
1246     Manager manager(bus,
1247                     twoGroupsWithMultipleComonLEDInDifferentStateDiffPriority);
1248     {
1249         // Assert Set-A
1250         Manager::group ledsAssert{};
1251         Manager::group ledsDeAssert{};
1252 
1253         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1254         auto result =
1255             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1256         EXPECT_EQ(true, result);
1257 
1258         // Need just the ledsAssserted populated with these.
1259         std::set<Layout::LedAction> refAssert = {
1260             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1261             {"Two", phosphor::led::Layout::Blink, 0, 0,
1262              phosphor::led::Layout::On},
1263             {"Three", phosphor::led::Layout::On, 0, 0,
1264              phosphor::led::Layout::Blink},
1265             {"Four", phosphor::led::Layout::On, 0, 0,
1266              phosphor::led::Layout::On},
1267             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1268              phosphor::led::Layout::Blink},
1269         };
1270         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1271         EXPECT_EQ(0, ledsDeAssert.size());
1272 
1273         // difference of refAssert and ledsAssert must be null.
1274         Manager::group temp{};
1275         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1276                             refAssert.begin(), refAssert.end(),
1277                             std::inserter(temp, temp.begin()));
1278         EXPECT_EQ(0, temp.size());
1279     }
1280     {
1281         // Assert Set-B
1282         Manager::group ledsAssert{};
1283         Manager::group ledsDeAssert{};
1284 
1285         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1286         auto result =
1287             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1288         EXPECT_EQ(true, result);
1289 
1290         // Need just the ledsAssserted populated with these.
1291         // [Two] gets to [ON] due to higher priority.
1292         // [Three] remains on since it never was in [Blink] before
1293         // [Ten] remains [Blink] due to priority: [Blink]
1294         std::set<Layout::LedAction> refAssert = {
1295             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1296             {"Five", phosphor::led::Layout::On, 0, 0,
1297              phosphor::led::Layout::On},
1298             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1299         };
1300         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1301         EXPECT_EQ(0, ledsDeAssert.size());
1302 
1303         // difference of refAssert and ledsAssert must be null.
1304         Manager::group temp{};
1305         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1306                             refAssert.begin(), refAssert.end(),
1307                             std::inserter(temp, temp.begin()));
1308         EXPECT_EQ(0, temp.size());
1309     }
1310     {
1311         // De-Assert Set-A
1312         Manager::group ledsAssert{};
1313         Manager::group ledsDeAssert{};
1314 
1315         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1316         auto result =
1317             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1318         EXPECT_EQ(false, result);
1319 
1320         // Need just the ledsDeAsssert populated with these.
1321         std::set<Layout::LedAction> refDeAssert = {
1322             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1323             {"Four", phosphor::led::Layout::On, 0, 0,
1324              phosphor::led::Layout::On},
1325         };
1326         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1327 
1328         // Need just the ledsAsssert populated with these.
1329         // [Ten] Moves to [On] since there is no prior [Blink]
1330         // [Three] remains [On] since it never changed state.
1331         // [Two] remains [On] since it did not go back
1332         std::set<Layout::LedAction> refAssert = {
1333             {"Ten", phosphor::led::Layout::On, 0, 0,
1334              phosphor::led::Layout::Blink},
1335         };
1336         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1337 
1338         // difference of refAssert and ledsAssert must be null.
1339         Manager::group temp{};
1340         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1341                             refAssert.begin(), refAssert.end(),
1342                             std::inserter(temp, temp.begin()));
1343         EXPECT_EQ(0, temp.size());
1344     }
1345 }
1346 
1347 /** @brief Assert 2 groups having multiple LEDs common in different state and
1348  *  mixed priority. DeAssert-B
1349  */
1350 TEST_F(
1351     LedTest,
1352     assertTwoGroupsWithMultipleComonLEDInDifferentStateDiffPriorityAandBDeAssertB)
1353 {
1354     Manager manager(bus,
1355                     twoGroupsWithMultipleComonLEDInDifferentStateDiffPriority);
1356     {
1357         // Assert Set-A
1358         Manager::group ledsAssert{};
1359         Manager::group ledsDeAssert{};
1360 
1361         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1362         auto result =
1363             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1364         EXPECT_EQ(true, result);
1365 
1366         // Need just the ledsAssserted populated with these.
1367         std::set<Layout::LedAction> refAssert = {
1368             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1369             {"Two", phosphor::led::Layout::Blink, 0, 0,
1370              phosphor::led::Layout::On},
1371             {"Three", phosphor::led::Layout::On, 0, 0,
1372              phosphor::led::Layout::Blink},
1373             {"Four", phosphor::led::Layout::On, 0, 0,
1374              phosphor::led::Layout::On},
1375             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1376              phosphor::led::Layout::Blink},
1377         };
1378         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1379         EXPECT_EQ(0, ledsDeAssert.size());
1380 
1381         // difference of refAssert and ledsAssert must be null.
1382         Manager::group temp{};
1383         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1384                             refAssert.begin(), refAssert.end(),
1385                             std::inserter(temp, temp.begin()));
1386         EXPECT_EQ(0, temp.size());
1387     }
1388     {
1389         // Assert Set-B
1390         Manager::group ledsAssert{};
1391         Manager::group ledsDeAssert{};
1392 
1393         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1394         auto result =
1395             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1396         EXPECT_EQ(true, result);
1397 
1398         // Need just the ledsAssserted populated with these.
1399         // [Two] gets to [ON] due to higher priority.
1400         // [Three] remains on since it never was in [Blink] before
1401         // [Ten] remains [Blink] due to priority: [Blink]
1402         std::set<Layout::LedAction> refAssert = {
1403             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1404             {"Five", phosphor::led::Layout::On, 0, 0,
1405              phosphor::led::Layout::On},
1406             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1407         };
1408         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1409         EXPECT_EQ(0, ledsDeAssert.size());
1410 
1411         // difference of refAssert and ledsAssert must be null.
1412         Manager::group temp{};
1413         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1414                             refAssert.begin(), refAssert.end(),
1415                             std::inserter(temp, temp.begin()));
1416         EXPECT_EQ(0, temp.size());
1417     }
1418     {
1419         // De-Assert Set-B
1420         Manager::group ledsAssert{};
1421         Manager::group ledsDeAssert{};
1422 
1423         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1424         auto result =
1425             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1426         EXPECT_EQ(false, result);
1427 
1428         // Need just the ledsDeAsssert populated with these.
1429         std::set<Layout::LedAction> refDeAssert = {
1430             {"Five", phosphor::led::Layout::On, 0, 0,
1431              phosphor::led::Layout::On},
1432             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1433         };
1434         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1435 
1436         // Need just the ledsAsssert populated with these.
1437         // [Ten] remains [Blink] since it did not move to [On]
1438         // [Three] remains [On] since it never changed state.
1439         // [Two] moves to [Blink] since there is no prior [On]
1440         std::set<Layout::LedAction> refAssert = {
1441             {"Two", phosphor::led::Layout::Blink, 0, 0,
1442              phosphor::led::Layout::On},
1443         };
1444         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1445 
1446         // difference of refAssert and ledsAssert must be null.
1447         Manager::group temp{};
1448         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1449                             refAssert.begin(), refAssert.end(),
1450                             std::inserter(temp, temp.begin()));
1451         EXPECT_EQ(0, temp.size());
1452     }
1453 }
1454 
1455 /** @brief Assert 2 groups having multiple LEDs common in different state and
1456  *  mixed priority.
1457  */
1458 TEST_F(LedTest,
1459        assertTwoGroupsWithMultipleComonLEDInDifferentStateDiffPriorityBandA)
1460 {
1461     Manager manager(bus,
1462                     twoGroupsWithMultipleComonLEDInDifferentStateDiffPriority);
1463     {
1464         // Assert Set-B
1465         Manager::group ledsAssert{};
1466         Manager::group ledsDeAssert{};
1467 
1468         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1469         auto result =
1470             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1471         EXPECT_EQ(true, result);
1472 
1473         // Need just the ledsAssserted populated with these.
1474         std::set<Layout::LedAction> refAssert = {
1475             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1476             {"Three", phosphor::led::Layout::On, 0, 0,
1477              phosphor::led::Layout::Blink},
1478             {"Five", phosphor::led::Layout::On, 0, 0,
1479              phosphor::led::Layout::On},
1480             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1481             {"Ten", phosphor::led::Layout::On, 0, 0,
1482              phosphor::led::Layout::Blink},
1483         };
1484         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1485         EXPECT_EQ(0, ledsDeAssert.size());
1486 
1487         // difference of refAssert and ledsAssert must be null.
1488         Manager::group temp{};
1489         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1490                             refAssert.begin(), refAssert.end(),
1491                             std::inserter(temp, temp.begin()));
1492         EXPECT_EQ(0, temp.size());
1493     }
1494     {
1495         // Assert Set-A
1496         Manager::group ledsAssert{};
1497         Manager::group ledsDeAssert{};
1498 
1499         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1500         auto result =
1501             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1502         EXPECT_EQ(true, result);
1503 
1504         // Need just the ledsAssserted populated with these.
1505         // [Two] remains [ON] due to higher priority.
1506         // [Three] remains on since it never was in [Blink] before
1507         // [Ten] moves to [Blink] due to priority: [Blink]
1508         std::set<Layout::LedAction> refAssert = {
1509             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1510             {"Four", phosphor::led::Layout::On, 0, 0,
1511              phosphor::led::Layout::On},
1512             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1513              phosphor::led::Layout::Blink},
1514         };
1515         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1516         EXPECT_EQ(0, ledsDeAssert.size());
1517 
1518         // difference of refAssert and ledsAssert must be null.
1519         Manager::group temp{};
1520         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1521                             refAssert.begin(), refAssert.end(),
1522                             std::inserter(temp, temp.begin()));
1523         EXPECT_EQ(0, temp.size());
1524     }
1525 }
1526 
1527 /** @brief Assert 2 groups having multiple LEDs common in different state and
1528  *  mixed priority and De-Assert-A
1529  */
1530 TEST_F(
1531     LedTest,
1532     assertTwoGroupsWithMultipleComonLEDInDifferentStateDiffPriorityBandADeAssertA)
1533 {
1534     Manager manager(bus,
1535                     twoGroupsWithMultipleComonLEDInDifferentStateDiffPriority);
1536     {
1537         // Assert Set-B
1538         Manager::group ledsAssert{};
1539         Manager::group ledsDeAssert{};
1540 
1541         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1542         auto result =
1543             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1544         EXPECT_EQ(true, result);
1545 
1546         // Need just the ledsAssserted populated with these.
1547         std::set<Layout::LedAction> refAssert = {
1548             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1549             {"Three", phosphor::led::Layout::On, 0, 0,
1550              phosphor::led::Layout::Blink},
1551             {"Five", phosphor::led::Layout::On, 0, 0,
1552              phosphor::led::Layout::On},
1553             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1554             {"Ten", phosphor::led::Layout::On, 0, 0,
1555              phosphor::led::Layout::Blink},
1556         };
1557         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1558         EXPECT_EQ(0, ledsDeAssert.size());
1559 
1560         // difference of refAssert and ledsAssert must be null.
1561         Manager::group temp{};
1562         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1563                             refAssert.begin(), refAssert.end(),
1564                             std::inserter(temp, temp.begin()));
1565         EXPECT_EQ(0, temp.size());
1566     }
1567     {
1568         // Assert Set-A
1569         Manager::group ledsAssert{};
1570         Manager::group ledsDeAssert{};
1571 
1572         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1573         auto result =
1574             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1575         EXPECT_EQ(true, result);
1576 
1577         // Need just the ledsAssserted populated with these.
1578         // [Two] remains [ON] due to higher priority.
1579         // [Three] remains on since it never was in [Blink] before
1580         // [Ten] moves to [Blink] due to priority: [Blink]
1581         std::set<Layout::LedAction> refAssert = {
1582             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1583             {"Four", phosphor::led::Layout::On, 0, 0,
1584              phosphor::led::Layout::On},
1585             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1586              phosphor::led::Layout::Blink},
1587         };
1588         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1589         EXPECT_EQ(0, ledsDeAssert.size());
1590 
1591         // difference of refAssert and ledsAssert must be null.
1592         Manager::group temp{};
1593         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1594                             refAssert.begin(), refAssert.end(),
1595                             std::inserter(temp, temp.begin()));
1596         EXPECT_EQ(0, temp.size());
1597     }
1598     {
1599         // De-Assert Set-A
1600         Manager::group ledsAssert{};
1601         Manager::group ledsDeAssert{};
1602 
1603         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1604         auto result =
1605             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1606         EXPECT_EQ(false, result);
1607 
1608         // Need just the ledsAssserted populated with these.
1609         // [Ten] remains [Blink] due to priority.
1610         std::set<Layout::LedAction> refDeAssert = {
1611             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1612             {"Four", phosphor::led::Layout::On, 0, 0,
1613              phosphor::led::Layout::On},
1614         };
1615         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1616 
1617         // Need just the ledsAssserted populated with these.
1618         // [Two] remains [ON] due to higher priority.
1619         // [Three] remains [On] since it never was in [Blink] before
1620         // [Ten] moves to [On] due to priority: [Blink]
1621         std::set<Layout::LedAction> refAssert = {
1622             {"Ten", phosphor::led::Layout::On, 0, 0,
1623              phosphor::led::Layout::Blink},
1624         };
1625         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1626 
1627         // difference of refAssert and ledsAssert must be null.
1628         Manager::group temp{};
1629         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1630                             refAssert.begin(), refAssert.end(),
1631                             std::inserter(temp, temp.begin()));
1632         EXPECT_EQ(0, temp.size());
1633     }
1634 }
1635 
1636 /** @brief Assert 2 groups having multiple LEDs common in different state and
1637  *  mixed priority and then DeAssert twice.
1638  */
1639 TEST_F(LedTest,
1640        assertTwoGroupsWithMultipleComonLEDInDifferentStateOnBlinkPriorityBandA)
1641 {
1642     Manager manager(bus,
1643                     twoGroupsWithMultipleComonLEDInDifferentStateDiffPriority);
1644     {
1645         // Assert Set-B
1646         Manager::group ledsAssert{};
1647         Manager::group ledsDeAssert{};
1648 
1649         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1650         auto result =
1651             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1652         EXPECT_EQ(true, result);
1653 
1654         // Need just the ledsAssserted populated with these.
1655         std::set<Layout::LedAction> refAssert = {
1656             {"Two", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1657             {"Three", phosphor::led::Layout::On, 0, 0,
1658              phosphor::led::Layout::Blink},
1659             {"Five", phosphor::led::Layout::On, 0, 0,
1660              phosphor::led::Layout::On},
1661             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1662             {"Ten", phosphor::led::Layout::On, 0, 0,
1663              phosphor::led::Layout::Blink},
1664         };
1665         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1666         EXPECT_EQ(0, ledsDeAssert.size());
1667 
1668         // difference of refAssert and ledsAssert must be null.
1669         Manager::group temp{};
1670         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1671                             refAssert.begin(), refAssert.end(),
1672                             std::inserter(temp, temp.begin()));
1673         EXPECT_EQ(0, temp.size());
1674     }
1675     {
1676         // Assert Set-A
1677         Manager::group ledsAssert{};
1678         Manager::group ledsDeAssert{};
1679 
1680         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1681         auto result =
1682             manager.setGroupState(group, true, ledsAssert, ledsDeAssert);
1683         EXPECT_EQ(true, result);
1684 
1685         // Need just the ledsAssserted populated with these.
1686         // [Two] remains [ON] due to higher priority.
1687         // [Three] remains on since it never was in [Blink] before
1688         // [Ten] moves to [Blink] due to priority: [Blink]
1689         std::set<Layout::LedAction> refAssert = {
1690             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1691             {"Four", phosphor::led::Layout::On, 0, 0,
1692              phosphor::led::Layout::On},
1693             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1694              phosphor::led::Layout::Blink},
1695         };
1696         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1697         EXPECT_EQ(0, ledsDeAssert.size());
1698 
1699         // difference of refAssert and ledsAssert must be null.
1700         Manager::group temp{};
1701         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1702                             refAssert.begin(), refAssert.end(),
1703                             std::inserter(temp, temp.begin()));
1704         EXPECT_EQ(0, temp.size());
1705     }
1706     {
1707         // DeAssert Set-B
1708         Manager::group ledsAssert{};
1709         Manager::group ledsDeAssert{};
1710 
1711         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1712         auto result =
1713             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1714         EXPECT_EQ(false, result);
1715 
1716         // Need just the ledsAssserted populated with these.
1717         // [Ten] remains [Blink] due to priority.
1718         std::set<Layout::LedAction> refDeAssert = {
1719             {"Five", phosphor::led::Layout::On, 0, 0,
1720              phosphor::led::Layout::On},
1721             {"Six", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1722         };
1723         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1724 
1725         // difference of refDeAssert and ledsDeAssert must be null.
1726         Manager::group temp{};
1727         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
1728                             refDeAssert.begin(), refDeAssert.end(),
1729                             std::inserter(temp, temp.begin()));
1730         EXPECT_EQ(0, temp.size());
1731 
1732         // Need just the ledsAssert populated with these.
1733         // [Two] will move to [Blink]
1734         std::set<Layout::LedAction> refAssert = {
1735             {"Two", phosphor::led::Layout::Blink, 0, 0,
1736              phosphor::led::Layout::On},
1737         };
1738         EXPECT_EQ(refAssert.size(), ledsAssert.size());
1739 
1740         // difference of refAssert and ledsAssert must be null.
1741         Manager::group temp1{};
1742         std::set_difference(ledsAssert.begin(), ledsAssert.end(),
1743                             refAssert.begin(), refAssert.end(),
1744                             std::inserter(temp1, temp1.begin()));
1745         EXPECT_EQ(0, temp1.size());
1746     }
1747     {
1748         // DeAssert Set-A
1749         Manager::group ledsAssert{};
1750         Manager::group ledsDeAssert{};
1751 
1752         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsASet";
1753         auto result =
1754             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1755         EXPECT_EQ(false, result);
1756 
1757         // Need just the ledsAssserted populated with these.
1758         std::set<Layout::LedAction> refDeAssert = {
1759             {"One", phosphor::led::Layout::On, 0, 0, phosphor::led::Layout::On},
1760             {"Two", phosphor::led::Layout::Blink, 0, 0,
1761              phosphor::led::Layout::On},
1762             {"Three", phosphor::led::Layout::On, 0, 0,
1763              phosphor::led::Layout::Blink},
1764             {"Four", phosphor::led::Layout::On, 0, 0,
1765              phosphor::led::Layout::On},
1766             {"Ten", phosphor::led::Layout::Blink, 0, 0,
1767              phosphor::led::Layout::Blink},
1768         };
1769         EXPECT_EQ(refDeAssert.size(), ledsDeAssert.size());
1770         EXPECT_EQ(0, ledsAssert.size());
1771 
1772         // difference of refDeAssert and ledsDeAssert must be null.
1773         Manager::group temp{};
1774         std::set_difference(ledsDeAssert.begin(), ledsDeAssert.end(),
1775                             refDeAssert.begin(), refDeAssert.end(),
1776                             std::inserter(temp, temp.begin()));
1777         EXPECT_EQ(0, temp.size());
1778     }
1779     {
1780         // DeAssert Set-B again and make sure we get all empty
1781         Manager::group ledsAssert{};
1782         Manager::group ledsDeAssert{};
1783 
1784         auto group = "/xyz/openbmc_project/ledmanager/groups/MultipleLedsBSet";
1785         auto result =
1786             manager.setGroupState(group, false, ledsAssert, ledsDeAssert);
1787         EXPECT_EQ(false, result);
1788         EXPECT_EQ(0, ledsDeAssert.size());
1789         EXPECT_EQ(0, ledsAssert.size());
1790     }
1791 }
1792