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