1 /*
2 * Copyright (c) 2023 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 <thread>
17 #include <chrono>
18 #include <gtest/gtest.h>
19 #include "ffrt_inner.h"
20 #include "c/loop.h"
21 #include "c/ffrt_ipc.h"
22 #define private public
23 #define protected public
24 #include "sync/poller.h"
25 #include "tm/cpu_task.h"
26 #include "tm/scpu_task.h"
27 #undef private
28 #undef protected
29 #include "util.h"
30 #include "../common.h"
31
32 using namespace std;
33 using namespace ffrt;
34 using namespace testing;
35 #ifdef HWTEST_TESTING_EXT_ENABLE
36 using namespace testing::ext;
37 #endif
38
39 class PollerTest : public testing::Test {
40 protected:
SetUpTestCase()41 static void SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 static void TearDownTestCase()
46 {
47 }
48
SetUp()49 void SetUp() override
50 {
51 }
52
TearDown()53 void TearDown() override
54 {
55 }
56 };
57
Testfun(void * data)58 static void Testfun(void* data)
59 {
60 int* testData = static_cast<int*>(data);
61 *testData += 1;
62 printf("%d, timeout callback\n", *testData);
63 }
64 static void (*g_cb)(void*) = Testfun;
65
66 /*
67 * 测试用例名称：poll_once_batch_timeout
68 * 测试用例描述：PollOnce批量超时测试
69 * 预置条件 ：无
70 * 操作步骤 ：1、调用注册接口
71 2、单次调用PollOnce
72 * 预期结果 ：1、超时任务全部从队列中清除
73 2、当实际超时时间很长，但是传入超时时间很短，应该按传入时间执行
74 */
75 HWTEST_F(PollerTest, poll_once_batch_timeout, TestSize.Level0)
76 {
77 Poller poller;
78 // 1、组装timeMap_
79 static int result0 = 0;
80 int* xf = &result0;
81 void* data = xf;
82 uint64_t timeout = 10;
83 uint64_t timeout1 = 11;
84 uint64_t timeout2 = 12;
85 uint64_t sleepTime = 25000;
86 poller.RegisterTimer(timeout, data, g_cb, false);
87 poller.RegisterTimer(timeout1, data, g_cb, false);
88 poller.RegisterTimer(timeout2, data, g_cb, false);
89 // 调用PollOnce,预计timerMap_为空，全部清除
90 usleep(sleepTime);
91 poller.PollOnce(1);
92 EXPECT_EQ(true, poller.DetermineEmptyMap());
93
94 uint64_t timeout3 = 10000;
95 uint64_t timeout4 = 100;
96 int loopNum = 2;
97 poller.RegisterTimer(timeout3, data, g_cb, false);
98 TimePoint start = std::chrono::steady_clock::now();
99 for (int i = 0; i < loopNum; ++i) {
100 poller.PollOnce(timeout4);
101 }
102 TimePoint end = std::chrono::steady_clock::now();
103 int m = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
104 // 预计等待时间为100，可能有几毫秒的误差
105 EXPECT_EQ(true, m >= timeout4 && m < timeout3);
106 }
107
108 /*
109 * 测试用例名称：poll_once_batch_timeout
110 * 测试用例描述：PollOnce批量超时测试
111 * 预置条件 ：无
112 * 操作步骤 ：1、调用注册接口,注册repeat为true的timer
113 2、创建两个线程，并发PollerOnce和Unregister
114 * 预期结果 ：1、任务全部从队列中清除
115 */
116 HWTEST_F(PollerTest, unregister_timer_001, TestSize.Level0)
117 {
118 Poller poller;
119 // 1、组装timeMap_
120 static int result0 = 0;
121 int* xf = &result0;
122 void* data = xf;
123 uint64_t timeout = 1;
124 uint64_t sleepTime = 2500;
125 int maxIter = 100;
126 // 2、 创建两个线程，并发PollerOnce和Unregister
127 for (int i = 0; i < maxIter; i++) {
128 int timerHandle = poller.RegisterTimer(timeout, data, g_cb, true);
129 EXPECT_FALSE(poller.timerMap_.empty());
130 auto boundPollonce = std::bind(&Poller::PollOnce, &poller, timeout);
131 auto boundUnregister = std::bind(&Poller::UnregisterTimer, &poller, timerHandle);
132 usleep(sleepTime);
133 std::thread thread1(boundPollonce);
134 std::thread thread2(boundUnregister);
135 thread1.join();
136 thread2.join();
137 EXPECT_TRUE(poller.timerMap_.empty());
138 EXPECT_TRUE(poller.executedHandle_.empty());
139 poller.timerMap_.clear();
140 poller.executedHandle_.clear();
141 }
142 }
143
144 std::mutex g_mutexRegister;
145 std::condition_variable g_cvRegister;
146
WaitCallback(void * data)147 void WaitCallback(void* data)
148 {
149 auto dependency = reinterpret_cast<std::atomic<int>*>(data);
150 while (*dependency != 1) {
151 std::this_thread::yield();
152 }
153 }
154
EmptyCallback(void * data)155 void EmptyCallback(void* data) {}
156
157 /*
158 * 测试用例名称：multi_timer_dependency
159 * 测试用例描述：poller批量超时回调依赖测试
160 * 预置条件 ：构造三个超时时间相同的timer，回调A依赖回调B执行完成，回调B依赖timer C取消成功，三者并发
161 * 操作步骤 ：1、调用PollOnce接口
162 * 预期结果 ：1、三个回调执行完成，没有卡死现象
163 */
164 HWTEST_F(PollerTest, multi_timer_dependency, TestSize.Level0)
165 {
166 // dependency can be accessed by multiple threads:
167 // the polling and the updating thread. Hence,
168 // it must be defined as atomic in order to
169 // prevent data-race
170 std::atomic<int> dependency = 0;
__anonbe7a08cf0102null171 ffrt::task_handle handle = ffrt::submit_h([&] {
172 std::unique_lock lk(g_mutexRegister);
173 g_cvRegister.wait(lk);
174 dependency = 1;
175 });
176
177 TimePoint timeout = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
178 TimerDataWithCb data(&dependency, WaitCallback, nullptr, false, 100);
179 data.handle = 0;
180
181 Poller poller;
182 poller.timerMap_.emplace(timeout, data);
183
184 data.handle++;
185 data.cb = EmptyCallback;
186 poller.timerMap_.emplace(timeout, data);
187
__anonbe7a08cf0202null188 std::thread th1([&] { poller.PollOnce(-1); });
__anonbe7a08cf0302null189 std::thread th2([&] {
190 usleep(100 * 1000);
191 poller.UnregisterTimer(1);
192 g_cvRegister.notify_all();
193 });
194
195 th1.join();
196 th2.join();
197 ffrt::wait({handle});
198 }
199
200 /*
201 * 测试用例名称：multi_timer_dependency_unregister_self
202 * 测试用例描述：poller批量超时回调，解注册自身依赖测试
203 * 预置条件 ：构造两个超时时间相同的timer，回调A依赖回调B执行完成，回调B依赖另一个线程的timer A取消成功，三者并发
204 * 操作步骤 ：调用PollOnce接口
205 * 预期结果 ：三个回调执行完成，没有卡死现象
206 */
207 HWTEST_F(PollerTest, multi_timer_dependency_unregister_self, TestSize.Level0)
208 {
209 // dependency can be accessed by multiple threads:
210 // the polling and the updating thread. Hence,
211 // it must be defined as atomic in order to
212 // prevent data-race
213 std::atomic<int> dependency = 0;
214
215 TimePoint timeout = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
216 TimerDataWithCb data(&dependency, WaitCallback, nullptr, false, 100);
217 data.handle = 0;
218
219 Poller poller;
220 poller.timerMap_.emplace(timeout, data);
221
222 data.handle++;
223 data.cb = EmptyCallback;
224 poller.timerMap_.emplace(timeout, data);
225
__anonbe7a08cf0402null226 ffrt::task_handle handle = ffrt::submit_h([&] {
227 std::unique_lock lk(g_mutexRegister);
228 g_cvRegister.wait(lk);
229 poller.IsTimerReady();
230 dependency = 1;
231 });
232
__anonbe7a08cf0502null233 std::thread th1([&] { poller.PollOnce(-1); });
__anonbe7a08cf0602null234 std::thread th2([&] {
235 usleep(100 * 1000);
236 g_cvRegister.notify_all();
237 poller.UnregisterTimer(0);
238 });
239
240 th1.join();
241 th2.join();
242 ffrt::wait({handle});
243 }
244
245 /*
246 * 测试用例名称 : fetch_cached_event_unmask DoTaskFdAdd
247 * 测试用例描述 : 遍历本地events缓存，并提出缓存event
248 * 预置条件 : 无
249 * 操作步骤 :
250 * 预期结果 :
251 */
252 HWTEST_F(PollerTest, TestCacheDelFd001, TestSize.Level0)
253 {
254 Poller poller;
255 CPUEUTask* currTask = static_cast<CPUEUTask*>(malloc(sizeof(CPUEUTask)));
256 int fd = 1001;
257 int fd1 = 1002;
258 poller.CacheDelFd(fd, currTask);
259 poller.CacheDelFd(fd1, currTask);
260 std::unique_ptr<struct WakeDataWithCb> maskWakeData = std::make_unique<WakeDataWithCb>(fd, nullptr,
261 nullptr, currTask);
262 std::unique_ptr<struct WakeDataWithCb> maskWakeData1 = std::make_unique<WakeDataWithCb>(fd1, nullptr,
263 nullptr, currTask);
264 poller.CacheMaskWakeData(currTask, maskWakeData);
265 poller.CacheMaskWakeData(currTask, maskWakeData1);
266
267 EXPECT_EQ(2, poller.m_delFdCacheMap.size());
268 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap.size());
269 EXPECT_EQ(2, poller.m_maskWakeDataWithCbMap[currTask].size());
270
271 poller.ClearMaskWakeDataWithCbCacheWithFd(currTask, fd);
272 EXPECT_EQ(2, poller.m_delFdCacheMap.size());
273 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap.size());
274 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap[currTask].size());
275
276 poller.ClearMaskWakeDataWithCbCacheWithFd(currTask, fd1);
277 EXPECT_EQ(2, poller.m_delFdCacheMap.size());
278 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap.size());
279 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap[currTask].size());
280
281 free(currTask);
282 }
283
284 /*
285 * 测试用例名称 : fetch_cached_event_unmask DoTaskFdAdd
286 * 测试用例描述 : 遍历本地events缓存，并提出缓存event
287 * 预置条件 : 无
288 * 操作步骤 :
289 * 预期结果 :
290 */
291 HWTEST_F(PollerTest, TestCacheDelFd002, TestSize.Level0)
292 {
293 Poller poller;
294 CPUEUTask* currTask = static_cast<CPUEUTask*>(malloc(sizeof(CPUEUTask)));
295 int fd = 1001;
296 int fd1 = 1002;
297 poller.m_delFdCacheMap.emplace(fd, currTask);
298 poller.m_delFdCacheMap.emplace(fd1, currTask);
299 std::unique_ptr<struct WakeDataWithCb> maskWakeData = std::make_unique<WakeDataWithCb>(fd, nullptr,
300 nullptr, currTask);
301 std::unique_ptr<struct WakeDataWithCb> maskWakeData1 = std::make_unique<WakeDataWithCb>(fd1, nullptr,
302 nullptr, currTask);
303 poller.m_maskWakeDataWithCbMap[currTask].emplace_back(std::move(maskWakeData));
304 poller.m_maskWakeDataWithCbMap[currTask].emplace_back(std::move(maskWakeData1));
305
306 EXPECT_EQ(2, poller.m_delFdCacheMap.size());
307 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap.size());
308 EXPECT_EQ(2, poller.m_maskWakeDataWithCbMap[currTask].size());
309
310 poller.ClearMaskWakeDataWithCbCache(currTask);
311
312 EXPECT_EQ(0, poller.m_delFdCacheMap.size());
313 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap.size());
314 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap[currTask].size());
315
316 free(currTask);
317 }
318
319 /*
320 * 测试用例名称 : fetch_cached_event_unmask DoTaskFdAdd
321 * 测试用例描述 : 遍历本地events缓存，并提出缓存event
322 * 预置条件 : 无
323 * 操作步骤 :
324 * 预期结果 :
325 */
326 HWTEST_F(PollerTest, TestCacheDelFd003, TestSize.Level0)
327 {
328 Poller poller;
329 CPUEUTask* currTask = static_cast<CPUEUTask*>(malloc(sizeof(CPUEUTask)));
330 int fd = 1001;
331 int fd1 = 1002;
332 poller.m_delFdCacheMap.emplace(fd, currTask);
333 poller.m_delFdCacheMap.emplace(fd1, currTask);
334 std::unique_ptr<struct WakeDataWithCb> maskWakeData = std::make_unique<WakeDataWithCb>(fd, nullptr,
335 nullptr, currTask);
336 std::unique_ptr<struct WakeDataWithCb> maskWakeData1 = std::make_unique<WakeDataWithCb>(fd1, nullptr,
337 nullptr, currTask);
338 poller.m_maskWakeDataWithCbMap[currTask].emplace_back(std::move(maskWakeData));
339 poller.m_maskWakeDataWithCbMap[currTask].emplace_back(std::move(maskWakeData1));
340
341 EXPECT_EQ(2, poller.m_delFdCacheMap.size());
342 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap.size());
343 EXPECT_EQ(2, poller.m_maskWakeDataWithCbMap[currTask].size());
344
345 poller.ClearDelFdCache(fd);
346 EXPECT_EQ(1, poller.m_delFdCacheMap.size());
347 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap.size());
348 EXPECT_EQ(1, poller.m_maskWakeDataWithCbMap[currTask].size());
349
350 poller.ClearDelFdCache(fd1);
351 EXPECT_EQ(0, poller.m_delFdCacheMap.size());
352 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap.size());
353 EXPECT_EQ(0, poller.m_maskWakeDataWithCbMap[currTask].size());
354
355 free(currTask);
356 }
357
358 HWTEST_F(PollerTest, GetTaskWaitTime, TestSize.Level0)
359 {
360 Poller poller;
361 SCPUEUTask task(nullptr, nullptr, 0);
362 poller.m_waitTaskMap[&task] = SyncData();
363 poller.m_waitTaskMap[&task].waitTP = std::chrono::steady_clock::now();
364 EXPECT_EQ(poller.GetTaskWaitTime(nullptr), 0);
365 EXPECT_GT(poller.GetTaskWaitTime(&task), 0);
366 }
367
368 HWTEST_F(PollerTest, WaitFdEventTest, TestSize.Level1)
369 {
370 Poller poller;
__anonbe7a08cf0702null371 std::thread th([&] { poller.PollOnce(30000); });
372
373 uint64_t expected = 0x3;
374 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
375 int op = EPOLL_CTL_ADD;
376 ffrt_qos_t qos = ffrt_qos_user_initiated;
377
__anonbe7a08cf0802() 378 ffrt::submit([&]() {
379 int ret = poller.AddFdEvent(op, EPOLLIN, testFd, nullptr, nullptr);
380 EXPECT_EQ(ret, 0);
381 // sleep to wait event
382 ffrt_usleep(50000);
383 // get fds
384 struct epoll_event events[1024];
385 int nfds = poller.WaitFdEvent(events, 1024, -1);
386 EXPECT_EQ(nfds, 1);
387 ret = poller.DelFdEvent(testFd);
388 EXPECT_EQ(ret, 0);
389 // read vaule from fd and check
390 uint64_t value = 0;
391 ssize_t n = read(testFd, &value, sizeof(uint64_t));
392 EXPECT_EQ(n, sizeof(value));
393 EXPECT_EQ(value, expected);
394 close(testFd);
395 }, {}, {}, ffrt::task_attr().qos(ffrt_qos_user_initiated));
396
397 stall_us(200);
398 uint64_t u1 = 1;
399 ssize_t n = write(testFd, &u1, sizeof(uint64_t));
400 uint64_t u2 = 2;
401 n = write(testFd, &u2, sizeof(uint64_t));
402 EXPECT_EQ(n, sizeof(uint64_t));
403 ffrt::wait();
404 th.detach();
405 }
406
407 HWTEST_F(PollerTest, WaitFdEventTestLegacyMode, TestSize.Level1)
408 {
409 Poller poller;
__anonbe7a08cf0b02null410 std::thread th([&] { poller.PollOnce(30000); });
411
412 uint64_t expected = 0x3;
413 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
414 int op = EPOLL_CTL_ADD;
415 ffrt_qos_t qos = ffrt_qos_user_initiated;
416
__anonbe7a08cf0c02() 417 ffrt::submit([&]() {
418 ffrt_this_task_set_legacy_mode(true);
419 int ret = poller.AddFdEvent(op, EPOLLIN, testFd, nullptr, nullptr);
420 EXPECT_EQ(ret, 0);
421 // sleep to wait event
422 ffrt_usleep(50000);
423 // get fds
424 struct epoll_event events[1024];
425 int nfds = poller.WaitFdEvent(events, 1024, -1);
426 EXPECT_EQ(nfds, 1);
427 ret = poller.DelFdEvent(testFd);
428 EXPECT_EQ(ret, 0);
429 // read vaule from fd and check
430 uint64_t value = 0;
431 ssize_t n = read(testFd, &value, sizeof(uint64_t));
432 EXPECT_EQ(n, sizeof(value));
433 EXPECT_EQ(value, expected);
434 close(testFd);
435 ffrt_this_task_set_legacy_mode(false);
436 }, {}, {}, ffrt::task_attr().qos(ffrt_qos_user_initiated));
437
438 stall_us(200);
439 uint64_t u1 = 1;
440 ssize_t n = write(testFd, &u1, sizeof(uint64_t));
441 uint64_t u2 = 2;
442 n = write(testFd, &u2, sizeof(uint64_t));
443 EXPECT_EQ(n, sizeof(uint64_t));
444 ffrt::wait();
445 th.detach();
446 }
447
448 HWTEST_F(PollerTest, ProcessTimerDataCb, TestSize.Level1)
449 {
450 Poller poller;
451 SCPUEUTask task(nullptr, nullptr, 0);
452 task.blockType = BlockType::BLOCK_THREAD;
453 poller.m_waitTaskMap[&task] = SyncData();
454 EXPECT_EQ(poller.m_waitTaskMap.size(), 1);
455
456 poller.ProcessTimerDataCb(nullptr);
457 EXPECT_EQ(poller.m_waitTaskMap.size(), 1);
458 poller.ProcessTimerDataCb(&task);
459 EXPECT_EQ(poller.m_waitTaskMap.size(), 0);
460 }
461
462 HWTEST_F(PollerTest, WakeSyncTask, TestSize.Level1)
463 {
464 Poller poller;
465 SCPUEUTask task(nullptr, nullptr, 0);
466 task.blockType = BlockType::BLOCK_THREAD;
467 EventVec eventVec(1);
468 std::unordered_map<CoTask*, EventVec> syncTaskEvents = { { &task, eventVec } };
469
470 int nfds = 0;
471 struct epoll_event event;
472 poller.m_waitTaskMap[&task] = SyncData(nullptr, 1024, nullptr, std::chrono::steady_clock::now());
473 poller.WakeSyncTask(syncTaskEvents);
474 poller.m_waitTaskMap[&task] = SyncData(&event, 1024, nullptr, std::chrono::steady_clock::now());
475 poller.WakeSyncTask(syncTaskEvents);
476 poller.m_waitTaskMap[&task] = SyncData(&event, 1024, &nfds, std::chrono::steady_clock::now());
477 poller.m_waitTaskMap[&task].timerHandle = 0;
478 poller.m_waitTaskMap[&task] = SyncData(&event, 1024, &nfds, std::chrono::steady_clock::now());
479 poller.WakeSyncTask(syncTaskEvents);
480 EXPECT_EQ(nfds, 1);
481 }
482
483 HWTEST_F(PollerTest, ClearMaskWakeData, TestSize.Level1)
484 {
485 Poller poller;
486 SCPUEUTask task(nullptr, nullptr, 0);
487 task.blockType = BlockType::BLOCK_THREAD;
488
489 std::unique_ptr<WakeDataWithCb> wakeData = std::make_unique<WakeDataWithCb>(0, nullptr, nullptr, nullptr);
490 poller.m_maskWakeDataWithCbMap[&task].emplace_back(std::move(wakeData));
491 poller.CacheMaskFdAndEpollDel(0, nullptr);
492 poller.ClearMaskWakeDataWithCbCacheWithFd(nullptr, 0);
493 EXPECT_EQ(poller.m_delFdCacheMap.size(), 0);
494
495 poller.CacheMaskFdAndEpollDel(0, &task);
496 poller.ClearMaskWakeDataWithCbCacheWithFd(&task, 0);
497 EXPECT_EQ(poller.m_delFdCacheMap.size(), 1);
498 EXPECT_EQ(poller.m_delFdCacheMap[0], &task);
499
500 poller.ClearDelFdCache(0);
501 EXPECT_EQ(poller.m_delFdCacheMap.size(), 0);
502 }
503
504 HWTEST_F(PollerTest, ReleaseFdWakeData, TestSize.Level1)
505 {
506 Poller poller;
507 for (int i = 0; i < 3; i++) {
508 poller.m_delCntMap[i] = i;
509 std::unique_ptr<WakeDataWithCb> wakeData = std::make_unique<WakeDataWithCb>(0, nullptr, nullptr, nullptr);
510 std::unique_ptr<WakeDataWithCb> wakeData2 = std::make_unique<WakeDataWithCb>(0, nullptr, nullptr, nullptr);
511 poller.m_wakeDataMap[i].emplace_back(std::move(wakeData));
512 poller.m_wakeDataMap[i].emplace_back(std::move(wakeData2));
513 }
514
515 poller.ReleaseFdWakeData();
516 EXPECT_EQ(poller.m_delCntMap[0], 0);
517 EXPECT_EQ(poller.m_delCntMap[1], 1);
518 EXPECT_EQ(poller.m_delCntMap.size(), 2);
519 }
520
521 HWTEST_F(PollerTest, DeterminePollerReady, TestSize.Level1)
522 {
523 Poller poller;
524 EXPECT_FALSE(poller.DeterminePollerReady());
525 auto timePoint = std::chrono::steady_clock::now() + std::chrono::minutes(3);
526 poller.timerMap_.emplace(timePoint, TimerDataWithCb());
527 EXPECT_FALSE(poller.DeterminePollerReady());
528 poller.fdEmpty_ = false;
529 EXPECT_TRUE(poller.DeterminePollerReady());
530 }
531
532 HWTEST_F(PollerTest, GetTimerStatus, TestSize.Level1)
533 {
534 Poller poller;
535 TimerDataWithCb data;
536 data.handle = 1;
537 poller.timerMap_.emplace(std::chrono::steady_clock::now(), data);
538 poller.executedHandle_[2] = TimerStatus::EXECUTED;
539 EXPECT_EQ(poller.GetTimerStatus(0), ffrt_timer_notfound);
540 EXPECT_EQ(poller.GetTimerStatus(1), ffrt_timer_not_executed);
541 EXPECT_EQ(poller.GetTimerStatus(2), ffrt_timer_executed);
542
543 poller.flag_ = EpollStatus::TEARDOWN;
544 EXPECT_EQ(poller.RegisterTimer(0, nullptr, nullptr, false), -1);
545 EXPECT_EQ(poller.UnregisterTimer(0), -1);
546 EXPECT_EQ(poller.GetTimerStatus(0), ffrt_timer_notfound);
547 }
548
549 HWTEST_F(PollerTest, FetchCachedEventAndDoUnmask, TestSize.Level1)
550 {
551 Poller poller;
552 EventVec eventVec;
553 epoll_event events[1024];
554 for (int i = 0; i < 3; i++) {
555 epoll_event event;
556 event.data.fd = i / 2;
557 eventVec.push_back(event);
558 }
559 std::unique_ptr<WakeDataWithCb> wakeData = std::make_unique<WakeDataWithCb>(0, nullptr, nullptr, nullptr);
560 poller.m_wakeDataMap[0].emplace_back(std::move(wakeData));
561 poller.m_delFdCacheMap[0] = nullptr;
562 EXPECT_EQ(poller.FetchCachedEventAndDoUnmask(eventVec, events), 2);
563 }
564
565 HWTEST_F(PollerTest, DelFdEvent, TestSize.Level1)
566 {
567 Poller poller;
568 EXPECT_EQ(poller.DelFdEvent(0), -1);
569
570 std::unique_ptr<WakeDataWithCb> wakeData = std::make_unique<WakeDataWithCb>(0, nullptr, nullptr, nullptr);
571 poller.m_wakeDataMap[0].emplace_back(std::move(wakeData));
572 poller.m_delCntMap[0] = 1;
573 EXPECT_EQ(poller.DelFdEvent(0), -1);
574 CPUEUTask* currTask = static_cast<CPUEUTask*>(malloc(sizeof(CPUEUTask)));
575 poller.ClearCachedEvents(currTask);
576 }
577
578 HWTEST_F(PollerTest, Qos_Test, TestSize.Level1)
579 {
580 ffrt_qos_t qos = qos_default;
581 ffrt::QoS ffrtQos;
582 ffrt::SetFuncQosMap(nullptr);
583 ffrt_poller_wakeup(qos);
584 int ret = ffrt_epoll_get_count(qos);
585 EXPECT_EQ(ret, 0);
586 ffrt::SetFuncQosMap(ffrt::QoSMap);
587 }