Debian Codegraph @

tests/ut_dasync.cpp

raw
1 // SPDX-FileCopyrightText: 2021 - 2022 UnionTech Software Technology Co., Ltd.
2 //
3 // SPDX-License-Identifier: LGPL-3.0-or-later
4
5 #include <QTest>
6 #include <QTimer>
7 #include <gtest/gtest.h>
8 #include "dasync.h"
9 #include "dtimedloop.h"
10
11 #include "ut_dutil.h"
12
13 DCORE_USE_NAMESPACE
14 #if 0
15 // 为了方便托管 std::thread 而创建的辅助类
16 class Thread : public QObject {
17 std::thread *m_thread = nullptr;
18 public:
19 template<typename FUNC>
20 Thread(FUNC &&func, QObject *parent = nullptr)
21 : QObject (parent)
22 , m_thread (new std::thread(func))
23 {
24 }
25 void detach() {
26 m_thread->detach();
27 }
28 void join() {
29 m_thread->join();
30 }
31
32 virtual ~Thread()
33 {
34 if (m_thread) {
35 delete m_thread;
36 m_thread = nullptr;
37 }
38 }
39 };
40
41 bool gInSubFlag = true;
42
43 // 全局内存托管,防止 asan 报错
44 QObject gRoot;
45 template <typename FUNC>
46 void DetachedRun(FUNC &&func) {
47 Thread *thread = new Thread(func, &gRoot);
48 if (!gInSubFlag) {
49 func();
50 }
51 thread->detach();
52 }
53
54 class ut_DAsync : public testing::Test, public QObject
55 {
56 public:
57 class Test : public QObject {
58 public:
59 Test(int in, QObject *parent = nullptr)
60 : QObject (parent)
61 , count (in)
62 {
63 }
64 int count = 0;
65 };
66
67 ut_DAsync() { }
68 virtual ~ut_DAsync() {}
69
70 virtual void SetUp() {
71 task1 = new DAsync<int, int>(this);
72 // 测试 task2 在线程内部new能正常工作
73 task3 = new DAsync<int, QString>(this);
74 // task4~task7 测试固定的API,功能大同小异,在函数内部创建
75 task8 = new DAsync<void, QString>(this);
76 task9 = new DAsync<void, void>(this);
77 task10 = new DAsync<int, void>(this);
78
79 m_loop = new DTimedLoop(this);
80 m_loop->setTimeDump(true);
81 }
82
83 virtual void TearDown() {
84 // 释放资源要用 deleteLater 或者托管内存
85 // 避免线程不同步时直接 delete 导致 asan 偶发性报使用释放掉的堆内存
86 }
87 // 首先要保证这些不同类型的模板参数的声明没有编译问题
88 DAsync<int ,int> *task1 = nullptr;
89 DAsync<int ,int> *task2 = nullptr;
90 DAsync<int, QString> *task3 = nullptr;
91 DAsync<QString, QString> *task4 = nullptr;
92 DAsync<Test *, Test*> *task5 = nullptr;
93 DAsync<QString, void> *task6 = nullptr;
94 // 第一个模板参数是 void 的类型的仅执行一次函数调用
95 DAsync<void, void> *task7 = nullptr;
96 DAsync<void, QString> *task8 = nullptr;
97 DAsync<void, void> *task9 = nullptr;
98 DAsync<int, void> *task10 = nullptr;
99
100 // m_loop 须是 static 的,asan 会有误报
101 static DTimedLoop *m_loop;
102 };
103
104 DTimedLoop *ut_DAsync::m_loop = nullptr;
105
106 TEST_F(ut_DAsync, testRunInCorrectThread)
107 {
108 // 测试 post 中的函数一定在非主线程异步调用
109 // 返回结果传到 then 中的函数在主线程中调用
110 task1->post([](int arg) {
111
112 HAVE_FUN(ASSERT_TRUE(!D_THREAD_IN_MAIN()));
113 return arg;
114
115 })->then([&](int arg) {
116
117 ASSERT_EQ(arg, 1);
118 HAVE_FUN(ASSERT_TRUE(D_THREAD_IN_MAIN()));
119 m_loop->exit();
120
121 })->start();
122
123 task1->postData(1);
124
125 m_loop->exec("testRunInCorrectThread");
126 }
127
128 TEST_F(ut_DAsync, testRunInSubThread)
129 {
130 // 和上面 testRunInCorrectThread 测项类似
131 // task2, 测试 task 在非主线程中依然能正确创建和运行
132 bool startedFlag = false;
133 DetachedRun([&]{
134 // 这里用托管也可以的,但是会有警告
135 task2 = new DAsync<int, int>(/*this*/);
136 task2->post([](int arg) {
137
138 HAVE_FUN(ASSERT_TRUE(!D_THREAD_IN_MAIN()));
139 return arg;
140
141 })->then([&](int arg) {
142
143 static int i = 0;
144 ASSERT_EQ(arg, i++);
145 HAVE_FUN(ASSERT_TRUE(D_THREAD_IN_MAIN()));
146 if (i > 3) m_loop->exit();
147
148 })->start();
149
150 startedFlag = true;
151 });
152
153 DetachedRun([&]{
154 static int i = 0;
155 while (true) {
156 // 要自己设置 flag,因为在不同的线程中,
157 // 到这里 task2 还不一定已经被创建完毕
158 if (startedFlag) {
159 task2->postData(i++);
160 if (i > 3) {
161 break;
162 }
163 }
164 usleep(100*1000);
165 }
166 });
167
168 m_loop->exec("testRunInSubThread");
169 }
170
171 TEST_F(ut_DAsync, testMultiThreadSynchronization)
172 {
173 // task3, 在子线程中输入 0~999, 在 post 中乘以 2 输出到主线程 then 中
174 static int n = 1000;
175 static int result = 0;
176
177 task3->post([](int arg) -> QString {
178
179 return QString("%1").arg(arg * 2);
180
181 })->then([](QString arg) {
182
183 static int i = 0;
184 ASSERT_TRUE(arg == QString("%1").arg(i * 2));
185 i++;
186 result = n;
187
188 })->start();
189
190 DetachedRun([&] {
191 int i = 0;
192 while (i < n) {
193 if (!task3->isFinished()) {
194 task3->postData(i++);
195 }
196 }
197 task3->cancelAll();
198 });
199
200 DetachedRun([&] {
201 // 该线程启动后会一直阻塞等待,直到 cancelAll 被调用,
202 // 说明任务结束了,就可以往下走,判断执行结果
203 task3->waitForFinished(false);
204 ASSERT_EQ(result, n);
205 m_loop->exit();
206 });
207
208 m_loop->exec("testMultiThreadSynchronization");
209 }
210
211 TEST_F(ut_DAsync, testOneTimeTask)
212 {
213 // task8, 测试一次性任务,确保两个函数只会进来执行一次
214 task8->post([] {
215
216 static int i = 0;
217 return QString("testOneTimeTask%1").arg(i++);
218
219 })->then([&](const QString &arg) {
220
221 ASSERT_TRUE(arg == "testOneTimeTask0");
222 m_loop->exit();
223
224 })->start();
225 m_loop->exec("test task8");
226
227 // task9, 测试一次性任务,确保只有 post 的函数能够被执行到
228 task9->post([&]{
229 m_loop->exit();
230 })->start();
231 // task9->startUp(); # 或者在合适的时候调用
232 m_loop->exec("test task9");
233
234 // task10, 测试仅有 post 的任务的正确执行
235 task10->post([&] (int arg) {
236 static int j = 0;
237 ASSERT_EQ(arg, j++);
238 if (j == 2) {
239 m_loop->exit();
240 }
241 });
242 task10->postData(0);
243 task10->startUp();
244 task10->postData(1);
245 m_loop->exec("test task10");
246 }
247
248 TEST_F(ut_DAsync, testFixedApi)
249 {
250 // 测试这些固定的 API 能够正确处理不同的参数类型
251 // task4
252 task4 = new DAsync<QString, QString>(this);
253 static int i = 0;
254 while (i < 100) {
255 task4->postData(QString::number(i++));
256 }
257 task4->post([](const QString &arg) -> QString {
258
259 static int j = 0;
260 HAVE_FUN(ASSERT_TRUE(arg == QString::number(j++)));
261 return arg;
262
263 })->then([](QString arg) {
264
265 static int k = 0;
266 ASSERT_TRUE(arg == QString::number(k++));
267 if (k == 100) {
268 m_loop->exit();
269 }
270
271 })->start();
272
273 m_loop->exec("test task4");
274
275 // 和上面的不一样的地方就是 postData 在 start 前后都调用了
276 // task5
277 i = 0;
278 task5 = new DAsync<Test *, Test*>(this);
279 while (i < 50) {
280 task5->postData(new Test(i++, this));
281 }
282
283 task5->post([](Test *arg) -> Test * {
284
285 static int j = 0;
286 HAVE_FUN(ASSERT_TRUE(arg->count == j++));
287 return arg;
288
289 })->then([](Test *arg) {
290
291 static int k = 0;
292 HAVE_FUN(ASSERT_TRUE(arg->count == k++));
293 if (k == 100) {
294 m_loop->exit();
295 }
296
297 })->start();
298
299 while (i < 100) {
300 task5->postData(new Test(i++, this));
301 }
302 m_loop->exec("test task5");
303
304 // task6
305 i = 0;
306 task6 = new DAsync<QString, void>(this);
307 while (i < 50) {
308 task6->postData(QString::number(i++));
309 }
310 task6->post([](QString arg) {
311
312 static int j = 0;
313 HAVE_FUN(ASSERT_TRUE(arg == QString::number(j++)));
314
315 })->then([]() {
316
317 static int k = 0;
318 k++;
319 if (k == 100) {
320 m_loop->exit();
321 }
322
323 })->start(false);
324
325 DetachedRun([&]{
326 usleep(100 * 1000);
327
328 while (i < 100) {
329 task6->postData(QString::number(i++));
330 }
331 task6->startUp();
332 });
333 m_loop->exec("test task6");
334
335 // task7
336 task7 = new DAsync<void, void>(this);
337 task7->post([]() {
338
339 static int j = 0;
340 HAVE_FUN(ASSERT_TRUE(0 == j++));
341
342 })->then([]() {
343
344 static int k = 0;
345 HAVE_FUN(ASSERT_TRUE(0 == k++));
346 m_loop->exit();
347
348 })->start();
349 m_loop->exec("test task7");
350 }
351 #endif