1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include <chrono>
19 #include <thread>
20
21 #include <fcntl.h>
22 #include <sys/resource.h>
23 #include <sys/stat.h>
24 #include <sys/time.h>
25 #include <sys/types.h>
26
27 #include "event_handler.h"
28 #include "event_queue.h"
29 #include "event_runner.h"
30 #include "inner_event.h"
31
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::AppExecFwk;
35
36 namespace {
37 const size_t MAX_PRIORITY_NUM = 4;
38 const size_t MAX_HIGH_PRIORITY_COUNT = 5;
39 const uint32_t NUM = 2;
40 const uint32_t HIGH_PRIORITY_COUNT = 12;
41 const uint32_t LOW_PRIORITY_COUNT = 2;
42 const uint32_t IMMEDIATE_PRIORITY_COUNT = 72;
43 const int64_t DELAY_TIME = 100;
44 const int64_t REMOVE_DELAY_TIME = 10;
45 const int64_t HAS_DELAY_TIME = 10;
46 const int64_t REMOVE_WAIT_TIME = 20000;
47 const uint32_t REMOVE_EVENT_ID = 0;
48 const uint32_t HAS_EVENT_ID = 100;
49 const int64_t HAS_EVENT_PARAM = 1000;
50 const uint32_t INSERT_DELAY = 10;
51 bool isDump = false;
52
53 std::atomic<bool> eventRan(false);
54 } // namespace
55
56 class DumpTest : public Dumper {
57 public:
58 /**
59 * Processes the content of a specified string.
60 * @param message the content of a specified string.
61 */
Dump(const std::string & message)62 void Dump(const std::string &message)
63 {
64 isDump = true;
65 GTEST_LOG_(INFO) << message;
66 }
67
68 /**
69 * Obtains the tag information.
70 * which is a prefix added to each string before the string content is processed.
71 * @return the tag information.
72 */
GetTag()73 std::string GetTag()
74 {
75 return "DumpTest";
76 }
77 };
78
79 /**
80 * Init FileDescriptor.
81 *
82 * @param fds[] pipe need.
83 * @return Returns fileDescriptor we get.
84 */
InitFileDescriptor(int32_t fds[])85 static int32_t InitFileDescriptor(int32_t fds[])
86 {
87 auto result = pipe(fds);
88 EXPECT_GE(result, 0);
89
90 int32_t fileDescriptor = fds[0];
91 return fileDescriptor;
92 }
93
94 /**
95 * get event from queue and compare.
96 *
97 * @param eventId of the event we want to get.
98 * @param queue we get event from this queue.
99 */
GetEventAndCompare(uint32_t eventId,EventQueue & queue)100 static void GetEventAndCompare(uint32_t eventId, EventQueue &queue)
101 {
102 auto event = queue.GetEvent();
103 EXPECT_NE(nullptr, event);
104 if (event != nullptr) {
105 auto id = event->GetInnerEventId();
106 EXPECT_EQ(eventId, id);
107 }
108 }
109
110 /**
111 * set event handler time delay.
112 *
113 * @param delayTime of the event handle time.
114 */
DelayTest(uint8_t delayTime)115 static void DelayTest(uint8_t delayTime)
116 {
117 const uint8_t longDelta = 20;
118 const uint8_t shortDelta = 5;
119 uint32_t eventId = 0;
120 uint8_t maxDelta = shortDelta;
121 if (delayTime > 0) {
122 maxDelta = longDelta;
123 }
124
125 EventQueue queue;
126 queue.Prepare();
127 auto event = InnerEvent::Get(eventId);
128 auto now = InnerEvent::Clock::now();
129 // delay event handle time delayTime ms
130 auto handleTime = now + std::chrono::milliseconds(static_cast<int64_t>(delayTime));
131 event->SetSendTime(now);
132 event->SetHandleTime(handleTime);
133 queue.Insert(event);
134 event = queue.GetEvent();
135 // block until get event from queue after delay time
136 now = InnerEvent::Clock::now();
137 EXPECT_GE(now, handleTime);
138 // check if delay time is within acceptable error
139 auto errorTime = handleTime + std::chrono::milliseconds(static_cast<int64_t>(maxDelta));
140 EXPECT_LE(now, errorTime);
141 EXPECT_NE(event, nullptr);
142 if (event != nullptr) {
143 auto id = event->GetInnerEventId();
144 EXPECT_EQ(eventId, id);
145 }
146 }
147
148 /**
149 * Insert event and get event from queue.
150 *
151 * @param priorities[] prioritiesof event.
152 * @param priorityCount count of event we insert.
153 */
InsertPriorityTest(const EventQueue::Priority priorities[],size_t priorityCount)154 static void InsertPriorityTest(const EventQueue::Priority priorities[], size_t priorityCount)
155 {
156 std::list<uint32_t> eventIds;
157 auto now = InnerEvent::Clock::now();
158 EventQueue queue;
159 queue.Prepare();
160 uint32_t eventId = 0;
161
162 // insert event into queue from IDLE priority to IMMEDIATE priority
163 for (size_t i = 0; i < priorityCount; ++i) {
164 eventIds.push_back(eventId);
165 auto event = InnerEvent::Get(eventId);
166 event->SetSendTime(now);
167 event->SetHandleTime(now);
168 queue.Insert(event, priorities[i]);
169 ++eventId;
170 }
171
172 // get event from queue and check eventId
173 for (size_t i = 0; i < priorityCount; ++i) {
174 auto event = queue.GetEvent();
175 EXPECT_NE(nullptr, event);
176 if (event == nullptr) {
177 break;
178 }
179
180 if (priorities[0] == EventQueue::Priority::IDLE) {
181 auto storeId = eventIds.back();
182 auto id = event->GetInnerEventId();
183 EXPECT_EQ(storeId, id);
184 eventIds.pop_back();
185 } else {
186 auto storeId = eventIds.front();
187 auto id = event->GetInnerEventId();
188 EXPECT_EQ(storeId, id);
189 eventIds.pop_front();
190 }
191 }
192 }
193
194 /**
195 * Break event queue.
196 *
197 * @param queue we get break.
198 * @param eventId eventId of event we insert.
199 */
BreakQueueTest(EventQueue & queue,uint32_t eventId)200 static void BreakQueueTest(EventQueue &queue, uint32_t eventId)
201 {
202 auto event = queue.GetEvent();
203 EXPECT_NE(nullptr, event);
204 if (event != nullptr) {
205 auto id = event->GetInnerEventId();
206 EXPECT_EQ(eventId, id);
207 queue.Finish();
208 queue.Insert(event);
209 event = queue.GetEvent();
210 EXPECT_EQ(nullptr, event);
211 }
212 }
213
214 /**
215 * Insert event into queue and get event.
216 *
217 * @param queue we get event from this queue.
218 * @param event event we insert into queue.
219 */
InsertAndGet(EventQueue & queue,InnerEvent::Pointer & event)220 static void InsertAndGet(EventQueue &queue, InnerEvent::Pointer &event)
221 {
222 // insert event before prepare queue
223 queue.Insert(event);
224 event = queue.GetEvent();
225 EXPECT_EQ(nullptr, event);
226 if (event != nullptr) {
227 // If event is not nullptr, the queue must be empty, so need to insert it again.
228 queue.Insert(event);
229 }
230 }
231
232 /**
233 * Insert event and get event from queue.
234 *
235 * @param queue we insert event into this queue.
236 * @param length length of events.
237 */
InsertPriorityEvent(EventQueue & queue,size_t length)238 static void InsertPriorityEvent(EventQueue &queue, size_t length)
239 {
240 // insert two low priority events
241 for (uint32_t eventId = 0; eventId < NUM; eventId++) {
242 auto event = InnerEvent::Get(eventId);
243 auto now = InnerEvent::Clock::now();
244 event->SetSendTime(now);
245 event->SetHandleTime(now);
246 queue.Insert(event, EventQueue::Priority::LOW);
247 }
248
249 // avoid time accuracy problem
250 usleep(INSERT_DELAY);
251
252 // insert MAX_HIGH_PRIORITY_COUNT high priority events
253 for (uint32_t eventId = NUM; eventId < NUM * length + NUM; eventId++) {
254 auto event = InnerEvent::Get(eventId);
255 auto now = InnerEvent::Clock::now();
256 event->SetSendTime(now);
257 event->SetHandleTime(now);
258 queue.Insert(event, EventQueue::Priority::HIGH);
259 }
260 }
261
262 /**
263 * Insert all priority event and get event from queue.
264 *
265 * @param queue we insert event into this queue.
266 */
InsertAllPriorityEvent(EventQueue & queue)267 static void InsertAllPriorityEvent(EventQueue &queue)
268 {
269 // insert low priority events
270 for (uint32_t eventId = 0; eventId < LOW_PRIORITY_COUNT; eventId++) {
271 auto event = InnerEvent::Get(eventId);
272 auto now = InnerEvent::Clock::now();
273 event->SetSendTime(now);
274 event->SetHandleTime(now);
275 queue.Insert(event, EventQueue::Priority::LOW);
276 }
277
278 // avoid time accuracy problem
279 usleep(INSERT_DELAY);
280
281 // insert high priority events
282 for (uint32_t eventId = LOW_PRIORITY_COUNT; eventId < HIGH_PRIORITY_COUNT; eventId++) {
283 auto event = InnerEvent::Get(eventId);
284 auto now = InnerEvent::Clock::now();
285 event->SetSendTime(now);
286 event->SetHandleTime(now);
287 queue.Insert(event, EventQueue::Priority::HIGH);
288 }
289
290 // avoid time accuracy problem
291 usleep(INSERT_DELAY);
292
293 // insert immediate priority events
294 for (uint32_t eventId = HIGH_PRIORITY_COUNT; eventId < IMMEDIATE_PRIORITY_COUNT; eventId++) {
295 auto event = InnerEvent::Get(eventId);
296 auto now = InnerEvent::Clock::now();
297 event->SetSendTime(now);
298 event->SetHandleTime(now);
299 queue.Insert(event, EventQueue::Priority::IMMEDIATE);
300 }
301 }
302
303 class LibEventHandlerEventQueueTest : public testing::Test {
304 public:
305 static void SetUpTestCase(void);
306 static void TearDownTestCase(void);
307 void SetUp();
308 void TearDown();
309 };
310
SetUpTestCase(void)311 void LibEventHandlerEventQueueTest::SetUpTestCase(void)
312 {}
313
TearDownTestCase(void)314 void LibEventHandlerEventQueueTest::TearDownTestCase(void)
315 {}
316
SetUp(void)317 void LibEventHandlerEventQueueTest::SetUp(void)
318 {
319 /**
320 * @tc.setup: reset the eventRan value.
321 */
322 eventRan.store(false);
323 }
324
TearDown(void)325 void LibEventHandlerEventQueueTest::TearDown(void)
326 {}
327
328 class MyEventHandler : public EventHandler {
329 public:
MyEventHandler(const std::shared_ptr<EventRunner> & runner)330 explicit MyEventHandler(const std::shared_ptr<EventRunner> &runner) : EventHandler(runner)
331 {}
~MyEventHandler()332 ~MyEventHandler()
333 {}
334
ProcessEvent(const InnerEvent::Pointer &)335 void ProcessEvent(const InnerEvent::Pointer &) override
336 {
337 eventRan.store(true);
338 }
339
340 MyEventHandler(const MyEventHandler &) = delete;
341 MyEventHandler &operator=(const MyEventHandler &) = delete;
342 MyEventHandler(MyEventHandler &&) = delete;
343 MyEventHandler &operator=(MyEventHandler &&) = delete;
344 };
345
346 class MyFileDescriptorListener : public FileDescriptorListener {
347 public:
MyFileDescriptorListener()348 MyFileDescriptorListener()
349 {}
~MyFileDescriptorListener()350 ~MyFileDescriptorListener()
351 {}
352
353 /* @param int32_t fileDescriptor */
OnReadable(int32_t)354 void OnReadable(int32_t)
355 {}
356
357 /* @param int32_t fileDescriptor */
OnWritable(int32_t)358 void OnWritable(int32_t)
359 {}
360
361 /* @param int32_t fileDescriptor */
OnException(int32_t)362 void OnException(int32_t)
363 {}
364
365 MyFileDescriptorListener(const MyFileDescriptorListener &) = delete;
366 MyFileDescriptorListener &operator=(const MyFileDescriptorListener &) = delete;
367 MyFileDescriptorListener(MyFileDescriptorListener &&) = delete;
368 MyFileDescriptorListener &operator=(MyFileDescriptorListener &&) = delete;
369 };
370
371 /*
372 * @tc.name: WakeAndBreak001
373 * @tc.desc: check events inserted in queue when Prepare() and
374 * Finish() are called in right order
375 * @tc.type: FUNC
376 */
377 HWTEST_F(LibEventHandlerEventQueueTest, WakeAndBreak001, TestSize.Level1)
378 {
379 /**
380 * @tc.setup: get event and queue.
381 */
382 EventQueue queue;
383 uint32_t eventId = 0;
384 auto event = InnerEvent::Get(eventId);
385
386 /**
387 * @tc.steps: step1. prepare queue and inserted in queue when Prepare() and Finish() are called in right order.
388 * @tc.expected: step1. event and event id is valid when Prepare() and Finish() are called in right order.
389 */
390 queue.Prepare();
391 queue.Insert(event);
392 BreakQueueTest(queue, eventId);
393 }
394
395 /*
396 * @tc.name: WakeAndBreak002
397 * @tc.desc: check events inserted in queue when queue is prepared
398 * and broken in wrong order
399 * @tc.type: FUNC
400 */
401 HWTEST_F(LibEventHandlerEventQueueTest, WakeAndBreak002, TestSize.Level1)
402 {
403 /**
404 * @tc.setup: get event and queue.
405 */
406 EventQueue queue;
407 uint32_t eventId = 0;
408 auto event = InnerEvent::Get(eventId);
409
410 /**
411 * @tc.steps: step1. prepare queue and inserted in queue when Prepare() and Finish() are called in wrong order.
412 * @tc.expected: step1. event and event id is invalid when Prepare() and Finish() are called in wrong order.
413 */
414 InsertAndGet(queue, event);
415 queue.Prepare();
416 BreakQueueTest(queue, eventId);
417 }
418
419 /*
420 * @tc.name: WakeAndBreak003
421 * @tc.desc: check events inserted in queue when queue is broken
422 * and prepared in wrong order
423 * @tc.type: FUNC
424 */
425 HWTEST_F(LibEventHandlerEventQueueTest, WakeAndBreak003, TestSize.Level1)
426 {
427 /**
428 * @tc.setup: get event and queue.
429 */
430 EventQueue queue;
431 uint32_t eventId = 0;
432 auto event = InnerEvent::Get(eventId);
433
434 InsertAndGet(queue, event);
435
436 /**
437 * @tc.steps: step1. get and check event Finish() is called in wrong order.
438 * @tc.expected: step1. event is null.
439 */
440 queue.Finish();
441 event = queue.GetEvent();
442 EXPECT_EQ(nullptr, event);
443 if (event != nullptr) {
444 // If event is not nullptr, the queue must be empty, so need to insert it again.
445 queue.Insert(event);
446 }
447
448 /**
449 * @tc.steps: step2. prepare queue and get event from queue when Prepare() is called in right order.
450 * @tc.expected: step2. event and event id is invalid .
451 */
452 queue.Prepare();
453 GetEventAndCompare(eventId, queue);
454 }
455
456 /*
457 * @tc.name: WakeAndBreak004
458 * @tc.desc: check events inserted in queue and get event by function GetExpiredEvent
459 * @tc.type: FUNC
460 */
461 HWTEST_F(LibEventHandlerEventQueueTest, WakeAndBreak004, TestSize.Level1)
462 {
463 /**
464 * @tc.setup: get event and queue.
465 */
466 EventQueue myQueue;
467 uint32_t eventId = 0;
468 auto event = InnerEvent::Get(eventId);
469 InsertAndGet(myQueue, event);
470
471 /**
472 * @tc.steps: step1. get and check event Finish() is called in wrong order.
473 * @tc.expected: step1. event is null.
474 */
475 myQueue.Finish();
476 event = myQueue.GetEvent();
477 EXPECT_EQ(nullptr, event);
478 if (event != nullptr) {
479 // If event is not nullptr, the queue must be empty, so need to insert it again.
480 myQueue.Insert(event);
481 }
482
483 /**
484 * @tc.steps: step2. prepare queue and get event from queue when Prepare() is called in right order.
485 * @tc.expected: step2. event and event id is invalid .
486 */
487 myQueue.Prepare();
488 InnerEvent::TimePoint nextWakeUpTime = InnerEvent::TimePoint::max();
489 auto resultEvent = myQueue.GetExpiredEvent(nextWakeUpTime);
490 EXPECT_NE(nullptr, resultEvent);
491 EXPECT_EQ(eventId, resultEvent->GetInnerEventId());
492 }
493
494 /*
495 * @tc.name: InsertEvent001
496 * @tc.desc: insert() event of different priorities into Queue,
497 * from IDLE to IMMEDIATE.
498 * @tc.type: FUNC
499 */
500 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent001, TestSize.Level1)
501 {
502 /**
503 * @tc.setup: init priority array, insert event with the order int the array.
504 */
505 const EventQueue::Priority priorities[MAX_PRIORITY_NUM] = {
506 EventQueue::Priority::IDLE,
507 EventQueue::Priority::LOW,
508 EventQueue::Priority::HIGH,
509 EventQueue::Priority::IMMEDIATE,
510 };
511
512 /**
513 * @tc.steps: step1. insert and get event, check whether the order of the event
514 * we get from queue is the same as we expect.
515 * @tc.expected: step1. the order is the same as we expect.
516 */
517 InsertPriorityTest(priorities, MAX_PRIORITY_NUM);
518 }
519
520 /*
521 * @tc.name: InsertEvent002
522 * @tc.desc: insert() event of different priorities into Queue,
523 * from IMMEDIATE to IDLE
524 * @tc.type: FUNC
525 */
526 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent002, TestSize.Level1)
527 {
528 /**
529 * @tc.setup: init priority array, insert event with the order int the array.
530 */
531 const EventQueue::Priority priorities[MAX_PRIORITY_NUM] = {
532 EventQueue::Priority::IMMEDIATE,
533 EventQueue::Priority::HIGH,
534 EventQueue::Priority::LOW,
535 EventQueue::Priority::IDLE,
536 };
537
538 /**
539 * @tc.steps: step1. insert and get event, check whether the order of the event
540 * we get from queue is the same as we expect.
541 * @tc.expected: step1. the order is the same as we expect.
542 */
543 InsertPriorityTest(priorities, MAX_PRIORITY_NUM);
544 }
545
546 /*
547 * @tc.name: InsertEvent003
548 * @tc.desc: insert nullptr event and normal event into queue,
549 * then get event from queue
550 * @tc.type: FUNC
551 */
552 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent003, TestSize.Level1)
553 {
554 /**
555 * @tc.setup: prepare queue. and insert event into queue, insert event with the order int the array.
556 */
557 uint32_t eventId = 0;
558 EventQueue queue;
559 queue.Prepare();
560
561 /**
562 * @tc.steps: step1. insert nullptr event and insert normal event into queue, and get event from queue, check
563 * whether the event we get from queue is valid as we expect.
564 * @tc.expected: step1. the event we get after we insert normal event into queue is valid.
565 */
566 auto event = InnerEvent::Pointer(nullptr, nullptr);
567 queue.Insert(event);
568 event = InnerEvent::Get(eventId);
569 queue.Insert(event);
570 GetEventAndCompare(eventId, queue);
571 }
572
573 /*
574 * @tc.name: InsertEvent004
575 * @tc.desc: avoid starvation in queue when insert event of
576 * different priorities into Queue
577 * @tc.type: FUNC
578 */
579 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent004, TestSize.Level1)
580 {
581 /**
582 * @tc.setup: prepare queue.
583 */
584 const uint32_t num = 3;
585 EventQueue queue;
586 queue.Prepare();
587
588 /**
589 * @tc.steps: step1. first insert MAX_HIGH_PRIORITY_COUNT high priority events, then insert two low priority events.
590 */
591 for (uint32_t eventId = 0; eventId < MAX_HIGH_PRIORITY_COUNT + 1; eventId++) {
592 auto event = InnerEvent::Get(eventId);
593 auto now = InnerEvent::Clock::now();
594 event->SetSendTime(now);
595 event->SetHandleTime(now);
596 queue.Insert(event, EventQueue::Priority::HIGH);
597 }
598
599 for (uint32_t eventId = MAX_HIGH_PRIORITY_COUNT + 1; eventId < MAX_HIGH_PRIORITY_COUNT + num; eventId++) {
600 auto event = InnerEvent::Get(eventId);
601 auto now = InnerEvent::Clock::now();
602 event->SetSendTime(now);
603 event->SetHandleTime(now);
604 queue.Insert(event, EventQueue::Priority::LOW);
605 }
606
607 /**
608 * @tc.steps: step2. get event from queue one by one, and check whether the event id we get from queue is the
609 * same as we expect.
610 * @tc.expected: step2. event id we get from queue is the same as we expect.
611 */
612 for (uint32_t eventId = 0; eventId < MAX_HIGH_PRIORITY_COUNT + num; eventId++) {
613 GetEventAndCompare(eventId, queue);
614 }
615 }
616
617 /*
618 * @tc.name: InsertEvent005
619 * @tc.desc: avoid starvation in queue when insert event of different priorities into Queue.
620 * @tc.type: FUNC
621 */
622 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent005, TestSize.Level1)
623 {
624 /**
625 * @tc.setup: prepare queue.
626 */
627 EventQueue queue;
628 queue.Prepare();
629
630 /**
631 * @tc.steps: step1. first insert two low priority events, insert MAX_HIGH_PRIORITY_COUNT high priority events.
632 */
633 InsertPriorityEvent(queue, MAX_HIGH_PRIORITY_COUNT);
634
635 /**
636 * @tc.steps: step2. get MAX_HIGH_PRIORITY_COUNT events from queue, and compare the event id.
637 * @tc.expected: step2. event we get is high priority events.
638 */
639 for (uint32_t eventId = 2; eventId < MAX_HIGH_PRIORITY_COUNT + NUM; eventId++) {
640 GetEventAndCompare(eventId, queue);
641 }
642
643 /**
644 * @tc.steps: step3. get one event from queue, and compare the event id .
645 * @tc.expected: step3. event we get is low priority events.
646 */
647 uint32_t lowEventId = 0;
648 GetEventAndCompare(lowEventId, queue);
649
650 /**
651 * @tc.steps: step4. get MAX_HIGH_PRIORITY_COUNT events from queue, and compare the event id .
652 * @tc.expected: step4. event we get is high priority events.
653 */
654 for (uint32_t eventId = MAX_HIGH_PRIORITY_COUNT + NUM; eventId < NUM * MAX_HIGH_PRIORITY_COUNT + NUM; eventId++) {
655 GetEventAndCompare(eventId, queue);
656 }
657
658 /**
659 * @tc.steps: step5. get one event from queue, and compare the event id .
660 * @tc.expected: step5. event we get is low priority events.
661 */
662 lowEventId = 1;
663 GetEventAndCompare(lowEventId, queue);
664 }
665
666 /*
667 * @tc.name: InsertEvent006
668 * @tc.desc: avoid starvation in queue when insert event of different priorities into queue.
669 * @tc.type: FUNC
670 */
671 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent006, TestSize.Level1)
672 {
673 /**
674 * @tc.setup: prepare queue.
675 */
676 const uint32_t count = 5;
677 const uint32_t highEventCount = 6;
678 EventQueue queue;
679 queue.Prepare();
680
681 /**
682 * @tc.steps: step1. insert events from low priority to immediate priority into queue.
683 */
684 InsertAllPriorityEvent(queue);
685
686 uint32_t highCount = 1;
687 uint32_t highEventId = 0;
688 uint32_t lowCount = 0;
689 uint32_t immediateCount = 1;
690
691 /**
692 * @tc.steps: step2. get events from queue, and compare the event id .
693 * @tc.expected: step2. first we get five immediate priority events , then get one high priority event, every five
694 * high priority events, we will get one low priority event.
695 */
696 for (uint32_t eventId = 0; eventId < IMMEDIATE_PRIORITY_COUNT - HIGH_PRIORITY_COUNT; eventId++) {
697 if (immediateCount % count == 0) {
698 GetEventAndCompare(HIGH_PRIORITY_COUNT + eventId, queue);
699 immediateCount++;
700 if (highCount % highEventCount == 0) {
701 GetEventAndCompare(lowCount, queue);
702 lowCount++;
703 highCount++;
704 } else {
705 GetEventAndCompare(LOW_PRIORITY_COUNT + highEventId, queue);
706 highCount++;
707 highEventId++;
708 }
709 } else {
710 GetEventAndCompare(HIGH_PRIORITY_COUNT + eventId, queue);
711 immediateCount++;
712 }
713 }
714 }
715
716 /*
717 * @tc.name: InsertEvent007
718 * @tc.desc: delay event handle time, get event after delaytime
719 * @tc.type: FUNC
720 */
721 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent007, TestSize.Level1)
722 {
723 const uint8_t delayTime = 100;
724 /**
725 * @tc.steps: step1. insert event into queue and set handle time delay 100ms from now, then get event from queue.
726 * @tc.expected: step1. the delay time we get event from queue is about 100ms with tolerable error.
727 */
728 DelayTest(delayTime);
729 }
730
731 /*
732 * @tc.name: InsertEvent008
733 * @tc.desc: delayTime = 0, send event and get event from queue
734 * @tc.type: FUNC
735 */
736 HWTEST_F(LibEventHandlerEventQueueTest, InsertEvent008, TestSize.Level1)
737 {
738 const uint8_t delayTime = 0;
739 /**
740 * @tc.steps: step1. insert event into queue and set handle time delay 0ms from now, then get event from queue.
741 * @tc.expected: step1. the delay time we get event from queue is about 0ms with tolerable error.
742 */
743 DelayTest(delayTime);
744 }
745
746 /*
747 * @tc.name: RemoveEvent001
748 * @tc.desc: remove all the events which belong to one handler
749 * @tc.type: FUNC
750 */
751 HWTEST_F(LibEventHandlerEventQueueTest, RemoveEvent001, TestSize.Level1)
752 {
753 /**
754 * @tc.setup: init handler and runner.
755 */
756 auto runner = EventRunner::Create(true);
757 auto handler = std::make_shared<EventHandler>(runner);
758 std::atomic<bool> taskCalled(false);
__anon2a5376800202() 759 auto f = [&taskCalled]() { taskCalled.store(true); };
760
761 /**
762 * @tc.steps: step1. post a task with delay time, then remove this task ,check whether the task is executed
763 * after delay time passed.
764 * @tc.expected: step1. the task is not executed after delay time.
765 */
766 if (handler->PostTask(f, REMOVE_DELAY_TIME, EventQueue::Priority::LOW)) {
767 handler->RemoveAllEvents();
768 usleep(REMOVE_WAIT_TIME);
769 auto called = taskCalled.load();
770 EXPECT_FALSE(called);
771 }
772 }
773
774 /*
775 * @tc.name: RemoveEvent002
776 * @tc.desc: remove all the events which belong to one handler with same id
777 * @tc.type: FUNC
778 */
779 HWTEST_F(LibEventHandlerEventQueueTest, RemoveEvent002, TestSize.Level1)
780 {
781 /**
782 * @tc.setup: init handler and runner.
783 */
784 auto runner = EventRunner::Create(true);
785 auto handler = std::make_shared<MyEventHandler>(runner);
786 auto event = InnerEvent::Get(REMOVE_EVENT_ID);
787
788 /**
789 * @tc.steps: step1. send an event with delay time, then remove this event with event id,
790 * then check whether the task is executed after delay time.
791 * @tc.expected: step1. the task is not executed after delay time.
792 */
793 handler->SendEvent(event, REMOVE_DELAY_TIME, EventQueue::Priority::LOW);
794 handler->RemoveEvent(REMOVE_EVENT_ID);
795 usleep(REMOVE_WAIT_TIME);
796 auto ran = eventRan.load();
797 EXPECT_FALSE(ran);
798 }
799
800 /*
801 * @tc.name: RemoveEvent003
802 * @tc.desc: remove all the events which belong to one handler with same id and param
803 * @tc.type: FUNC
804 */
805 HWTEST_F(LibEventHandlerEventQueueTest, RemoveEvent003, TestSize.Level1)
806 {
807 /**
808 * @tc.setup: init handler and runner.
809 */
810 int64_t eventParam = 0;
811 auto runner = EventRunner::Create(true);
812 auto handler = std::make_shared<MyEventHandler>(runner);
813 auto event = InnerEvent::Get(REMOVE_EVENT_ID, eventParam);
814
815 /**
816 * @tc.steps: step1. send an event with delay time, then remove this event with event id and param,
817 * then check whether the task is executed after delay time.
818 * @tc.expected: step1. the task is not executed after delay time.
819 */
820 handler->SendEvent(event, REMOVE_DELAY_TIME, EventQueue::Priority::LOW);
821 handler->RemoveEvent(REMOVE_EVENT_ID, eventParam);
822 usleep(REMOVE_WAIT_TIME);
823 auto ran = eventRan.load();
824 EXPECT_FALSE(ran);
825 }
826
827 /*
828 * @tc.name: RemoveEvent004
829 * @tc.desc: remove events with task from queue
830 * @tc.type: FUNC
831 */
832 HWTEST_F(LibEventHandlerEventQueueTest, RemoveEvent004, TestSize.Level1)
833 {
834 /**
835 * @tc.setup: init handler and runner, get event with callback and name.
836 */
837 int64_t delayTime = 5;
838 int64_t delayWaitTime = 10000;
839 std::string taskName("taskName");
840 std::atomic<bool> taskCalled(false);
__anon2a5376800302() 841 auto f = [&taskCalled]() { taskCalled.store(true); };
842 auto runner = EventRunner::Create(true);
843 auto handler = std::make_shared<EventHandler>(runner);
844 auto event = InnerEvent::Get(f, taskName);
845
846 /**
847 * @tc.steps: step1. send an event with delay time, then remove this event with taskname,
848 * then check whether the task is executed after delay time.
849 * @tc.expected: step1. the task is not executed after delay time.
850 */
851 handler->SendEvent(event, delayTime, EventQueue::Priority::LOW);
852 handler->RemoveTask(taskName);
853 usleep(delayWaitTime);
854 auto called = taskCalled.load();
855 EXPECT_FALSE(called);
856 }
857
858 /*
859 * @tc.name: NotifyQueue001
860 * @tc.desc: wake up the queue which is blocked when we need to execute a task
861 * @tc.type: FUNC
862 */
863 HWTEST_F(LibEventHandlerEventQueueTest, NotifyQueue001, TestSize.Level1)
864 {
865 /**
866 * @tc.setup: init handler and runner.
867 */
868 std::atomic<bool> taskCalled(false);
869 auto runner = EventRunner::Create(false);
870 auto handler = std::make_shared<EventHandler>(runner);
871
872 /**
873 * @tc.steps: step1. post a delay task to block handler thread, then new a thread to post a task to wake up the
874 * blocked handler.
875 * @tc.expected: step1. the task is executed as expect.
876 */
__anon2a5376800402() 877 auto mainTask = [&taskCalled, &runner]() {
878 taskCalled.store(false);
879 runner->Stop();
880 };
881 handler->PostTask(mainTask, DELAY_TIME);
__anon2a5376800502() 882 auto f = [&taskCalled, &handler]() {
883 usleep(10000);
884 auto task = [&taskCalled]() { taskCalled.store(true); };
885 handler->PostTask(task);
886 usleep(10000);
887 auto called = taskCalled.load();
888 EXPECT_TRUE(called);
889 };
890 std::thread newThread(f);
891 newThread.detach();
892 runner->Run();
893 auto called = taskCalled.load();
894 EXPECT_FALSE(called);
895 }
896
897 /*
898 * @tc.name: NotifyQueue002
899 * @tc.desc: add FileDescriptor and wake up the queue with epoll which is blocked when we need to execute a task
900 * @tc.type: FUNC
901 */
902 HWTEST_F(LibEventHandlerEventQueueTest, NotifyQueue002, TestSize.Level1)
903 {
904 /**
905 * @tc.setup: init handler and runner.
906 */
907 std::atomic<bool> taskCalled(false);
908 auto runner = EventRunner::Create(false);
909 auto handler = std::make_shared<EventHandler>(runner);
910
911 /**
912 * @tc.steps: step1. add file descripter listener to handler, handler will use epoll to wake up block thread.
913 */
914 int32_t fds[] = {-1, -1};
915 int32_t fileDescriptor = InitFileDescriptor(fds);
916 uint32_t event = 1;
917
918 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
919 handler->AddFileDescriptorListener(fileDescriptor, event, fileDescriptorListener);
920
921 /**
922 * @tc.steps: step2. post a delay task to block handler thread, then new a thread to post a task to wake up the
923 * blocked handler.
924 * @tc.expected: step2. the task is executed as expect.
925 */
__anon2a5376800702() 926 auto mainThreadTask = [&taskCalled, &runner]() {
927 taskCalled.store(false);
928 runner->Stop();
929 };
930 handler->PostTask(mainThreadTask, DELAY_TIME);
__anon2a5376800802() 931 auto newThreadTask = [&taskCalled, &handler]() {
932 usleep(10000);
933 auto tempTask = [&taskCalled]() { taskCalled.store(true); };
934 handler->PostTask(tempTask);
935 usleep(10000);
936 auto called = taskCalled.load();
937 EXPECT_TRUE(called);
938 };
939 std::thread newThread(newThreadTask);
940 newThread.detach();
941 runner->Run();
942 auto called = taskCalled.load();
943 EXPECT_FALSE(called);
944
945 /**
946 * @tc.steps: step3. remove file descripter listener and close pipe.
947 */
948 handler->RemoveFileDescriptorListener(fileDescriptor);
949 close(fds[0]);
950 close(fds[1]);
951 }
952
953 /*
954 * @tc.name: NotifyQueue003
955 * @tc.desc: wake up the queue with epoll which is blocked when we need to execute a task
956 * @tc.type: FUNC
957 */
958 HWTEST_F(LibEventHandlerEventQueueTest, NotifyQueue003, TestSize.Level1)
959 {
960 /**
961 * @tc.setup: init handler and runner.
962 */
963 std::atomic<bool> taskCalled(false);
964 auto runner = EventRunner::Create(false);
965 auto handler = std::make_shared<EventHandler>(runner);
966 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
967 auto called = taskCalled.load();
__anon2a5376800a02() 968 auto main = [&taskCalled, &runner]() {
969 taskCalled.store(false);
970 runner->Stop();
971 };
972
973 /**
974 * @tc.steps: step1. post delay task to block handler.
975 */
976 handler->PostTask(main, DELAY_TIME);
977 int32_t fds[] = {-1, -1};
978 int32_t fileDescriptor = InitFileDescriptor(fds);
979 uint32_t event = 1;
980
981 /**
982 * @tc.steps: step2. new a thread to post a delay task to add file descriptor listener to handler,
983 * then post a new task.
984 * @tc.expected: step2. all the task is executed as expect.
985 */
__anon2a5376800b02() 986 auto newTask = [&handler, &fileDescriptor, &event, &fileDescriptorListener, &taskCalled]() {
987 usleep(10000);
988 handler->AddFileDescriptorListener(fileDescriptor, event, fileDescriptorListener);
989 usleep(10000);
990 auto newCalled = taskCalled.load();
991 EXPECT_FALSE(newCalled);
992 auto innerTask = [&taskCalled]() { taskCalled.store(true); };
993 handler->PostTask(innerTask);
994 usleep(10000);
995 newCalled = taskCalled.load();
996 EXPECT_TRUE(newCalled);
997 };
998 std::thread newThread(newTask);
999 newThread.detach();
1000 runner->Run();
1001 called = taskCalled.load();
1002 EXPECT_FALSE(called);
1003
1004 /**
1005 * @tc.steps: step3. remove file descripter listener and close pipe.
1006 */
1007 handler->RemoveFileDescriptorListener(fileDescriptor);
1008 close(fds[0]);
1009 close(fds[1]);
1010 }
1011
1012 /*
1013 * @tc.name: RemoveOrphan001
1014 * @tc.desc: Remove event without owner, and check remove result
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(LibEventHandlerEventQueueTest, RemoveOrphan001, TestSize.Level1)
1018 {
1019 /**
1020 * @tc.steps: step1. init orphan handler and post a task.
1021 */
1022 std::atomic<bool> orphanTaskCalled(false);
1023 std::atomic<bool> commonTaskCalled(false);
1024 auto runner = EventRunner::Create(false);
1025 auto orphanHandler = std::make_shared<EventHandler>(runner);
__anon2a5376800d02() 1026 auto g = [&orphanTaskCalled]() { orphanTaskCalled.store(true); };
1027 orphanHandler->PostTask(g);
1028
1029 /**
1030 * @tc.steps: step2. init common handler and post a task.
1031 */
1032 auto commonHandler = std::make_shared<EventHandler>(runner);
__anon2a5376800e02() 1033 auto f = [&commonTaskCalled, &runner]() {
1034 commonTaskCalled.store(true);
1035 runner->Stop();
1036 };
1037 commonHandler->PostTask(f);
1038
1039 /**
1040 * @tc.steps: step3. reset orphan handler and start runner.
1041 * @tc.expected: step3. the task post through orphan handler is not executed, the task
1042 * post through common handler is executed.
1043 */
1044 orphanHandler.reset();
1045 usleep(10000);
1046 runner->Run();
1047 auto orphanCalled = orphanTaskCalled.load();
1048 EXPECT_FALSE(orphanCalled);
1049 auto commonCalled = commonTaskCalled.load();
1050 EXPECT_TRUE(commonCalled);
1051 }
1052
1053 /*
1054 * @tc.name: AddAndRemoveFileDescriptorListener001
1055 * @tc.desc: add file descriptor listener and remove file descriptor listener with fd
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F(LibEventHandlerEventQueueTest, AddAndRemoveFileDescriptorListener001, TestSize.Level1)
1059 {
1060 /**
1061 * @tc.setup: init queue and prepare queue.
1062 */
1063 EventQueue queue;
1064 queue.Prepare();
1065
1066 int32_t fds[] = {-1, -1};
1067 EXPECT_GE(pipe(fds), 0);
1068
1069 /**
1070 * @tc.steps: step1. add file descriptor listener to queue, then remove file descriptor listener with fd,
1071 * close pipe.
1072 * @tc.expected: step1. add file descriptor listener success.
1073 */
1074 int32_t fileDescriptor = fds[0];
1075 uint32_t event = 1;
1076 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1077 auto result = queue.AddFileDescriptorListener(fileDescriptor, event, fileDescriptorListener);
1078 EXPECT_EQ(result, ERR_OK);
1079 queue.RemoveFileDescriptorListener(-1);
1080 queue.RemoveFileDescriptorListener(fileDescriptor);
1081 close(fds[0]);
1082 close(fds[1]);
1083 }
1084
1085 /*
1086 * @tc.name: AddAndRemoveFileDescriptorListener002
1087 * @tc.desc: add file descriptor listener and remove file descriptor listener with handler
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(LibEventHandlerEventQueueTest, AddAndRemoveFileDescriptorListener002, TestSize.Level1)
1091 {
1092 /**
1093 * @tc.setup: init handler and runner, prepare queue.
1094 */
1095 auto runner = EventRunner::Create(false);
1096 auto handler = std::make_shared<EventHandler>(runner);
1097 EventQueue queue;
1098 queue.Prepare();
1099
1100 /**
1101 * @tc.steps: step1. add file descriptor listener to queue, then remove file descriptor listener with handler,
1102 * close pipe.
1103 * @tc.expected: step1. add file descriptor listener success.
1104 */
1105 int32_t fds[] = {-1, -1};
1106 int32_t fileDescriptor = InitFileDescriptor(fds);
1107 uint32_t event = 1;
1108
1109 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1110 fileDescriptorListener->SetOwner(handler);
1111 auto result = queue.AddFileDescriptorListener(fileDescriptor, event, fileDescriptorListener);
1112 EXPECT_EQ(result, ERR_OK);
1113 queue.RemoveFileDescriptorListener(nullptr);
1114 queue.RemoveFileDescriptorListener(handler);
1115 close(fds[0]);
1116 close(fds[1]);
1117 }
1118
1119 /*
1120 * @tc.name: AddFileDescriptorListener001
1121 * @tc.desc: add file descriptor listener multi times
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(LibEventHandlerEventQueueTest, AddFileDescriptorListener001, TestSize.Level1)
1125 {
1126 /**
1127 * @tc.setup: init handler and runner, prepare queue.
1128 */
1129 auto runner = EventRunner::Create(false);
1130 auto handler = std::make_shared<EventHandler>(runner);
1131 EventQueue queue;
1132 queue.Prepare();
1133
1134 int32_t fds[] = {-1, -1};
1135 int32_t fileDescriptor = InitFileDescriptor(fds);
1136 uint32_t listenEvent = 1;
1137
1138 /**
1139 * @tc.steps: step1. add file descriptor listener to queue multi times, then remove file descriptor listener
1140 * with handler, close pipe.
1141 * @tc.expected: step1. first time add file descriptor listener success, second time failed.
1142 */
1143 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1144 fileDescriptorListener->SetOwner(handler);
1145 auto result = queue.AddFileDescriptorListener(fileDescriptor, listenEvent, fileDescriptorListener);
1146 EXPECT_EQ(result, ERR_OK);
1147 result = queue.AddFileDescriptorListener(fileDescriptor, listenEvent, fileDescriptorListener);
1148 EXPECT_EQ(result, EVENT_HANDLER_ERR_FD_ALREADY);
1149 queue.RemoveFileDescriptorListener(handler);
1150 close(fds[0]);
1151 close(fds[1]);
1152 }
1153
1154 /*
1155 * @tc.name: AddFileDescriptorListener002
1156 * @tc.desc: add file descriptor listener with wrong type of event
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(LibEventHandlerEventQueueTest, AddFileDescriptorListener002, TestSize.Level1)
1160 {
1161 /**
1162 * @tc.setup: init handler and runner, prepare queue.
1163 */
1164 auto runner = EventRunner::Create(false);
1165 auto handler = std::make_shared<EventHandler>(runner);
1166 EventQueue queue;
1167 queue.Prepare();
1168
1169 /**
1170 * @tc.steps: step1. add file descriptor listener to queue with wrong type of event,
1171 * then remove file descriptor listener with handler, close pipe.
1172 * @tc.expected: step1. add file descriptor listener failed.
1173 */
1174 int32_t fds[] = {-1, -1};
1175 int32_t fileDescriptor = InitFileDescriptor(fds);
1176 uint32_t newEvent = 0;
1177
1178 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1179 fileDescriptorListener->SetOwner(handler);
1180 auto result = queue.AddFileDescriptorListener(fileDescriptor, newEvent, fileDescriptorListener);
1181 EXPECT_EQ(result, EVENT_HANDLER_ERR_INVALID_PARAM);
1182 queue.RemoveFileDescriptorListener(handler);
1183 close(fds[0]);
1184 close(fds[1]);
1185 }
1186
1187 /*
1188 * @tc.name: AddFileDescriptorListener003
1189 * @tc.desc: add file descriptor listener with nullptr listener function
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(LibEventHandlerEventQueueTest, AddFileDescriptorListener003, TestSize.Level1)
1193 {
1194 /**
1195 * @tc.setup: init handler and runner, prepare queue.
1196 */
1197 auto runner = EventRunner::Create(false);
1198 auto handler = std::make_shared<EventHandler>(runner);
1199 EventQueue queue;
1200 queue.Prepare();
1201
1202 /**
1203 * @tc.steps: step1. add file descriptor listener to queue with nullptr listener,
1204 * then remove file descriptor listener with handler, close pipe.
1205 * @tc.expected: step1. add file descriptor listener failed.
1206 */
1207 int32_t fds[] = {-1, -1};
1208 int32_t fileDescriptor = InitFileDescriptor(fds);
1209 uint32_t event = 1;
1210
1211 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1212 fileDescriptorListener->SetOwner(handler);
1213 auto result = queue.AddFileDescriptorListener(fileDescriptor, event, nullptr);
1214 EXPECT_EQ(result, EVENT_HANDLER_ERR_INVALID_PARAM);
1215 queue.RemoveFileDescriptorListener(handler);
1216 close(fds[0]);
1217 close(fds[1]);
1218 }
1219
1220 /*
1221 * @tc.name: AddFileDescriptorListener004
1222 * @tc.desc: add file descriptor listener with wrong fd
1223 * @tc.type: FUNC
1224 */
1225 HWTEST_F(LibEventHandlerEventQueueTest, AddFileDescriptorListener004, TestSize.Level1)
1226 {
1227 /**
1228 * @tc.setup: init handler and runner, prepare queue.
1229 */
1230 auto runner = EventRunner::Create(false);
1231 auto handler = std::make_shared<EventHandler>(runner);
1232 EventQueue queue;
1233 queue.Prepare();
1234
1235 /**
1236 * @tc.steps: step1. add file descriptor listener to queue with wrong pipe, then remove
1237 * file descriptor listener with handler, close pipe.
1238 * @tc.expected: step1. add file descriptor listener failed.
1239 */
1240 int32_t fds[] = {-1, -1};
1241
1242 int32_t fileDescriptor = fds[0];
1243 uint32_t event = 1;
1244 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1245 fileDescriptorListener->SetOwner(handler);
1246 auto result = queue.AddFileDescriptorListener(fileDescriptor, event, fileDescriptorListener);
1247 EXPECT_EQ(result, EVENT_HANDLER_ERR_INVALID_PARAM);
1248 queue.RemoveFileDescriptorListener(handler);
1249 close(fds[0]);
1250 close(fds[1]);
1251 }
1252
1253 /*
1254 * @tc.name: AddFileDescriptorListener005
1255 * @tc.desc: add file descriptor listener when there are too many open files
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(LibEventHandlerEventQueueTest, AddFileDescriptorListener005, TestSize.Level1)
1259 {
1260 /**
1261 * @tc.setup: init queue, prepare queue.
1262 */
1263 int32_t fds[] = {-1, -1};
1264 auto result = pipe(fds);
1265 EXPECT_GE(result, 0);
1266 EventQueue queue;
1267 queue.Prepare();
1268 int32_t readFileDescriptor = fds[0];
1269
1270 /**
1271 * @tc.steps: step1. get max num of files the system could support, and open max files
1272 */
1273 struct rlimit rLimit {};
1274 result = getrlimit(RLIMIT_NOFILE, &rLimit);
1275 EXPECT_EQ(result, 0);
1276 for (uint64_t pos = 1; pos < rLimit.rlim_cur; pos++) {
1277 dup(readFileDescriptor);
1278 }
1279
1280 /**
1281 * @tc.steps: step2. add file descriptor listener to queue, then remove
1282 * file descriptor listener with handler, close pipe.
1283 * @tc.expected: step2. add file descriptor listener failed.
1284 */
1285 uint32_t event = (FILE_DESCRIPTOR_INPUT_EVENT | FILE_DESCRIPTOR_OUTPUT_EVENT);
1286 auto fileDescriptorListener = std::make_shared<MyFileDescriptorListener>();
1287 result = queue.AddFileDescriptorListener(readFileDescriptor, event, fileDescriptorListener);
1288 EXPECT_EQ(result, EVENT_HANDLER_ERR_FD_NOT_SUPPORT);
1289 close(fds[0]);
1290 close(fds[1]);
1291 }
1292
1293 /*
1294 * @tc.name: HasEventWithID001
1295 * @tc.desc: check whether an event with the given ID can be found among the events that have been
1296 * sent but not processed.
1297 * @tc.type: FUNC
1298 */
1299 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithID001, TestSize.Level1)
1300 {
1301 /**
1302 * @tc.setup: init handler and runner.
1303 */
1304
1305 auto runner = EventRunner::Create(true);
1306 auto handler = std::make_shared<EventHandler>(runner);
1307 auto event = InnerEvent::Get(HAS_EVENT_ID);
1308
1309 /**
1310 * @tc.steps: step1. send a event with delay time, then check has this event with this id,
1311 * then check executed after delay time has no this event with this id.
1312 * @tc.expected: step1. Has this event with event id.
1313 */
1314 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1315 bool HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_ID);
1316 EXPECT_TRUE(HasInnerEvent);
1317 int64_t delayWaitTime = 100000;
1318 usleep(delayWaitTime);
1319 HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_ID);
1320 EXPECT_FALSE(HasInnerEvent);
1321 }
1322
1323 /*
1324 * @tc.name: HasEventWithID002
1325 * @tc.desc: check when runner is null ptr Has Inner Event process fail
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithID002, TestSize.Level1)
1329 {
1330 /**
1331 * @tc.setup: init runner.
1332 */
1333 auto handler = std::make_shared<EventHandler>(nullptr);
1334 auto event = InnerEvent::Get(HAS_EVENT_ID);
1335
1336 /**
1337 * @tc.steps: step1. HasInnerEvent process
1338 *
1339 * @tc.expected: step1. HasInnerEvent process fail.
1340 */
1341 bool HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_ID);
1342 EXPECT_FALSE(HasInnerEvent);
1343 }
1344
1345 /*
1346 * @tc.name: HasEventWithID003
1347 * @tc.desc: check when runner is null ptr Has Inner Event process fail
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithID003, TestSize.Level1)
1351 {
1352 /**
1353 * @tc.setup: init runner.
1354 */
1355 auto runner = EventRunner::Create(true);
1356
1357 auto event = InnerEvent::Get(HAS_EVENT_ID);
1358
1359 /**
1360 * @tc.steps: step1. HasInnerEvent process
1361 *
1362 * @tc.expected: step1. HasInnerEvent process fail.
1363 */
1364 bool HasInnerEvent = runner->GetEventQueue()->HasInnerEvent(nullptr, HAS_EVENT_ID);
1365 EXPECT_FALSE(HasInnerEvent);
1366 }
1367
1368 /*
1369 * @tc.name: HasEventWithParam001
1370 * @tc.desc: check whether an event with the given param can be found among the events that have been
1371 * sent but not processed.
1372 * @tc.type: FUNC
1373 */
1374 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithParam001, TestSize.Level1)
1375 {
1376 /**
1377 * @tc.setup: init handler and runner.
1378 */
1379
1380 auto runner = EventRunner::Create(true);
1381 auto handler = std::make_shared<EventHandler>(runner);
1382 auto event = InnerEvent::Get(HAS_EVENT_ID, HAS_EVENT_PARAM);
1383
1384 /**
1385 * @tc.steps: step1. send a event with delay time, then check has this event with this param,
1386 * then check executed after delay time has no this event with this param.
1387 * @tc.expected: step1. Has this event with event param.
1388 */
1389 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1390 bool HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_PARAM);
1391 EXPECT_TRUE(HasInnerEvent);
1392 int64_t delayWaitTime = 100000;
1393 usleep(delayWaitTime);
1394 HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_PARAM);
1395 EXPECT_FALSE(HasInnerEvent);
1396 }
1397
1398 /*
1399 * @tc.name: HasEventWithParam002
1400 * @tc.desc: check when runner is null ptr Has Inner Event process fail
1401 * @tc.type: FUNC
1402 */
1403 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithParam002, TestSize.Level1)
1404 {
1405 /**
1406 * @tc.setup: init runner.
1407 */
1408 auto handler = std::make_shared<EventHandler>(nullptr);
1409 auto event = InnerEvent::Get(HAS_EVENT_PARAM);
1410
1411 /**
1412 * @tc.steps: step1. HasInnerEvent process
1413 *
1414 * @tc.expected: step1. HasInnerEvent process fail.
1415 */
1416 bool HasInnerEvent = handler->HasInnerEvent(HAS_EVENT_PARAM);
1417 EXPECT_FALSE(HasInnerEvent);
1418 }
1419
1420 /*
1421 * @tc.name: HasEventWithParam003
1422 * @tc.desc: check when runner is null ptr Has Inner Event process fail
1423 * @tc.type: FUNC
1424 */
1425 HWTEST_F(LibEventHandlerEventQueueTest, HasEventWithParam003, TestSize.Level1)
1426 {
1427 /**
1428 * @tc.setup: init runner.
1429 */
1430 auto runner = EventRunner::Create(true);
1431
1432 auto event = InnerEvent::Get(HAS_EVENT_PARAM);
1433
1434 /**
1435 * @tc.steps: step1. HasInnerEvent process
1436 *
1437 * @tc.expected: step1. HasInnerEvent process fail.
1438 */
1439 bool HasInnerEvent = runner->GetEventQueue()->HasInnerEvent(nullptr, HAS_EVENT_PARAM);
1440 EXPECT_FALSE(HasInnerEvent);
1441 }
1442
1443 /*
1444 * @tc.name: GetEventName001
1445 * @tc.desc: check when send event has no task return event id
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(LibEventHandlerEventQueueTest, GetEventName001, TestSize.Level1)
1449 {
1450 /**
1451 * @tc.setup: init runner and handler
1452 */
1453 auto runner = EventRunner::Create(true);
1454 auto handler = std::make_shared<EventHandler>(runner);
1455 auto event = InnerEvent::Get(HAS_EVENT_ID);
1456
1457 /**
1458 * @tc.steps: step1. GetEventName
1459 * @tc.expected: step1. GetEventName return event id
1460 */
1461 std::string eventName = handler->GetEventName(event);
1462 EXPECT_EQ(eventName, std::to_string(HAS_EVENT_ID));
1463 }
1464
1465 /*
1466 * @tc.name: GetEventName002
1467 * @tc.desc: check when send event has task event name is "name" return event name "name"
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(LibEventHandlerEventQueueTest, GetEventName002, TestSize.Level1)
1471 {
1472 /**
1473 * @tc.setup: init runner and handler
1474 */
1475 auto runner = EventRunner::Create(true);
1476 auto handler = std::make_shared<EventHandler>(runner);
__anon2a5376800f02() 1477 auto task = []() {; };
1478 auto event = InnerEvent::Get(task, "name");
1479
1480 /**
1481 * @tc.steps: step1. GetEventName
1482 * @tc.expected: step1. GetEventName return name
1483 */
1484 std::string eventName = handler->GetEventName(event);
1485 EXPECT_EQ(eventName, "name");
1486 }
1487
1488 /*
1489 * @tc.name: GetEventName003
1490 * @tc.desc: check when send event has task task name is "" return event name ""
1491 * @tc.type: FUNC
1492 */
1493 HWTEST_F(LibEventHandlerEventQueueTest, GetEventName003, TestSize.Level1)
1494 {
1495 /**
1496 * @tc.setup: init runner and handler
1497 */
1498 auto runner = EventRunner::Create(true);
1499 auto handler = std::make_shared<EventHandler>(runner);
__anon2a5376801002() 1500 auto task = []() {; };
1501 auto event = InnerEvent::Get(task, "");
1502
1503 /**
1504 * @tc.steps: step1. GetEventName
1505 * @tc.expected: step1. GetEventName return name
1506 */
1507 std::string eventName = handler->GetEventName(event);
1508 EXPECT_EQ(eventName, "");
1509 }
1510
1511 /*
1512 * @tc.name: Dump001
1513 * @tc.desc: Check Dump
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(LibEventHandlerEventQueueTest, Dump001, TestSize.Level1)
1517 {
1518 /**
1519 * @tc.setup: init runner and handler
1520 */
1521 auto runner = EventRunner::Create(true);
1522 auto handler = std::make_shared<EventHandler>(runner);
__anon2a5376801102() 1523 auto task = []() {; };
1524 auto event = InnerEvent::Get(task, "");
1525 DumpTest dumptest;
1526 /**
1527 * @tc.steps: step1. Dump
1528 * @tc.expected: step1. Dump Success
1529 */
1530 usleep(100 * 1000);
1531 handler->Dump(dumptest);
1532 EXPECT_TRUE(isDump);
1533 }
1534
1535 /*
1536 * @tc.name: Dump002
1537 * @tc.desc: Check Dump after post task
1538 * @tc.type: FUNC
1539 */
1540 HWTEST_F(LibEventHandlerEventQueueTest, Dump002, TestSize.Level1)
1541 {
1542 isDump = false;
1543 /**
1544 * @tc.setup: init runner and handler
1545 */
1546 auto runner = EventRunner::Create(true);
1547 auto handler = std::make_shared<EventHandler>(runner);
__anon2a5376801202() 1548 auto task = []() {; };
1549 DumpTest dumptest;
1550 /**
1551 * @tc.steps: step1. PosTask then PostTask
1552 * @tc.expected: step1. PostTask success
1553 */
1554 handler->PostTask(task, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1555 usleep(100 * 1000);
1556 handler->Dump(dumptest);
1557 EXPECT_TRUE(isDump);
1558 }
1559
1560 /*
1561 * @tc.name: Dump003
1562 * @tc.desc: Check Dump after send event with event id
1563 * @tc.type: FUNC
1564 */
1565 HWTEST_F(LibEventHandlerEventQueueTest, Dump003, TestSize.Level1)
1566 {
1567 isDump = false;
1568 /**
1569 * @tc.setup: init runner and handler
1570 */
1571 auto runner = EventRunner::Create(true);
1572 auto handler = std::make_shared<EventHandler>(runner);
1573 auto event = InnerEvent::Get(HAS_EVENT_ID);
1574 DumpTest dumptest;
1575 /**
1576 * @tc.steps: step1. SendEvent then Dump
1577 * @tc.expected: step1. Dump Success
1578 */
1579 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1580 usleep(100 * 1000);
1581 handler->Dump(dumptest);
1582 EXPECT_TRUE(isDump);
1583 }
1584
1585 /*
1586 * @tc.name: Dump004
1587 * @tc.desc: Check Dump after send event with event id and param
1588 * @tc.type: FUNC
1589 */
1590 HWTEST_F(LibEventHandlerEventQueueTest, Dump004, TestSize.Level1)
1591 {
1592 isDump = false;
1593 /**
1594 * @tc.setup: init runner and handler
1595 */
1596 auto runner = EventRunner::Create(true);
1597 auto handler = std::make_shared<EventHandler>(runner);
1598 auto event = InnerEvent::Get(HAS_EVENT_ID, HAS_EVENT_PARAM);
1599 DumpTest dumptest;
1600 /**
1601 * @tc.steps: step1. SendEvent then Dump
1602 * @tc.expected: step1. Dump Success
1603 */
1604 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1605 usleep(100 * 1000);
1606 handler->Dump(dumptest);
1607 EXPECT_TRUE(isDump);
1608 }
1609
1610 /*
1611 * @tc.name: Dump005
1612 * @tc.desc: check when send event and post task dump success
1613 * @tc.type: FUNC
1614 */
1615 HWTEST_F(LibEventHandlerEventQueueTest, Dump005, TestSize.Level1)
1616 {
1617 isDump = false;
1618 /**
1619 * @tc.setup: init runner and handler
1620 */
1621 auto runner = EventRunner::Create(true);
1622 auto handler = std::make_shared<EventHandler>(runner);
1623 auto event = InnerEvent::Get(HAS_EVENT_ID, HAS_EVENT_PARAM);
__anon2a5376801302() 1624 auto task = []() {; };
1625 DumpTest dumptest;
1626
1627 /**
1628 * @tc.steps: step1. send event and post task then dump
1629 * @tc.expected: step1. dump success
1630 */
1631 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1632 handler->PostTask(task, HAS_DELAY_TIME * 2, EventQueue::Priority::LOW);
1633 usleep(100 * 1000);
1634 handler->Dump(dumptest);
1635 EXPECT_TRUE(isDump);
1636 }
1637
1638 /*
1639 * @tc.name: IsIdle
1640 * @tc.desc: check when idle IsIdle return true
1641 * @tc.type: FUNC
1642
1643 */
1644 HWTEST_F(LibEventHandlerEventQueueTest, IsIdle001, TestSize.Level1)
1645 {
1646 auto runner = EventRunner::Create(true);
1647 auto handler = std::make_shared<EventHandler>(runner);
1648 /**
1649 * @tc.steps: step1. IsIdle
1650 * @tc.expected: step1. when idle IsIdle return true
1651 */
1652 bool ret = handler->IsIdle();
1653 EXPECT_TRUE(ret);
1654 }
1655
1656 /*
1657 * @tc.name: IsQueueEmpty001
1658 * @tc.desc: check when queue is empty IsQueueEmpty return true
1659 * @tc.type: FUNC
1660 */
1661 HWTEST_F(LibEventHandlerEventQueueTest, IsQueueEmpty001, TestSize.Level1)
1662 {
1663 auto runner = EventRunner::Create(true);
1664 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1665 EXPECT_TRUE(ret);
1666 }
1667
1668 /*
1669 * @tc.name: IsQueueEmpty002
1670 * @tc.desc: check when queue is not empty has low event IsQueueEmpty return false
1671 * @tc.type: FUNC
1672 */
1673 HWTEST_F(LibEventHandlerEventQueueTest, IsQueueEmpty002, TestSize.Level1)
1674 {
1675 /**
1676 * @tc.setup: init runner and handler
1677 */
1678 auto runner = EventRunner::Create(true);
1679 auto handler = std::make_shared<EventHandler>(runner);
1680 auto event = InnerEvent::Get(HAS_EVENT_ID, HAS_EVENT_PARAM);
1681
1682 /**
1683 * @tc.steps: step1. send event and IsQueueEmpty
1684 * @tc.expected: step1. when queue is not empty has low event IsQueueEmpty return false
1685 */
1686 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::LOW);
1687 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1688 EXPECT_FALSE(ret);
1689 }
1690
1691 /*
1692 * @tc.name: IsQueueEmpty003
1693 * @tc.desc: check when queue is not empty has idle event IsQueueEmpty return false
1694 * @tc.type: FUNC
1695 */
1696 HWTEST_F(LibEventHandlerEventQueueTest, IsQueueEmpty003, TestSize.Level1)
1697 {
1698 /**
1699 * @tc.setup: init runner and handler
1700 */
1701 auto runner = EventRunner::Create(true);
1702 auto handler = std::make_shared<EventHandler>(runner);
1703 auto event = InnerEvent::Get(HAS_EVENT_ID, HAS_EVENT_PARAM);
1704
1705 /**
1706 * @tc.steps: step1. send event and IsQueueEmpty
1707 * @tc.expected: step1. when queue is not empty has idle event IsQueueEmpty return false
1708 */
1709 handler->SendEvent(event, HAS_DELAY_TIME, EventQueue::Priority::IDLE);
1710 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1711 EXPECT_FALSE(ret);
1712 }