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 <sys/prctl.h>
19 #include <thread>
20
21 #include "event_handler.h"
22 #include "event_queue.h"
23 #include "event_runner.h"
24 #include "inner_event.h"
25
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::AppExecFwk;
29
30 namespace {
31 bool g_isSetLogger = false;
32 bool g_isDump = false;
33 const uint32_t EVENT_ID_1 = 1;
34 const uint32_t EVENT_ID_2 = 2;
35 const uint32_t EVENT_ID_3 = 3;
36 const uint32_t EVENT_ID_4 = 4;
37 const uint32_t EVENT_ID_5 = 5;
38 const int64_t FLAG_ONE = 1;
39 const int64_t FLAG_TWO = 2;
40 const int64_t FLAG_THREE = 3;
41 const int64_t FLAG_FOUR = 4;
42 const int64_t FLAG_FIVE = 5;
43 const uint32_t EVENT_PARAM = 100;
44 const uint32_t DELAY_TIME = 100;
45 const std::string THREAD_NAME_TEST1 = "threadNameTest1";
46 const std::string THREAD_NAME_TEST2 = " ";
47 const std::string THREAD_NAME_TEST3 = "3243adsafdf";
48 const std::string THREAD_NAME_TEST4 = std::to_string(0);
49 const std::string THREAD_NAME_TEST5 = std::to_string(0) + "3243adsafdf";
50 } // namespace
51
52 class EmsEventRunnerSystemTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55 static void TearDownTestCase(void);
56 void SetUp();
57 void TearDown();
58 };
59
SetUpTestCase(void)60 void EmsEventRunnerSystemTest::SetUpTestCase(void)
61 {}
62
TearDownTestCase(void)63 void EmsEventRunnerSystemTest::TearDownTestCase(void)
64 {}
65
SetUp(void)66 void EmsEventRunnerSystemTest::SetUp(void)
67 {}
68
TearDown(void)69 void EmsEventRunnerSystemTest::TearDown(void)
70 {}
71
72 class DumpTest : public Dumper {
73 public:
74 /**
75 * Processes the content of a specified string.
76 * @param message the content of a specified string.
77 */
Dump(const std::string & message)78 void Dump(const std::string &message)
79 {
80 g_isDump = true;
81 GTEST_LOG_(INFO) << message;
82 }
83
84 /**
85 * Obtains the tag information.
86 * which is a prefix added to each string before the string content is processed.
87 * @return the tag information.
88 */
GetTag()89 std::string GetTag()
90 {
91 return "DumpTest";
92 }
93 };
94
95 class LoggerTest001 : public Logger {
96 public:
97 /**
98 * Processes the content of a specified string.
99 * @param message the content of a specified string.
100 */
Log(const std::string & line)101 void Log(const std::string &line)
102 {
103 g_isSetLogger = true;
104 GTEST_LOG_(INFO) << line;
105 };
~LoggerTest001()106 virtual ~LoggerTest001()
107 {}
108 };
109
110 class LoggerTest002 : public Logger {
111 public:
112 /**
113 * Processes the content of a specified string.
114 * @param message the content of a specified string.
115 */
Log(const std::string & line)116 void Log(const std::string &line)
117 {
118 g_isSetLogger = true;
119 GTEST_LOG_(INFO) << line;
120 };
~LoggerTest002()121 virtual ~LoggerTest002()
122 {}
123 };
124
125 class LoggerTest003 : public Logger {
126 public:
127 /**
128 * Processes the content of a specified string.
129 * @param message the content of a specified string.
130 */
Log(const std::string & line)131 void Log(const std::string &line)
132 {
133 g_isSetLogger = true;
134 GTEST_LOG_(INFO) << line;
135 };
~LoggerTest003()136 virtual ~LoggerTest003()
137 {}
138 };
139
140 class LoggerTest004 : public Logger {
141 public:
142 /**
143 * Processes the content of a specified string.
144 * @param message the content of a specified string.
145 */
Log(const std::string & line)146 void Log(const std::string &line)
147 {
148 g_isSetLogger = true;
149 GTEST_LOG_(INFO) << line;
150 };
~LoggerTest004()151 virtual ~LoggerTest004()
152 {}
153 };
154
155 class LoggerTest005 : public Logger {
156 public:
157 /**
158 * Processes the content of a specified string.
159 * @param message the content of a specified string.
160 */
Log(const std::string & line)161 void Log(const std::string &line)
162 {
163 g_isSetLogger = true;
164 GTEST_LOG_(INFO) << line;
165 };
~LoggerTest005()166 virtual ~LoggerTest005()
167 {}
168 };
169
170 /**
171 * Wait until task is executed.
172 *
173 * @param f task we post.
174 * @param handler handler we use to post task.
175 * @param taskCalled flag to record whether task is executed.
176 */
177 template <typename F>
WaitUntilTaskCalled(F const & f,const std::shared_ptr<EventHandler> & handler,const std::atomic<bool> & taskCalled)178 static void WaitUntilTaskCalled(
179 F const &f, const std::shared_ptr<EventHandler> &handler, const std::atomic<bool> &taskCalled)
180 {
181 const uint32_t maxRetryCount = 1000;
182 const uint32_t sleepTime = 1000;
183 uint32_t count = 0;
184 if (handler->PostTask(f)) {
185 while (!taskCalled.load()) {
186 ++count;
187 // if delay more than 1 second, break
188 if (count >= maxRetryCount) {
189 break;
190 }
191
192 usleep(sleepTime);
193 }
194 }
195 }
196
197 /**
198 * Create runner with name.
199 *
200 * @param handler handler we use to post task.
201 * @param threadName name of thread we set.
202 */
CreateRunnerWithName(const std::shared_ptr<EventHandler> & handler,const std::string & threadName)203 static void CreateRunnerWithName(const std::shared_ptr<EventHandler> &handler, const std::string &threadName)
204 {
205 std::atomic<bool> sameThreadName(false);
206 std::atomic<bool> taskCalled(false);
207 auto f = [&sameThreadName, &taskCalled, &threadName]() {
208 const size_t maxThreadNameSize = 16;
209 char thisThreadName[maxThreadNameSize + 1];
210
211 // Get current thread name and compare with the specified one.
212 int32_t ret = prctl(PR_GET_NAME, thisThreadName);
213 if (ret == 0) {
214 thisThreadName[maxThreadNameSize] = '\0';
215 sameThreadName.store(threadName == thisThreadName);
216 }
217
218 taskCalled.store(true);
219 };
220
221 WaitUntilTaskCalled(f, handler, taskCalled);
222
223 auto called = taskCalled.load();
224 EXPECT_TRUE(called);
225 auto sameThread = sameThreadName.load();
226 EXPECT_TRUE(sameThread);
227 }
228
229 /*
230 * @tc.name: SetLogger001
231 * @tc.desc: check SetLogger001 success
232 * @tc.type: FUNC
233 */
234 HWTEST_F(EmsEventRunnerSystemTest, SetLogger001, TestSize.Level1)
235 {
236 auto runner = EventRunner::Create(true);
237 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70302() 238 auto task = []() { ; };
239
240 g_isSetLogger = false;
241 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
242 runner->SetLogger(logtest);
243 handler->PostTask(task);
244 usleep(100 * 1000);
245 EXPECT_TRUE(g_isSetLogger);
246 }
247
248 /*
249 * @tc.name: SetLogger002
250 * @tc.desc: check SetLogger002 success
251 * @tc.type: FUNC
252 */
253 HWTEST_F(EmsEventRunnerSystemTest, SetLogger002, TestSize.Level1)
254 {
255 auto runner = EventRunner::Create(true);
256 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70402() 257 auto task = []() { ; };
258 g_isSetLogger = false;
259 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
260 runner->SetLogger(logtest);
261 handler->PostTask(task);
262 usleep(100 * 1000);
263 EXPECT_TRUE(g_isSetLogger);
264 }
265
266 /*
267 * @tc.name: SetLogger003
268 * @tc.desc: check SetLogger001 success
269 * @tc.type: FUNC
270 */
271 HWTEST_F(EmsEventRunnerSystemTest, SetLogger003, TestSize.Level1)
272 {
273 auto runner = EventRunner::Create(true);
274 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70502() 275 auto task = []() { ; };
276 g_isSetLogger = false;
277 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
278 runner->SetLogger(logtest);
279 handler->PostTask(task);
280 usleep(100 * 1000);
281 EXPECT_TRUE(g_isSetLogger);
282 }
283
284 /*
285 * @tc.name: SetLogger004
286 * @tc.desc: check SetLogger001 success
287 * @tc.type: FUNC
288 */
289 HWTEST_F(EmsEventRunnerSystemTest, SetLogger004, TestSize.Level1)
290 {
291 auto runner = EventRunner::Create(true);
292 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70602() 293 auto task = []() { ; };
294 g_isSetLogger = false;
295 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
296 runner->SetLogger(logtest);
297 handler->PostTask(task);
298 usleep(100 * 1000);
299 EXPECT_TRUE(g_isSetLogger);
300 }
301
302 /*
303 * @tc.name: SetLogger005
304 * @tc.desc: check SetLogger001 success
305 * @tc.type: FUNC
306 */
307 HWTEST_F(EmsEventRunnerSystemTest, SetLogger005, TestSize.Level1)
308 {
309 auto runner = EventRunner::Create(true);
310 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70702() 311 auto task = []() { ; };
312 g_isSetLogger = false;
313 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
314 runner->SetLogger(logtest);
315 handler->PostTask(task);
316 usleep(100 * 1000);
317 EXPECT_TRUE(g_isSetLogger);
318 }
319
320 /*
321 * @tc.name: SetLogger006
322 * @tc.desc: check SetLogger006 success
323 * @tc.type: FUNC
324 */
325 HWTEST_F(EmsEventRunnerSystemTest, SetLogger006, TestSize.Level1)
326 {
327 auto runner = EventRunner::Create(true);
328 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70802() 329 auto task = []() { ; };
330
331 g_isSetLogger = false;
332 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
333 runner->SetLogger(logtest);
334 handler->PostTask(task, EventHandler::Priority::HIGH);
335 usleep(100 * 1000);
336 EXPECT_TRUE(g_isSetLogger);
337 }
338
339 /*
340 * @tc.name: SetLogger007
341 * @tc.desc: check SetLogger007 success
342 * @tc.type: FUNC
343 */
344 HWTEST_F(EmsEventRunnerSystemTest, SetLogger007, TestSize.Level1)
345 {
346 auto runner = EventRunner::Create(true);
347 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70902() 348 auto task = []() { ; };
349 g_isSetLogger = false;
350 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
351 runner->SetLogger(logtest);
352 handler->PostTask(task, EventHandler::Priority::LOW);
353 usleep(100 * 1000);
354 EXPECT_TRUE(g_isSetLogger);
355 }
356
357 /*
358 * @tc.name: SetLogger008
359 * @tc.desc: check SetLogger008 success
360 * @tc.type: FUNC
361 */
362 HWTEST_F(EmsEventRunnerSystemTest, SetLogger008, TestSize.Level1)
363 {
364 auto runner = EventRunner::Create();
365 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70a02() 366 auto task = []() { ; };
367 g_isSetLogger = false;
368 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
369 runner->SetLogger(logtest);
370 handler->PostTask(task, EventHandler::Priority::IMMEDIATE);
371 usleep(100 * 1000);
372 EXPECT_TRUE(g_isSetLogger);
373 }
374
375 /*
376 * @tc.name: SetLogger009
377 * @tc.desc: check SetLogger009 success
378 * @tc.type: FUNC
379 */
380 HWTEST_F(EmsEventRunnerSystemTest, SetLogger009, TestSize.Level1)
381 {
382 auto runner = EventRunner::Create();
383 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70b02() 384 auto task = []() { ; };
385 g_isSetLogger = false;
386 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
387 runner->SetLogger(logtest);
388 handler->PostTask(task, EventHandler::Priority::IDLE);
389 usleep(500 * 1000);
390 EXPECT_FALSE(g_isSetLogger);
391 }
392
393 /*
394 * @tc.name: SetLogger010
395 * @tc.desc: check SetLogger010 success
396 * @tc.type: FUNC
397 */
398 HWTEST_F(EmsEventRunnerSystemTest, SetLogger010, TestSize.Level1)
399 {
400 auto runner = EventRunner::Create(true);
401 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70c02() 402 auto task = []() { ; };
403 g_isSetLogger = false;
404 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
405 runner->SetLogger(logtest);
406 handler->PostTask(task, EventHandler::Priority::IDLE);
407 usleep(500 * 1000);
408 EXPECT_FALSE(g_isSetLogger);
409 }
410
411 /*
412 * @tc.name: SetLogger011
413 * @tc.desc: check SetLogger011 success
414 * @tc.type: FUNC
415 */
416 HWTEST_F(EmsEventRunnerSystemTest, SetLogger011, TestSize.Level1)
417 {
418 auto runner = EventRunner::Create(true);
419 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70d02() 420 auto task = []() { ; };
421
422 g_isSetLogger = false;
423 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
424 runner->SetLogger(logtest);
425 handler->PostTimingTask(task, FLAG_ONE, std::string());
426 usleep(100 * 1000);
427 EXPECT_TRUE(g_isSetLogger);
428 }
429
430 /*
431 * @tc.name: SetLogger012
432 * @tc.desc: check SetLogger012 success
433 * @tc.type: FUNC
434 */
435 HWTEST_F(EmsEventRunnerSystemTest, SetLogger012, TestSize.Level1)
436 {
437 auto runner = EventRunner::Create(true);
438 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70e02() 439 auto task = []() { ; };
440 g_isSetLogger = false;
441 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
442 runner->SetLogger(logtest);
443 handler->PostTimingTask(task, FLAG_TWO, std::string());
444 usleep(100 * 1000);
445 EXPECT_TRUE(g_isSetLogger);
446 }
447
448 /*
449 * @tc.name: SetLogger013
450 * @tc.desc: check SetLogger013 success
451 * @tc.type: FUNC
452 */
453 HWTEST_F(EmsEventRunnerSystemTest, SetLogger013, TestSize.Level1)
454 {
455 auto runner = EventRunner::Create(true);
456 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f70f02() 457 auto task = []() { ; };
458 g_isSetLogger = false;
459 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
460 runner->SetLogger(logtest);
461 handler->PostTimingTask(task, FLAG_THREE, std::string());
462 usleep(100 * 1000);
463 EXPECT_TRUE(g_isSetLogger);
464 }
465
466 /*
467 * @tc.name: SetLogger014
468 * @tc.desc: check SetLogger014 success
469 * @tc.type: FUNC
470 */
471 HWTEST_F(EmsEventRunnerSystemTest, SetLogger014, TestSize.Level1)
472 {
473 auto runner = EventRunner::Create(true);
474 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71002() 475 auto task = []() { ; };
476 g_isSetLogger = false;
477 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
478 runner->SetLogger(logtest);
479 handler->PostTimingTask(task, FLAG_FOUR, std::string());
480 usleep(100 * 1000);
481 EXPECT_TRUE(g_isSetLogger);
482 }
483
484 /*
485 * @tc.name: SetLogger015
486 * @tc.desc: check SetLogger015 success
487 * @tc.type: FUNC
488 */
489 HWTEST_F(EmsEventRunnerSystemTest, SetLogger015, TestSize.Level1)
490 {
491 auto runner = EventRunner::Create(true);
492 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71102() 493 auto task = []() { ; };
494 g_isSetLogger = false;
495 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
496 runner->SetLogger(logtest);
497 handler->PostTimingTask(task, FLAG_FIVE, std::string());
498 usleep(100 * 1000);
499 EXPECT_TRUE(g_isSetLogger);
500 }
501
502 /*
503 * @tc.name: SetLogger016
504 * @tc.desc: check SetLogger016 success
505 * @tc.type: FUNC
506 */
507 HWTEST_F(EmsEventRunnerSystemTest, SetLogger016, TestSize.Level1)
508 {
509 auto runner = EventRunner::Create(true);
510 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71202() 511 auto task = []() { ; };
512
513 g_isSetLogger = false;
514 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
515 runner->SetLogger(logtest);
516 handler->PostTask(task, FLAG_ONE);
517 usleep(100 * 1000);
518 EXPECT_TRUE(g_isSetLogger);
519 }
520
521 /*
522 * @tc.name: SetLogger017
523 * @tc.desc: check SetLogger017 success
524 * @tc.type: FUNC
525 */
526 HWTEST_F(EmsEventRunnerSystemTest, SetLogger017, TestSize.Level1)
527 {
528 auto runner = EventRunner::Create(true);
529 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71302() 530 auto task = []() { ; };
531 g_isSetLogger = false;
532 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
533 runner->SetLogger(logtest);
534 handler->PostTask(task, FLAG_TWO);
535 usleep(100 * 1000);
536 EXPECT_TRUE(g_isSetLogger);
537 }
538
539 /*
540 * @tc.name: SetLogger018
541 * @tc.desc: check SetLogger018 success
542 * @tc.type: FUNC
543 */
544 HWTEST_F(EmsEventRunnerSystemTest, SetLogger018, TestSize.Level1)
545 {
546 auto runner = EventRunner::Create(true);
547 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71402() 548 auto task = []() { ; };
549 g_isSetLogger = false;
550 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
551 runner->SetLogger(logtest);
552 handler->PostTask(task, FLAG_THREE);
553 usleep(100 * 1000);
554 EXPECT_TRUE(g_isSetLogger);
555 }
556
557 /*
558 * @tc.name: SetLogger019
559 * @tc.desc: check SetLogger019 success
560 * @tc.type: FUNC
561 */
562 HWTEST_F(EmsEventRunnerSystemTest, SetLogger019, TestSize.Level1)
563 {
564 auto runner = EventRunner::Create(true);
565 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71502() 566 auto task = []() { ; };
567 g_isSetLogger = false;
568 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
569 runner->SetLogger(logtest);
570 handler->PostTask(task, FLAG_FOUR);
571 usleep(100 * 1000);
572 EXPECT_TRUE(g_isSetLogger);
573 }
574
575 /*
576 * @tc.name: SetLogger020
577 * @tc.desc: check SetLogger020 success
578 * @tc.type: FUNC
579 */
580 HWTEST_F(EmsEventRunnerSystemTest, SetLogger020, TestSize.Level1)
581 {
582 auto runner = EventRunner::Create(true);
583 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71602() 584 auto task = []() { ; };
585 g_isSetLogger = false;
586 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
587 runner->SetLogger(logtest);
588 handler->PostTask(task, FLAG_FIVE);
589 usleep(100 * 1000);
590 EXPECT_TRUE(g_isSetLogger);
591 }
592
593 /*
594 * @tc.name: SetLogger021
595 * @tc.desc: check SetLogger021 success
596 * @tc.type: FUNC
597 */
598 HWTEST_F(EmsEventRunnerSystemTest, SetLogger021, TestSize.Level1)
599 {
600 auto runner = EventRunner::Create(true);
601 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71702() 602 auto task = []() { ; };
603
604 g_isSetLogger = false;
605 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
606 runner->SetLogger(logtest);
607 handler->PostTask(task, FLAG_ONE, EventHandler::Priority::IMMEDIATE);
608 usleep(100 * 1000);
609 EXPECT_TRUE(g_isSetLogger);
610 }
611
612 /*
613 * @tc.name: SetLogger022
614 * @tc.desc: check SetLogger022 success
615 * @tc.type: FUNC
616 */
617 HWTEST_F(EmsEventRunnerSystemTest, SetLogger022, TestSize.Level1)
618 {
619 auto runner = EventRunner::Create(true);
620 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71802() 621 auto task = []() { ; };
622 g_isSetLogger = false;
623 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
624 runner->SetLogger(logtest);
625 handler->PostTask(task, FLAG_TWO, EventHandler::Priority::LOW);
626 usleep(100 * 1000);
627 EXPECT_TRUE(g_isSetLogger);
628 }
629
630 /*
631 * @tc.name: SetLogger023
632 * @tc.desc: check SetLogger023 success
633 * @tc.type: FUNC
634 */
635 HWTEST_F(EmsEventRunnerSystemTest, SetLogger023, TestSize.Level1)
636 {
637 auto runner = EventRunner::Create(true);
638 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71902() 639 auto task = []() { ; };
640 g_isSetLogger = false;
641 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
642 runner->SetLogger(logtest);
643 handler->PostTask(task, FLAG_THREE, EventHandler::Priority::HIGH);
644 usleep(100 * 1000);
645 EXPECT_TRUE(g_isSetLogger);
646 }
647
648 /*
649 * @tc.name: SetLogger024
650 * @tc.desc: check SetLogger024 success
651 * @tc.type: FUNC
652 */
653 HWTEST_F(EmsEventRunnerSystemTest, SetLogger024, TestSize.Level1)
654 {
655 auto runner = EventRunner::Create(true);
656 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71a02() 657 auto task = []() { ; };
658 g_isSetLogger = false;
659 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
660 runner->SetLogger(logtest);
661 handler->PostTask(task, FLAG_FOUR, EventHandler::Priority::IDLE);
662 usleep(500 * 1000);
663 EXPECT_FALSE(g_isSetLogger);
664 }
665
666 /*
667 * @tc.name: SetLogger025
668 * @tc.desc: check SetLogger025 success
669 * @tc.type: FUNC
670 */
671 HWTEST_F(EmsEventRunnerSystemTest, SetLogger025, TestSize.Level1)
672 {
673 auto runner = EventRunner::Create(true);
674 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71b02() 675 auto task = []() { ; };
676 g_isSetLogger = false;
677 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
678 runner->SetLogger(logtest);
679 handler->PostTask(task, FLAG_FIVE, EventHandler::Priority::IDLE);
680 usleep(500 * 1000);
681 EXPECT_FALSE(g_isSetLogger);
682 }
683
684 /*
685 * @tc.name: SetLogger026
686 * @tc.desc: check SetLogger026 success
687 * @tc.type: FUNC
688 */
689 HWTEST_F(EmsEventRunnerSystemTest, SetLogger026, TestSize.Level1)
690 {
691 auto runner = EventRunner::Create(true);
692 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71c02() 693 auto task = []() { ; };
694
695 g_isSetLogger = false;
696 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
697 runner->SetLogger(logtest);
698 handler->PostSyncTask(task, EventHandler::Priority::IMMEDIATE);
699 usleep(100 * 1000);
700 EXPECT_TRUE(g_isSetLogger);
701 }
702
703 /*
704 * @tc.name: SetLogger027
705 * @tc.desc: check SetLogger027 success
706 * @tc.type: FUNC
707 */
708 HWTEST_F(EmsEventRunnerSystemTest, SetLogger027, TestSize.Level1)
709 {
710 auto runner = EventRunner::Create(true);
711 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71d02() 712 auto task = []() { ; };
713 g_isSetLogger = false;
714 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
715 runner->SetLogger(logtest);
716 handler->PostSyncTask(task, EventHandler::Priority::LOW);
717 usleep(100 * 1000);
718 EXPECT_TRUE(g_isSetLogger);
719 }
720
721 /*
722 * @tc.name: SetLogger028
723 * @tc.desc: check SetLogger028 success
724 * @tc.type: FUNC
725 */
726 HWTEST_F(EmsEventRunnerSystemTest, SetLogger028, TestSize.Level1)
727 {
728 auto runner = EventRunner::Create(true);
729 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71e02() 730 auto task = []() { ; };
731 g_isSetLogger = false;
732 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
733 runner->SetLogger(logtest);
734 handler->PostSyncTask(task, EventHandler::Priority::HIGH);
735 usleep(100 * 1000);
736 EXPECT_TRUE(g_isSetLogger);
737 }
738
739 /*
740 * @tc.name: SetLogger029
741 * @tc.desc: check SetLogger029 success
742 * @tc.type: FUNC
743 */
744 HWTEST_F(EmsEventRunnerSystemTest, SetLogger029, TestSize.Level1)
745 {
746 auto runner = EventRunner::Create(true);
747 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f71f02() 748 auto task = []() { ; };
749 g_isSetLogger = false;
750 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
751 runner->SetLogger(logtest);
752 handler->PostSyncTask(task, EventHandler::Priority::IDLE);
753 usleep(500 * 1000);
754 EXPECT_FALSE(g_isSetLogger);
755 }
756
757 /*
758 * @tc.name: SetLogger030
759 * @tc.desc: check SetLogger030 success
760 * @tc.type: FUNC
761 */
762 HWTEST_F(EmsEventRunnerSystemTest, SetLogger030, TestSize.Level1)
763 {
764 auto runner = EventRunner::Create(true);
765 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72002() 766 auto task = []() { ; };
767 g_isSetLogger = false;
768 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
769 runner->SetLogger(logtest);
770 handler->PostSyncTask(task, EventHandler::Priority::IDLE);
771 usleep(500 * 1000);
772 EXPECT_FALSE(g_isSetLogger);
773 }
774
775 /*
776 * @tc.name: SetLogger031
777 * @tc.desc: check SetLogger031 success
778 * @tc.type: FUNC
779 */
780 HWTEST_F(EmsEventRunnerSystemTest, SetLogger031, TestSize.Level1)
781 {
782 auto runner = EventRunner::Create(true);
783 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72102() 784 auto task = []() { ; };
785
786 g_isSetLogger = false;
787 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
788 runner->SetLogger(logtest);
789 handler->PostSyncTask(task);
790 usleep(100 * 1000);
791 EXPECT_TRUE(g_isSetLogger);
792 }
793
794 /*
795 * @tc.name: SetLogger032
796 * @tc.desc: check SetLogger032 success
797 * @tc.type: FUNC
798 */
799 HWTEST_F(EmsEventRunnerSystemTest, SetLogger032, TestSize.Level1)
800 {
801 auto runner = EventRunner::Create(true);
802 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72202() 803 auto task = []() { ; };
804 g_isSetLogger = false;
805 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
806 runner->SetLogger(logtest);
807 handler->PostSyncTask(task);
808 usleep(100 * 1000);
809 EXPECT_TRUE(g_isSetLogger);
810 }
811
812 /*
813 * @tc.name: SetLogger033
814 * @tc.desc: check SetLogger033 success
815 * @tc.type: FUNC
816 */
817 HWTEST_F(EmsEventRunnerSystemTest, SetLogger033, TestSize.Level1)
818 {
819 auto runner = EventRunner::Create(true);
820 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72302() 821 auto task = []() { ; };
822 g_isSetLogger = false;
823 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
824 runner->SetLogger(logtest);
825 handler->PostSyncTask(task);
826 usleep(100 * 1000);
827 EXPECT_TRUE(g_isSetLogger);
828 }
829
830 /*
831 * @tc.name: SetLogger034
832 * @tc.desc: check SetLogger034 success
833 * @tc.type: FUNC
834 */
835 HWTEST_F(EmsEventRunnerSystemTest, SetLogger034, TestSize.Level1)
836 {
837 auto runner = EventRunner::Create(true);
838 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72402() 839 auto task = []() { ; };
840 g_isSetLogger = false;
841 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
842 runner->SetLogger(logtest);
843 handler->PostSyncTask(task);
844 usleep(100 * 1000);
845 EXPECT_TRUE(g_isSetLogger);
846 }
847
848 /*
849 * @tc.name: SetLogger035
850 * @tc.desc: check SetLogger035 success
851 * @tc.type: FUNC
852 */
853 HWTEST_F(EmsEventRunnerSystemTest, SetLogger035, TestSize.Level1)
854 {
855 auto runner = EventRunner::Create(true);
856 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72502() 857 auto task = []() { ; };
858 g_isSetLogger = false;
859 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
860 runner->SetLogger(logtest);
861 handler->PostSyncTask(task);
862 usleep(100 * 1000);
863 EXPECT_TRUE(g_isSetLogger);
864 }
865
866 /*
867 * @tc.name: SetLogger036
868 * @tc.desc: check SetLogger036 success
869 * @tc.type: FUNC
870 */
871 HWTEST_F(EmsEventRunnerSystemTest, SetLogger036, TestSize.Level1)
872 {
873 auto runner = EventRunner::Create(true);
874 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72602() 875 auto task = []() { ; };
876
877 g_isSetLogger = false;
878 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
879 runner->SetLogger(logtest);
880 handler->PostTimingTask(task, FLAG_ONE, EventHandler::Priority::IMMEDIATE);
881 usleep(100 * 1000);
882 EXPECT_TRUE(g_isSetLogger);
883 }
884
885 /*
886 * @tc.name: SetLogger037
887 * @tc.desc: check SetLogger037 success
888 * @tc.type: FUNC
889 */
890 HWTEST_F(EmsEventRunnerSystemTest, SetLogger037, TestSize.Level1)
891 {
892 auto runner = EventRunner::Create(true);
893 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72702() 894 auto task = []() { ; };
895 g_isSetLogger = false;
896 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
897 runner->SetLogger(logtest);
898 handler->PostTimingTask(task, FLAG_TWO, EventHandler::Priority::LOW);
899 usleep(100 * 1000);
900 EXPECT_TRUE(g_isSetLogger);
901 }
902
903 /*
904 * @tc.name: SetLogger038
905 * @tc.desc: check SetLogger038 success
906 * @tc.type: FUNC
907 */
908 HWTEST_F(EmsEventRunnerSystemTest, SetLogger038, TestSize.Level1)
909 {
910 auto runner = EventRunner::Create(true);
911 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72802() 912 auto task = []() { ; };
913 g_isSetLogger = false;
914 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
915 runner->SetLogger(logtest);
916 handler->PostTimingTask(task, FLAG_THREE, EventHandler::Priority::HIGH);
917 usleep(100 * 1000);
918 EXPECT_TRUE(g_isSetLogger);
919 }
920
921 /*
922 * @tc.name: SetLogger039
923 * @tc.desc: check SetLogger039 success
924 * @tc.type: FUNC
925 */
926 HWTEST_F(EmsEventRunnerSystemTest, SetLogger039, TestSize.Level1)
927 {
928 auto runner = EventRunner::Create(true);
929 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72902() 930 auto task = []() { ; };
931 g_isSetLogger = false;
932 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
933 runner->SetLogger(logtest);
934 handler->PostTimingTask(task, FLAG_FOUR, EventHandler::Priority::IDLE);
935 usleep(500 * 1000);
936 EXPECT_FALSE(g_isSetLogger);
937 }
938
939 /*
940 * @tc.name: SetLogger040
941 * @tc.desc: check SetLogger040 success
942 * @tc.type: FUNC
943 */
944 HWTEST_F(EmsEventRunnerSystemTest, SetLogger040, TestSize.Level1)
945 {
946 auto runner = EventRunner::Create(true);
947 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72a02() 948 auto task = []() { ; };
949 g_isSetLogger = false;
950 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
951 runner->SetLogger(logtest);
952 handler->PostTimingTask(task, FLAG_FIVE, EventHandler::Priority::IDLE);
953 usleep(500 * 1000);
954 EXPECT_FALSE(g_isSetLogger);
955 }
956
957 /*
958 * @tc.name: Stop001
959 * @tc.desc: stop eventrunner in synchronous thread
960 * @tc.type: FUNC
961 */
962 HWTEST_F(EmsEventRunnerSystemTest, Stop001, TestSize.Level1)
963 {
964 auto runner = EventRunner::Create(false);
965 auto handler = std::make_shared<EventHandler>(runner);
966 ErrCode result = EVENT_HANDLER_ERR_RUNNER_NO_PERMIT;
__anon38b2a1f72b02() 967 auto f = [&result, runner]() { result = runner->Stop(); };
968
969 if (handler->PostTask(f)) {
970 runner->Run();
971 }
972
973 EXPECT_EQ(ERR_OK, result);
974 }
975
976 /*
977 * @tc.name: Stop002
978 * @tc.desc: stop eventrunner in asynchronous thread
979 * @tc.type: FUNC
980 */
981 HWTEST_F(EmsEventRunnerSystemTest, Stop002, TestSize.Level1)
982 {
983 auto runner = EventRunner::Create();
984
985 auto runResult = runner->Run();
986 auto stopResult = runner->Stop();
987 EXPECT_EQ(EVENT_HANDLER_ERR_RUNNER_NO_PERMIT, runResult);
988 EXPECT_EQ(EVENT_HANDLER_ERR_RUNNER_NO_PERMIT, stopResult);
989 }
990
991 /*
992 * @tc.name: Stop003
993 * @tc.desc: execute Stop() function from one EventRunner multi times
994 * @tc.type: FUNC
995 */
996 HWTEST_F(EmsEventRunnerSystemTest, Stop003, TestSize.Level1)
997 {
998 auto runner = EventRunner::Create(false);
999 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72c02() 1000 auto task = [&runner]() { runner->Stop(); };
1001
1002 handler->PostTask(task);
1003 runner->Run();
1004 usleep(10000);
1005 auto stopResult = runner->Stop();
1006 EXPECT_EQ(ERR_OK, stopResult);
1007 }
1008
1009 /*
1010 * @tc.name: Stop004
1011 * @tc.desc: stop eventrunner success
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(EmsEventRunnerSystemTest, Stop004, TestSize.Level1)
1015 {
1016 auto runner = EventRunner::Create(false);
1017 auto handler = std::make_shared<EventHandler>(runner);
1018
1019 if (handler->SendEvent(EVENT_ID_1, EVENT_PARAM, DELAY_TIME)) {
1020 ErrCode result = runner->Stop();
1021 EXPECT_EQ(ERR_OK, result);
1022 }
1023 }
1024
1025 /*
1026 * @tc.name: Stop004
1027 * @tc.desc: stop eventrunner success
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(EmsEventRunnerSystemTest, Stop005, TestSize.Level1)
1031 {
1032 auto runner = EventRunner::Create(false);
1033 auto handler = std::make_shared<EventHandler>(runner);
1034
1035 if (handler->SendEvent(EVENT_ID_1)) {
1036 ErrCode result = runner->Stop();
1037 EXPECT_EQ(ERR_OK, result);
1038 }
1039 }
1040
1041 /*
1042 * @tc.name: Stop006
1043 * @tc.desc: stop eventrunner success
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(EmsEventRunnerSystemTest, Stop006, TestSize.Level1)
1047 {
1048 auto runner = EventRunner::Create(false);
1049 auto handler = std::make_shared<EventHandler>(runner);
1050
1051 if (handler->SendEvent(EVENT_ID_2)) {
1052 ErrCode result = runner->Stop();
1053 EXPECT_EQ(ERR_OK, result);
1054 }
1055 }
1056
1057 /*
1058 * @tc.name: Stop007
1059 * @tc.desc: stop eventrunner success
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(EmsEventRunnerSystemTest, Stop007, TestSize.Level1)
1063 {
1064 auto runner = EventRunner::Create(false);
1065 auto handler = std::make_shared<EventHandler>(runner);
1066
1067 if (handler->SendEvent(EVENT_ID_3)) {
1068 ErrCode result = runner->Stop();
1069 EXPECT_EQ(ERR_OK, result);
1070 }
1071 }
1072
1073 /*
1074 * @tc.name: Stop008
1075 * @tc.desc: stop eventrunner success
1076 * @tc.type: FUNC
1077 */
1078 HWTEST_F(EmsEventRunnerSystemTest, Stop008, TestSize.Level1)
1079 {
1080 auto runner = EventRunner::Create(false);
1081 auto handler = std::make_shared<EventHandler>(runner);
1082
1083 if (handler->SendEvent(EVENT_ID_4)) {
1084 ErrCode result = runner->Stop();
1085 EXPECT_EQ(ERR_OK, result);
1086 }
1087 }
1088
1089 /*
1090 * @tc.name: Stop009
1091 * @tc.desc: stop eventrunner success
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(EmsEventRunnerSystemTest, Stop009, TestSize.Level1)
1095 {
1096 auto runner = EventRunner::Create(false);
1097 auto handler = std::make_shared<EventHandler>(runner);
1098
1099 if (handler->SendEvent(EVENT_ID_5)) {
1100 ErrCode result = runner->Stop();
1101 EXPECT_EQ(ERR_OK, result);
1102 }
1103 }
1104
1105 /*
1106 * @tc.name: CreateAndRun001
1107 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun001, TestSize.Level1)
1111 {
1112 auto handler = std::make_shared<EventHandler>(EventRunner::Create());
1113 std::atomic<bool> taskCalled(false);
__anon38b2a1f72d02() 1114 auto f = [&taskCalled]() { taskCalled.store(true); };
1115
1116 WaitUntilTaskCalled(f, handler, taskCalled);
1117 auto called = taskCalled.load();
1118 EXPECT_TRUE(called);
1119 }
1120
1121 /*
1122 * @tc.name: CreateAndRun002
1123 * @tc.desc: run ha no permit
1124 * @tc.type: FUNC
1125 */
1126 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun002, TestSize.Level1)
1127 {
1128 auto runner = EventRunner::Create();
1129
1130 auto runResult = runner->Run();
1131 EXPECT_EQ(EVENT_HANDLER_ERR_RUNNER_NO_PERMIT, runResult);
1132 }
1133
1134 /*
1135 * @tc.name: CreateAndRun003
1136 * @tc.desc: create eventrunner and run eventrunner in synchronous thread
1137 * @tc.type: FUNC
1138 */
1139 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun003, TestSize.Level1)
1140 {
1141 auto runner = EventRunner::Create(false);
1142 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72e02() 1143 auto f = [&runner]() { runner->Stop(); };
1144
1145 ErrCode result = EVENT_HANDLER_ERR_RUNNER_NO_PERMIT;
1146 if (handler->PostTask(f)) {
1147 result = runner->Run();
1148 }
1149
1150 EXPECT_EQ(ERR_OK, result);
1151 }
1152
1153 /*
1154 * @tc.name: CreateAndRun004
1155 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread with threadname
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun004, TestSize.Level1)
1159 {
1160 std::string threadName(THREAD_NAME_TEST1);
1161 auto handler = std::make_shared<EventHandler>(EventRunner::Create(threadName));
1162
1163 CreateRunnerWithName(handler, threadName);
1164 }
1165
1166 /*
1167 * @tc.name: CreateAndRun005
1168 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread with threadname
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun005, TestSize.Level1)
1172 {
1173 std::string threadName(THREAD_NAME_TEST2);
1174 auto handler = std::make_shared<EventHandler>(EventRunner::Create(threadName));
1175
1176 CreateRunnerWithName(handler, threadName);
1177 }
1178
1179 /*
1180 * @tc.name: CreateAndRun006
1181 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread with threadname
1182 * @tc.type: FUNC
1183 */
1184 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun006, TestSize.Level1)
1185 {
1186 std::string threadName(THREAD_NAME_TEST3);
1187 auto handler = std::make_shared<EventHandler>(EventRunner::Create(threadName));
1188
1189 CreateRunnerWithName(handler, threadName);
1190 }
1191
1192 /*
1193 * @tc.name: CreateAndRun007
1194 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread with threadname
1195 * @tc.type: FUNC
1196 */
1197 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun007, TestSize.Level1)
1198 {
1199 std::string threadName(THREAD_NAME_TEST4);
1200 auto handler = std::make_shared<EventHandler>(EventRunner::Create(threadName));
1201
1202 CreateRunnerWithName(handler, threadName);
1203 }
1204
1205 /*
1206 * @tc.name: CreateAndRun008
1207 * @tc.desc: create eventrunner and run eventrunner in asynchronous thread with threadname
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun008, TestSize.Level1)
1211 {
1212 std::string threadName(THREAD_NAME_TEST5);
1213 auto handler = std::make_shared<EventHandler>(EventRunner::Create(threadName));
1214
1215 CreateRunnerWithName(handler, threadName);
1216 }
1217
1218 /*
1219 * @tc.name: CreateAndRun009
1220 * @tc.desc: execute Run() function from one EventRunner multi times
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(EmsEventRunnerSystemTest, CreateAndRun009, TestSize.Level1)
1224 {
1225 const int64_t delayTime = 30;
1226 auto runner = EventRunner::Create(false);
1227 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f72f02() 1228 auto mainTask = [&runner]() { runner->Stop(); };
1229
__anon38b2a1f73002() 1230 auto f = [&runner]() {
1231 usleep(10000);
1232 auto runResult = runner->Run();
1233 EXPECT_EQ(EVENT_HANDLER_ERR_RUNNER_ALREADY, runResult);
1234 };
1235 handler->PostTask(mainTask, delayTime);
1236 std::thread newThread(f);
1237 newThread.detach();
1238 runner->Run();
1239 }
1240
1241 /*
1242 * @tc.name: GetCurrentEventQueue
1243 * @tc.desc: GetCurrentEventQueue success and then process IsQueueEmpty success
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(EmsEventRunnerSystemTest, GetCurrentEventQueue001, TestSize.Level1)
1247 {
1248 auto runner = EventRunner::Create(false);
1249 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73102() 1250 auto task = []() {
1251 bool ret = EventRunner::GetCurrentEventQueue()->IsQueueEmpty();
1252 EXPECT_TRUE(ret);
1253 };
1254 handler->PostTask(task);
1255 }
1256
1257 /*
1258 * @tc.name: GetCurrentEventQueue002
1259 * @tc.desc: GetCurrentEventQueue success and then process IsQueueEmpty success
1260 * @tc.type: FUNC
1261 */
1262 HWTEST_F(EmsEventRunnerSystemTest, GetCurrentEventQueue002, TestSize.Level1)
1263 {
1264 auto runner = EventRunner::Create(true);
1265 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73202() 1266 auto task = []() {
1267 bool ret = EventRunner::GetCurrentEventQueue()->IsQueueEmpty();
1268 EXPECT_TRUE(ret);
1269 };
1270 handler->PostTask(task);
1271 }
1272
1273 /*
1274 * @tc.name: GetCurrentEventQueue003
1275 * @tc.desc: GetCurrentEventQueue success and then process IsQueueEmpty success
1276 * @tc.type: FUNC
1277 */
1278 HWTEST_F(EmsEventRunnerSystemTest, GetCurrentEventQueue003, TestSize.Level1)
1279 {
1280 auto runner = EventRunner::Create(true);
1281 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73302() 1282 auto task = []() {
1283 bool ret = EventRunner::GetCurrentEventQueue()->IsQueueEmpty();
1284 EXPECT_TRUE(ret);
1285 };
1286 handler->PostTask(task);
1287 }
1288
1289 /*
1290 * @tc.name: GetCurrentEventQueue004
1291 * @tc.desc: GetCurrentEventQueue success and then process IsQueueEmpty success
1292 * @tc.type: FUNC
1293 */
1294 HWTEST_F(EmsEventRunnerSystemTest, GetCurrentEventQueue004, TestSize.Level1)
1295 {
1296 auto runner = EventRunner::Create(true);
1297 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73402() 1298 auto task = []() {
1299 bool ret = EventRunner::GetCurrentEventQueue()->IsIdle();
1300 EXPECT_TRUE(ret);
1301 };
1302 handler->PostTask(task);
1303 }
1304
1305 /*
1306 * @tc.name: GetCurrentEventQueue005
1307 * @tc.desc: GetCurrentEventQueue success and then process IsQueueEmpty success
1308 * @tc.type: FUNC
1309 */
1310 HWTEST_F(EmsEventRunnerSystemTest, GetCurrentEventQueue005, TestSize.Level1)
1311 {
1312 auto runner = EventRunner::Create(true);
1313 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73502() 1314 auto task = []() {
1315 bool ret = EventRunner::GetCurrentEventQueue()->HasInnerEvent(nullptr, EVENT_ID_1);
1316 EXPECT_FALSE(ret);
1317 };
1318 handler->PostTask(task);
1319 }
1320
1321 /*
1322 * @tc.name: GetEventQueue
1323 * @tc.desc: GetEventQueue success and then process IsQueueEmpty success
1324 * @tc.type: FUNC
1325 */
1326 HWTEST_F(EmsEventRunnerSystemTest, GetEventQueue001, TestSize.Level1)
1327 {
1328 auto runner = EventRunner::Create(true);
1329 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1330 EXPECT_TRUE(ret);
1331 }
1332
1333 /*
1334 * @tc.name: GetEventQueue
1335 * @tc.desc: GetEventQueue success and then check when queue is not empty has low event IsQueueEmpty return false
1336 * @tc.type: FUNC
1337 */
1338 HWTEST_F(EmsEventRunnerSystemTest, GetEventQueue002, TestSize.Level1)
1339 {
1340 auto runner = EventRunner::Create(true);
1341 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73602() 1342 auto task = []() { ; };
1343 auto event = InnerEvent::Get(task);
1344
1345 handler->SendEvent(event, DELAY_TIME, EventQueue::Priority::LOW);
1346 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1347 EXPECT_FALSE(ret);
1348 }
1349
1350 /*
1351 * @tc.name: GetEventQueue003
1352 * @tc.desc: GetEventQueue success and then check when queue is not empty has idle event IsQueueEmpty return false
1353 * @tc.type: FUNC
1354 */
1355 HWTEST_F(EmsEventRunnerSystemTest, GetEventQueue003, TestSize.Level1)
1356 {
1357 auto runner = EventRunner::Create(true);
1358 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73702() 1359 auto task = []() { ; };
1360 auto event = InnerEvent::Get(task);
1361
1362 handler->SendEvent(event, DELAY_TIME, EventQueue::Priority::IDLE);
1363 bool ret = runner->GetEventQueue()->IsQueueEmpty();
1364 EXPECT_FALSE(ret);
1365 }
1366
1367 /*
1368 * @tc.name: GetEventQueue
1369 * @tc.desc: GetEventQueue success and then process IsIdle success
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(EmsEventRunnerSystemTest, GetEventQueue004, TestSize.Level1)
1373 {
1374 auto runner = EventRunner::Create(THREAD_NAME_TEST1);
1375 auto handler = std::make_shared<EventHandler>(runner);
1376 bool ret = runner->GetEventQueue()->IsIdle();
1377 EXPECT_TRUE(ret);
1378 }
1379
1380 /*
1381 * @tc.name: Current001
1382 * @tc.desc: start a runner, use Current() to get the running runner then compare
1383 * @tc.type: FUNC
1384 */
1385 HWTEST_F(EmsEventRunnerSystemTest, Current001, TestSize.Level1)
1386 {
1387 auto runner = EventRunner::Create(false);
1388 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73802() 1389 auto f = [&runner]() {
1390 auto currentRunner = EventRunner::Current();
1391 if (currentRunner != nullptr) {
1392 EXPECT_EQ(currentRunner, runner);
1393 runner->Stop();
1394 }
1395 };
1396 handler->PostTask(f);
1397 runner->Run();
1398 usleep(100 * 1000);
1399 }
1400
1401 /*
1402 * @tc.name: Current002
1403 * @tc.desc: start a runner, use Current() to get the running runner then compare
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(EmsEventRunnerSystemTest, Current002, TestSize.Level1)
1407 {
1408 auto runner = EventRunner::Create();
1409 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73902() 1410 auto f = [&runner]() {
1411 auto currentRunner = EventRunner::Current();
1412 if (currentRunner != nullptr) {
1413 EXPECT_EQ(currentRunner, runner);
1414 currentRunner->Stop();
1415 }
1416 };
1417 handler->PostTask(f);
1418 runner->Run();
1419 usleep(100 * 1000);
1420 }
1421
1422 /*
1423 * @tc.name: Current003
1424 * @tc.desc: start a runner, use Current() to get the running runner then compare
1425 * @tc.type: FUNC
1426 */
1427 HWTEST_F(EmsEventRunnerSystemTest, Current003, TestSize.Level1)
1428 {
1429 auto runner = EventRunner::Create(true);
1430 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73a02() 1431 auto f = [&runner]() {
1432 auto currentRunner = EventRunner::Current();
1433 if (currentRunner != nullptr) {
1434 EXPECT_EQ(currentRunner, runner);
1435 currentRunner->Stop();
1436 }
1437 };
1438 handler->PostTask(f);
1439 runner->Run();
1440 usleep(100 * 1000);
1441 }
1442
1443 /*
1444 * @tc.name: Current004
1445 * @tc.desc: start a runner, use Current() to get the running runner then compare
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(EmsEventRunnerSystemTest, Current004, TestSize.Level1)
1449 {
1450 auto runner = EventRunner::Create(THREAD_NAME_TEST1);
1451 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73b02() 1452 auto f = [&runner]() {
1453 auto currentRunner = EventRunner::Current();
1454 if (currentRunner != nullptr) {
1455 EXPECT_EQ(currentRunner, runner);
1456 currentRunner->Stop();
1457 }
1458 };
1459 handler->PostTask(f);
1460 runner->Run();
1461 usleep(100 * 1000);
1462 }
1463
1464 /*
1465 * @tc.name: Current005
1466 * @tc.desc: start a runner, use Current() to get the running runner then compare
1467 * @tc.type: FUNC
1468 */
1469 HWTEST_F(EmsEventRunnerSystemTest, Current005, TestSize.Level1)
1470 {
1471 auto runner = EventRunner::Create(THREAD_NAME_TEST2);
1472 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73c02() 1473 auto f = [&runner]() {
1474 auto currentRunner = EventRunner::Current();
1475 if (currentRunner != nullptr) {
1476 EXPECT_EQ(currentRunner, runner);
1477 currentRunner->Stop();
1478 }
1479 };
1480 handler->PostTask(f);
1481 runner->Run();
1482 usleep(100 * 1000);
1483 }
1484
1485 /*
1486 * @tc.name: IsCurrentRunnerThread001
1487 * @tc.desc: start a runner, use Current() to get the running runner then compare IsCurrentRunnerThread
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(EmsEventRunnerSystemTest, IsCurrentRunnerThread001, TestSize.Level1)
1491 {
1492 auto runner = EventRunner::Create(false);
1493 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73d02() 1494 auto f = [&runner]() {
1495 auto currentRunner = EventRunner::Current();
1496 if (currentRunner != nullptr) {
1497 bool result = currentRunner->IsCurrentRunnerThread();
1498 EXPECT_TRUE(result);
1499 currentRunner->Stop();
1500 }
1501 };
1502 handler->PostTask(f);
1503 runner->Run();
1504 usleep(100 * 1000);
1505 }
1506
1507 /*
1508 * @tc.name: IsCurrentRunnerThread002
1509 * @tc.desc: start a runner, use Current() to get the running runner then compare IsCurrentRunnerThread
1510 * @tc.type: FUNC
1511 */
1512 HWTEST_F(EmsEventRunnerSystemTest, IsCurrentRunnerThread002, TestSize.Level1)
1513 {
1514 auto runner = EventRunner::Create();
1515 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73e02() 1516 auto f = [&runner]() {
1517 auto currentRunner = EventRunner::Current();
1518 if (currentRunner != nullptr) {
1519 bool result = currentRunner->IsCurrentRunnerThread();
1520 EXPECT_TRUE(result);
1521 currentRunner->Stop();
1522 }
1523 };
1524 handler->PostTask(f);
1525 runner->Run();
1526 usleep(100 * 1000);
1527 }
1528
1529 /*
1530 * @tc.name: IsCurrentRunnerThread003
1531 * @tc.desc: start a runner, use Current() to get the running runner then compare IsCurrentRunnerThread
1532 * @tc.type: FUNC
1533 */
1534 HWTEST_F(EmsEventRunnerSystemTest, IsCurrentRunnerThread003, TestSize.Level1)
1535 {
1536 auto runner = EventRunner::Create(true);
1537 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f73f02() 1538 auto f = [&runner]() {
1539 auto currentRunner = EventRunner::Current();
1540 if (currentRunner != nullptr) {
1541 bool result = currentRunner->IsCurrentRunnerThread();
1542 EXPECT_TRUE(result);
1543 currentRunner->Stop();
1544 }
1545 };
1546 handler->PostTask(f);
1547 runner->Run();
1548 usleep(100 * 1000);
1549 }
1550
1551 /*
1552 * @tc.name: IsCurrentRunnerThread004
1553 * @tc.desc: start a runner, use Current() to get the running runner then compare IsCurrentRunnerThread
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(EmsEventRunnerSystemTest, IsCurrentRunnerThread004, TestSize.Level1)
1557 {
1558 auto runner = EventRunner::Create(THREAD_NAME_TEST1);
1559 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f74002() 1560 auto f = [&runner]() {
1561 auto currentRunner = EventRunner::Current();
1562 if (currentRunner != nullptr) {
1563 bool result = currentRunner->IsCurrentRunnerThread();
1564 EXPECT_TRUE(result);
1565 currentRunner->Stop();
1566 }
1567 };
1568 handler->PostTask(f);
1569 runner->Run();
1570 usleep(100 * 1000);
1571 }
1572
1573 /*
1574 * @tc.name: IsCurrentRunnerThread005
1575 * @tc.desc: start a runner, use Current() to get the running runner then compare IsCurrentRunnerThread
1576 * @tc.type: FUNC
1577 */
1578 HWTEST_F(EmsEventRunnerSystemTest, IsCurrentRunnerThread005, TestSize.Level1)
1579 {
1580 auto runner = EventRunner::Create(THREAD_NAME_TEST2);
1581 auto handler = std::make_shared<EventHandler>(runner);
__anon38b2a1f74102() 1582 auto f = [&runner]() {
1583 auto currentRunner = EventRunner::Current();
1584 if (currentRunner != nullptr) {
1585 bool result = currentRunner->IsCurrentRunnerThread();
1586 EXPECT_TRUE(result);
1587 currentRunner->Stop();
1588 }
1589 };
1590 handler->PostTask(f);
1591 runner->Run();
1592 usleep(100 * 1000);
1593 }
1594
1595 /*
1596 * @tc.name: GetThreadId001
1597 * @tc.desc: start a runner, use Current() to get the running runner then compare GetThreadId is equal
1598 * @tc.type: FUNC
1599 */
1600 HWTEST_F(EmsEventRunnerSystemTest, GetThreadId001, TestSize.Level1)
1601 {
1602 auto runner = EventRunner::Create(THREAD_NAME_TEST5);
1603 runner->Run();
1604 usleep(100 * 1000);
1605 uint64_t id1 = runner->GetThreadId();
1606 auto handler = std::make_shared<EventHandler>(runner);
1607
__anon38b2a1f74202() 1608 auto f = [&]() {
1609 auto currentRunner = EventRunner::Current();
1610 if (currentRunner != nullptr && id1 != 0) {
1611 uint64_t id2 = currentRunner->GetThreadId();
1612 EXPECT_EQ(id1, id2);
1613 currentRunner->Stop();
1614 }
1615 };
1616 handler->PostTask(f);
1617 usleep(100 * 1000);
1618 }
1619
1620 /*
1621 * @tc.name: GetThreadId002
1622 * @tc.desc: start a runner, use Current() to get the running runner then compare GetThreadId is equal
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(EmsEventRunnerSystemTest, GetThreadId002, TestSize.Level1)
1626 {
1627 auto runner = EventRunner::Create();
1628 runner->Run();
1629 usleep(100 * 1000);
1630 uint64_t id1 = runner->GetThreadId();
1631 auto handler = std::make_shared<EventHandler>(runner);
1632
__anon38b2a1f74302() 1633 auto f = [&]() {
1634 auto currentRunner = EventRunner::Current();
1635 if (currentRunner != nullptr && id1 != 0) {
1636 uint64_t id2 = currentRunner->GetThreadId();
1637 EXPECT_EQ(id1, id2);
1638 currentRunner->Stop();
1639 }
1640 };
1641 handler->PostTask(f);
1642 usleep(100 * 1000);
1643 }
1644
1645 /*
1646 * @tc.name: IsCurrentRunnerThread003
1647 * @tc.desc: start a runner, use Current() to get the running runner then compare GetThreadId is equal
1648 * @tc.type: FUNC
1649 */
1650 HWTEST_F(EmsEventRunnerSystemTest, GetThreadId003, TestSize.Level1)
1651 {
1652 auto runner = EventRunner::Create(true);
1653 runner->Run();
1654 usleep(100 * 1000);
1655 uint64_t id1 = runner->GetThreadId();
1656 auto handler = std::make_shared<EventHandler>(runner);
1657
__anon38b2a1f74402() 1658 auto f = [&]() {
1659 auto currentRunner = EventRunner::Current();
1660 if (currentRunner != nullptr && id1 != 0) {
1661 uint64_t id2 = currentRunner->GetThreadId();
1662 EXPECT_EQ(id1, id2);
1663 currentRunner->Stop();
1664 }
1665 };
1666 handler->PostTask(f);
1667 usleep(100 * 1000);
1668 }
1669
1670 /*
1671 * @tc.name: GetThreadId004
1672 * @tc.desc: start a runner, use Current() to get the running runner then compare GetThreadId is equal
1673 * @tc.type: FUNC
1674 */
1675 HWTEST_F(EmsEventRunnerSystemTest, GetThreadId004, TestSize.Level1)
1676 {
1677 auto runner = EventRunner::Create(THREAD_NAME_TEST1);
1678 runner->Run();
1679 usleep(100 * 1000);
1680 uint64_t id1 = runner->GetThreadId();
1681 auto handler = std::make_shared<EventHandler>(runner);
1682
__anon38b2a1f74502() 1683 auto f = [&]() {
1684 auto currentRunner = EventRunner::Current();
1685 if (currentRunner != nullptr && id1 != 0) {
1686 uint64_t id2 = currentRunner->GetThreadId();
1687 EXPECT_EQ(id1, id2);
1688 currentRunner->Stop();
1689 }
1690 };
1691 handler->PostTask(f);
1692 usleep(100 * 1000);
1693 }
1694
1695 /*
1696 * @tc.name: GetThreadId005
1697 * @tc.desc: start a runner, use Current() to get the running runner then compare GetThreadId is equal
1698 * @tc.type: FUNC
1699 */
1700 HWTEST_F(EmsEventRunnerSystemTest, GetThreadId005, TestSize.Level1)
1701 {
1702 auto runner = EventRunner::Create(THREAD_NAME_TEST2);
1703 runner->Run();
1704 usleep(100 * 1000);
1705 uint64_t id1 = runner->GetThreadId();
1706 auto handler = std::make_shared<EventHandler>(runner);
1707
__anon38b2a1f74602() 1708 auto f = [&]() {
1709 auto currentRunner = EventRunner::Current();
1710 if (currentRunner != nullptr && id1 != 0) {
1711 uint64_t id2 = currentRunner->GetThreadId();
1712 EXPECT_EQ(id1, id2);
1713 currentRunner->Stop();
1714 }
1715 };
1716 handler->PostTask(f);
1717 usleep(100 * 1000);
1718 }
1719
1720 /*
1721 * @tc.name: GetMainEventRunner001
1722 * @tc.desc: check GetMainEventRunner001 success
1723 * @tc.type: FUNC
1724 */
1725 HWTEST_F(EmsEventRunnerSystemTest, GetMainEventRunner001, TestSize.Level1)
1726 {
1727 std::shared_ptr<EventHandler> handler = std::make_shared<EventHandler>(EventRunner::GetMainEventRunner());
1728 std::shared_ptr<LoggerTest001> logtest = std::make_shared<LoggerTest001>();
1729 EventRunner::GetMainEventRunner()->SetLogger(logtest);
__anon38b2a1f74702() 1730 auto task = []() { EventRunner::GetMainEventRunner()->Stop(); };
1731 handler->PostTask(task);
1732 EventRunner::GetMainEventRunner()->Run();
1733 EXPECT_TRUE(g_isSetLogger);
1734 }
1735
1736 /*
1737 * @tc.name: GetMainEventRunner002
1738 * @tc.desc: check GetMainEventRunner002 success
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(EmsEventRunnerSystemTest, GetMainEventRunner002, TestSize.Level1)
1742 {
1743 std::shared_ptr<EventHandler> handler = std::make_shared<EventHandler>(EventRunner::GetMainEventRunner());
1744 std::shared_ptr<LoggerTest002> logtest = std::make_shared<LoggerTest002>();
1745 EventRunner::GetMainEventRunner()->SetLogger(logtest);
__anon38b2a1f74802() 1746 auto task = []() { EventRunner::GetMainEventRunner()->Stop(); };
1747 handler->PostTask(task);
1748 EventRunner::GetMainEventRunner()->Run();
1749 EXPECT_TRUE(g_isSetLogger);
1750 }
1751
1752 /*
1753 * @tc.name: GetMainEventRunner003
1754 * @tc.desc: check GetMainEventRunner003 success
1755 * @tc.type: FUNC
1756 */
1757 HWTEST_F(EmsEventRunnerSystemTest, GetMainEventRunner003, TestSize.Level1)
1758 {
1759 std::shared_ptr<EventHandler> handler = std::make_shared<EventHandler>(EventRunner::GetMainEventRunner());
1760 std::shared_ptr<LoggerTest003> logtest = std::make_shared<LoggerTest003>();
1761 EventRunner::GetMainEventRunner()->SetLogger(logtest);
__anon38b2a1f74902() 1762 auto task = []() { EventRunner::GetMainEventRunner()->Stop(); };
1763 handler->PostTask(task);
1764 EventRunner::GetMainEventRunner()->Run();
1765 EXPECT_TRUE(g_isSetLogger);
1766 }
1767
1768 /*
1769 * @tc.name: GetMainEventRunner004
1770 * @tc.desc: check GetMainEventRunner004 success
1771 * @tc.type: FUNC
1772 */
1773 HWTEST_F(EmsEventRunnerSystemTest, GetMainEventRunner004, TestSize.Level1)
1774 {
1775 std::shared_ptr<EventHandler> handler = std::make_shared<EventHandler>(EventRunner::GetMainEventRunner());
1776 std::shared_ptr<LoggerTest004> logtest = std::make_shared<LoggerTest004>();
1777 EventRunner::GetMainEventRunner()->SetLogger(logtest);
__anon38b2a1f74a02() 1778 auto task = []() { EventRunner::GetMainEventRunner()->Stop(); };
1779 handler->PostTask(task);
1780 EventRunner::GetMainEventRunner()->Run();
1781 EXPECT_TRUE(g_isSetLogger);
1782 }
1783
1784 /*
1785 * @tc.name: GetMainEventRunner001
1786 * @tc.desc: check GetMainEventRunner001 success
1787 * @tc.type: FUNC
1788 */
1789 HWTEST_F(EmsEventRunnerSystemTest, GetMainEventRunner005, TestSize.Level1)
1790 {
1791 std::shared_ptr<EventHandler> handler = std::make_shared<EventHandler>(EventRunner::GetMainEventRunner());
1792 std::shared_ptr<LoggerTest005> logtest = std::make_shared<LoggerTest005>();
1793 EventRunner::GetMainEventRunner()->SetLogger(logtest);
__anon38b2a1f74b02() 1794 auto task = []() { EventRunner::GetMainEventRunner()->Stop(); };
1795 handler->PostTask(task);
1796 EventRunner::GetMainEventRunner()->Run();
1797 EXPECT_TRUE(g_isSetLogger);
1798 }
1799