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 <gtest/gtest.h>
17 #include <cstdlib>
18 #include <mutex>
19 #include <cmath>
20 #include <chrono>
21 #include <thread>
22 #include <fstream>
23 #include <random>
24 #include <algorithm>
25 #include <cinttypes>
26 #include "util.h"
27 #include "ffrt_inner.h"
28 #include "c/ffrt_ipc.h"
29 #include "eu/co_routine.h"
30 #include "sync/io_poller.h"
31 #define private public
32 #define protect public
33 #include "util/ffrt_facade.h"
34 #undef private
35 #undef protect
36 #include "../common.h"
37
38 using namespace std;
39 using namespace testing;
40 #ifdef HWTEST_TESTING_EXT_ENABLE
41 using namespace testing::ext;
42 #endif
43 #ifdef APP_USE_ARM
44 #define SIZEOF_BYTES sizeof(uint32_t)
45 #else
46 #define SIZEOF_BYTES sizeof(uint64_t)
47 #endif
48
49 class ffrtIoTest : public testing::Test {
50 protected:
SetUpTestCase()51 static void SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 static void TearDownTestCase()
56 {
57 }
58
SetUp()59 void SetUp() override
60 {
61 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
62 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
63 }
64
TearDown()65 void TearDown() override
66 {
67 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
68 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerHandle_ = -1;
69 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerMutex_.lock();
70 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerMap_.clear();
71 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerMutex_.unlock();
72 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).executedHandle_.clear();
73 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
74 }
75 };
76
77 HWTEST_F(ffrtIoTest, IoPoller_1Producer_1Consumer, TestSize.Level1)
78 {
79 uint64_t expected = 0xabacadae;
80 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
__anon920467c80102() 81 ffrt::submit([&]() {
82 ffrt::sync_io(testFd);
83 uint64_t value = 0;
84 ssize_t n = read(testFd, &value, sizeof(uint64_t));
85 EXPECT_EQ(n, sizeof(value));
86 EXPECT_EQ(value, expected);
87 close(testFd);
88 }, {}, {});
__anon920467c80402() 89 ffrt::submit([&]() {
90 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
91 EXPECT_EQ(n, sizeof(uint64_t));
92 }, {}, {});
93
94 ffrt::wait();
95 }
96
97 HWTEST_F(ffrtIoTest, IoPoller_1Consumer_1Producer, TestSize.Level1)
98 {
99 uint64_t expected = 0xabacadae;
100 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
__anon920467c80702() 101 ffrt::submit([&]() {
102 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
103 EXPECT_EQ(n, sizeof(uint64_t));
104 }, {}, {});
105
106 stall_us(3);
107
__anon920467c80a02() 108 ffrt::submit([&]() {
109 ffrt::sync_io(testFd);
110 uint64_t value = 0;
111 ssize_t n = read(testFd, &value, sizeof(uint64_t));
112 EXPECT_EQ(n, sizeof(value));
113 EXPECT_EQ(value, expected);
114 close(testFd);
115 }, {}, {});
116
117 ffrt::wait();
118 }
119
120 uint64_t g_Ev = 0;
121
122 HWTEST_F(ffrtIoTest, IoPoller_Producer_N_Consumer_N, TestSize.Level1)
123 {
124 int count = 3;
125 uint64_t ev = 0xabacadae;
126 int testFd[count];
127 uint64_t evN = 0;
128 uint64_t i;
129 for (i = 0; i < count; i++) {
130 testFd[i] = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
131 if (testFd[i] < 0) {
132 break;
133 }
134 evN++;
135 g_Ev = evN;
136 int fd = testFd[i];
__anon920467c80d02() 137 ffrt::submit([fd, i]() {
138 ffrt::sync_io(fd);
139 uint64_t value = 0;
140 ssize_t n = read(fd, &value, sizeof(uint64_t));
141 EXPECT_EQ(n, sizeof(value));
142 close(fd);
143 }, {}, {});
144 }
145
146 for (i = 0; i < evN; i++) {
__anon920467c81002() 147 ffrt::submit([&, i]() {
148 uint64_t expected = ev + i;
149 ssize_t n = write(testFd[i], &expected, sizeof(uint64_t));
150 EXPECT_EQ(n, sizeof(uint64_t));
151 }, {}, {});
152 }
153 printf("max eventfd:%" PRIu64 ".\n", evN);
154 ffrt::wait();
155 }
156
157 struct TestData {
158 int fd;
159 uint64_t expected;
160 };
161
testCallBack(void * token,uint32_t event)162 static void testCallBack(void* token, uint32_t event)
163 {
164 struct TestData* testData = reinterpret_cast<TestData*>(token);
165 uint64_t value = 0;
166 ssize_t n = read(testData->fd, &value, sizeof(uint64_t));
167 EXPECT_EQ(n, sizeof(value));
168 EXPECT_EQ(value, testData->expected);
169 printf("cb done\n");
170 }
171
testfun(void * data)172 static void testfun(void* data)
173 {
174 *(int*)data += 1;
175 printf("%d, timeout callback\n", *(int*)data);
176 }
177 void (*cb)(void*) = testfun;
178
testSleepFun(void * data)179 static void testSleepFun(void* data)
180 {
181 usleep(100000);
182 *(int*)data += 1;
183 printf("%d, timeout callback\n", *(int*)data);
184 }
185 void (*sleepCb)(void*) = testSleepFun;
186
187 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_map_null, TestSize.Level1)
188 {
189 uint64_t timeout = 20;
190 int x = 0;
191 int* xf = &x;
192 void* data = xf;
193 uint64_t expected = 0xabacadae;
194 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
195 EXPECT_EQ(0, ffrt_timer_start(ffrt_qos_default, timeout, data, cb, false));
196
197 struct TestData testData {.fd = testFd, .expected = expected};
198 ffrt_epoll_ctl(ffrt_qos_default, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
199
200 usleep(30000);
__anon920467c81302() 201 ffrt::submit([&]() {
202 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
203 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
204 }, {}, {});
205 ffrt_epoll_ctl(ffrt_qos_default, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
206 ffrt::wait();
207 EXPECT_EQ(1, x);
208 close(testFd);
209 }
210
211 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_cb_null, TestSize.Level1)
212 {
213 uint64_t timeout = 20;
214 void* data = nullptr;
215 void (*timeoutNullCb)(void*) = nullptr;
216
217 EXPECT_EQ(-1, ffrt_timer_start(ffrt_qos_default, timeout, data, timeoutNullCb, false));
218 }
219
220 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_flag_teardown, TestSize.Level1)
221 {
222 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
223 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
224 uint64_t timeout = 20;
225 void* data = nullptr;
226
227 EXPECT_EQ(-1, ffrt_timer_start(qos, timeout, data, cb, false));
228 }
229
230 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_short_timeout_flagwait, TestSize.Level1)
231 {
232 int x = 0;
233 int* xf = &x;
234 void* data = xf;
235 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
236 uint64_t timeout1 = 200;
237 uint64_t timeout2 = 10;
238 uint64_t expected = 0xabacadae;
239 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
240 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
241 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
242
243 EXPECT_EQ(1, ffrt_timer_start(qos, timeout2, data, cb, false));
244 struct TestData testData {.fd = testFd, .expected = expected};
245 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
246
247 usleep(15000);
__anon920467c81602() 248 ffrt::submit([&]() {
249 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
250 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
251 }, {}, {});
252 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
253 ffrt::wait();
254 EXPECT_EQ(1, x);
255 close(testFd);
256 }
257
258 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_long_timeout_flagwake, TestSize.Level1)
259 {
260 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
261 int x = 0;
262 int* xf = &x;
263 void* data = xf;
264 uint64_t timeout1 = 10;
265 uint64_t timeout2 = 200;
266 uint64_t expected = 0xabacadae;
267 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
268
269 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
270 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
271 EXPECT_EQ(1, ffrt_timer_start(qos, timeout2, data, cb, false));
272 struct TestData testData {.fd = testFd, .expected = expected};
273 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
274
275 usleep(15000);
__anon920467c81902() 276 ffrt::submit([&]() {
277 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
278 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
279 }, {}, {});
280 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
281 ffrt::wait();
282 EXPECT_EQ(1, x);
283 close(testFd);
284 }
285
286 HWTEST_F(ffrtIoTest, ffrt_timer_stop_fail, TestSize.Level1)
287 {
288 int handle = -1;
289 auto ret = ffrt_timer_stop(ffrt_qos_default, handle);
290 EXPECT_EQ(ret, -1);
291 }
292
293 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwait, TestSize.Level1)
294 {
295 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
296 int x = 0;
297 int* xf = &x;
298 void* data = xf;
299 uint64_t timeout1 = 20;
300 uint64_t timeout2 = 10;
301 uint64_t expected = 0xabacadae;
302 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
303
304 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
305
306 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
307 EXPECT_EQ(1, handle);
308 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
309 ffrt_timer_stop(qos, handle);
310 struct TestData testData {.fd = testFd, .expected = expected};
311 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
312
313 usleep(15000);
__anon920467c81c02() 314 ffrt::submit([&]() {
315 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
316 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
317 }, {}, {});
318 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
319 ffrt::wait();
320 close(testFd);
321 }
322
323 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapother, TestSize.Level1)
324 {
325 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
326 int x = 0;
327 int* xf = &x;
328 void* data = xf;
329 uint64_t timeout1 = 10;
330 uint64_t timeout2 = 20;
331 uint64_t expected = 0xabacadae;
332 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
333
334 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
335 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
336 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
337 EXPECT_EQ(1, handle);
338 ffrt_timer_stop(qos, handle);
339 struct TestData testData {.fd = testFd, .expected = expected};
340 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
341
342 usleep(15000);
__anon920467c81f02() 343 ffrt::submit([&]() {
344 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
345 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
346 }, {}, {});
347 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
348 ffrt::wait();
349 close(testFd);
350 }
351
352 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwake, TestSize.Level1)
353 {
354 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
355 int x = 0;
356 int* xf = &x;
357 void* data = xf;
358 uint64_t timeout1 = 10;
359 uint64_t timeout2 = 20;
360 uint64_t expected = 0xabacadae;
361 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
362
363 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
364 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
365 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
366 EXPECT_EQ(1, handle);
367 ffrt_timer_stop(qos, handle);
368 struct TestData testData {.fd = testFd, .expected = expected};
369 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
370
371 usleep(15000);
372
__anon920467c82202() 373 ffrt::submit([&]() {
374 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
375 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
376 }, {}, {});
377 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
378 ffrt::wait();
379 close(testFd);
380 }
381
382 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_flag_teardown, TestSize.Level1)
383 {
384 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
385 int x = 0;
386 int* xf = &x;
387 void* data = xf;
388 uint64_t timeout2 = 20;
389 uint64_t expected = 0xabacadae;
390 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
391
392 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
393 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
394 EXPECT_EQ(-1, handle);
395 ffrt_timer_stop(qos, handle);
396 struct TestData testData {.fd = testFd, .expected = expected};
397 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
398
399 usleep(21000);
400
__anon920467c82502() 401 ffrt::submit([&]() {
402 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
403 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
404 }, {}, {});
405 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
406 ffrt::wait();
407 close(testFd);
408 }
409
410 HWTEST_F(ffrtIoTest, ffrt_timer_query_test, TestSize.Level1)
411 {
412 int x = 0;
413 int* xf = &x;
414 void* data = xf;
415 uint64_t timeout1 = 10;
416 uint64_t timeout2 = 20;
417 uint64_t expected = 0xabacadae;
418 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
419
420 ffrt_qos_t qos = ffrt_qos_default;
421 int handle = ffrt_timer_start(qos, timeout1, data, cb, false);
422 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
423
424 struct TestData testData {.fd = testFd, .expected = expected};
425 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
426
427 usleep(15000);
428
__anon920467c82802() 429 ffrt::submit([&]() {
430 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
431 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
432 }, {}, {});
433 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
434 ffrt::wait();
435 close(testFd);
436 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
437 }
438
439 HWTEST_F(ffrtIoTest, ffrt_timer_query_stop, TestSize.Level1)
440 {
441 int x = 0;
442 int* xf = &x;
443 void* data = xf;
444 uint64_t timeout1 = 10;
445 uint64_t timeout2 = 20;
446 uint64_t expected = 0xabacadae;
447 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
448
449 ffrt_qos_t qos = ffrt_qos_default;
450 int handle = ffrt_timer_start(qos, timeout1, data, sleepCb, false);
451 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
452 usleep(500000);
453 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
454
455 ffrt_timer_stop(qos, handle);
456 struct TestData testData {.fd = testFd, .expected = expected};
457 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
458
459 usleep(15000);
460
__anon920467c82b02() 461 ffrt::submit([&]() {
462 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
463 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
464 }, {}, {});
465 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
466 ffrt::wait();
467 EXPECT_EQ(-1, ffrt_timer_query(qos, handle));
468 close(testFd);
469 }
470
471 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_valid, TestSize.Level1)
472 {
473 uint64_t expected = 0xabacadae;
474 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
475 ffrt_qos_t qos_level = ffrt_qos_default;
476 int op = EPOLL_CTL_ADD;
477
478 struct TestData testData {.fd = testFd, .expected = expected};
479
480 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
481 EXPECT_EQ(0, ret);
482
__anon920467c82e02() 483 ffrt::submit([&]() {
484 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
485 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
486 }, {}, {});
487
488 usleep(100);
489
490 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
491 EXPECT_EQ(0, ret);
492 ffrt::wait();
493 close(testFd);
494 }
495
496 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_fd_invalid, TestSize.Level1)
497 {
498 uint64_t expected = 0xabacadae;
499 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
500 ffrt_qos_t qos_level = ffrt_qos_default;
501 int op = EPOLL_CTL_ADD;
502
503 struct TestData testData {.fd = testFd, .expected = expected};
504
505 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
506 EXPECT_EQ(0, ret);
507
__anon920467c83102() 508 ffrt::submit([&]() {
509 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
510 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
511 }, {}, {});
512
513 usleep(100);
514
515 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, -1, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
516 EXPECT_EQ(-1, ret);
517 ffrt::wait();
518 close(testFd);
519 }
520
521 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_qos_invalid, TestSize.Level1)
522 {
523 uint64_t expected = 0xabacadae;
524 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
525 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
526 int op = EPOLL_CTL_ADD;
527
528 struct TestData testData {.fd = testFd, .expected = expected};
529
530 int ret = ffrt_epoll_ctl(ffrt_qos_default, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
531 EXPECT_EQ(0, ret);
532
__anon920467c83402() 533 ffrt::submit([&]() {
534 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
535 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
536 }, {}, {});
537
538 usleep(100);
539
540 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
541 EXPECT_EQ(-1, ret);
542 ffrt::wait();
543 close(testFd);
544 }
545
546 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_true, TestSize.Level1)
547 {
548 bool isLocalSet = true;
549 ffrt_task_attr_t attr;
550 ffrt_task_attr_init(&attr);
551 ffrt_task_attr_set_local(&attr, isLocalSet);
552 bool localval = ffrt_task_attr_get_local(&attr);
553 EXPECT_EQ(localval, isLocalSet);
554 }
555
556 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_false, TestSize.Level1)
557 {
558 bool isLocalSet = false;
559 ffrt_task_attr_t attr;
560 ffrt_task_attr_init(&attr);
561 ffrt_task_attr_set_local(&attr, isLocalSet);
562 bool localval = ffrt_task_attr_get_local(&attr);
563 EXPECT_EQ(localval, isLocalSet);
564 }
565
566 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_attr_invalid, TestSize.Level1)
567 {
568 bool isLocalSet = true;
569 ffrt_task_attr_set_local(nullptr, isLocalSet);
570 EXPECT_EQ(isLocalSet, true);
571 }
572
573 struct WakeData {
574 int fd;
575 void* data;
576 };
577
578 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid, TestSize.Level1)
579 {
580 uint64_t expected = 0xabacadae;
581 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
582 struct WakeData m_wakeData;
583 m_wakeData.data = nullptr;
584 m_wakeData.fd = testFd;
585 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
586 int op = EPOLL_CTL_ADD;
587 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
588 int maxevents = 1024;
589 uint64_t timeout = 0;
590 int result = 0;
591 struct TestData testData {.fd = testFd, .expected = expected};
592
593 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
594 EXPECT_EQ(0, ret);
595
__anon920467c83702() 596 ffrt::submit([&]() {
597 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
598 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
599 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
600 }, {}, {});
601 usleep(1000);
602 EXPECT_EQ(0, result);
603 }
604
605 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_maxevents_invalid, TestSize.Level1)
606 {
607 uint64_t expected = 0xabacadae;
608 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
609
610 struct WakeData m_wakeData;
611 m_wakeData.data = nullptr;
612 m_wakeData.fd = testFd;
613 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
614 int op = EPOLL_CTL_ADD;
615 int result = 0;
616
617 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
618 int maxevents = -1;
619 uint64_t timeout = 0;
620 struct TestData testData {.fd = testFd, .expected = expected};
621
622 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
623 EXPECT_EQ(0, ret);
624
__anon920467c83a02() 625 ffrt::submit([&]() {
626 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
627 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
628 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
629 }, {}, {});
630 usleep(1000);
631 EXPECT_EQ(-1, result);
632 }
633
634 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op1, TestSize.Level1)
635 {
636 int op = EPOLL_CTL_ADD;
637 ffrt_qos_t qos = ffrt_qos_default;
638 uint64_t expected = 0xabacadae;
639 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
640 struct TestData testData {.fd = testFd, .expected = expected};
641
642 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
643 EXPECT_EQ(0, ret);
644 }
645
646 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op3, TestSize.Level1)
647 {
648 int op = EPOLL_CTL_MOD;
649 ffrt_qos_t qos = ffrt_qos_default;
650 uint64_t expected = 0xabacadae;
651 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
652 struct TestData testData {.fd = testFd, .expected = expected};
653
654 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
655 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
656 EXPECT_EQ(0, ret);
657 }
658
659 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op_invalid, TestSize.Level1)
660 {
661 int op = 0;
662 ffrt_qos_t qos = ffrt_qos_default;
663 uint64_t expected = 0xabacadae;
664 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
665 struct TestData testData {.fd = testFd, .expected = expected};
666
667 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
668 EXPECT_EQ(-1, ret);
669 }
670
671 /**
672 * @tc.name: ffrt_epoll_wait_valid_with_thread_mode
673 * @tc.desc: Test ffrt_epoll_wait when valid in Thread mode
674 * @tc.type: FUNC
675 */
676 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid_with_thread_mode, TestSize.Level1)
677 {
678 uint64_t expected = 0xabacadae;
679 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
680 struct WakeData m_wakeData;
681 m_wakeData.data = nullptr;
682 m_wakeData.fd = testFd;
683 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
684 int op = EPOLL_CTL_ADD;
685 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
686 int maxevents = 1024;
687 uint64_t timeout = 0;
688 int result = 0;
689 struct TestData testData {.fd = testFd, .expected = expected};
690
691
692 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
693 EXPECT_EQ(0, ret);
694
__anon920467c83d02() 695 ffrt::submit([&]() {
696 ffrt_this_task_set_legacy_mode(true);
697 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
698 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
699 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
700 ffrt_this_task_set_legacy_mode(false);
701 }, {}, {});
702 usleep(1000);
703 EXPECT_EQ(0, result);
704 }
705
706 HWTEST_F(ffrtIoTest, ffrt_epoll_get_count, TestSize.Level1)
707 {
708 ffrt_qos_t qos = ffrt_qos_default;
709
710 int ret = ffrt_epoll_get_count(qos);
711 EXPECT_NE(ret, 0);
712 }
713
714 HWTEST_F(ffrtIoTest, ffrt_epoll_get_wait_time_invalid, TestSize.Level1)
715 {
716 void* taskHandle = nullptr;
717
718 int ret = ffrt_epoll_get_wait_time(taskHandle);
719 EXPECT_EQ(ret, 0);
720 }