1 /*
2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 <iostream>
18 #include "common/sharing_log.h"
19 #include "event/event_manager.h"
20 #include "event/taskpool.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::Sharing;
24
25 namespace OHOS {
26 namespace Sharing {
27 class EventListenerImpl : public EventListener {
28 public:
29 EventListenerImpl() = default;
30 int32_t OnEvent(SharingEvent &event) final
31 {
32 SHARING_LOGD("ontestEvent");
33 return 0;
34 }
35 };
36
37 class SharingEventUnitTest : public testing::Test {};
38
39 namespace {
40
HWTEST_F(SharingEventUnitTest, Event_Base_01, Function | SmallTest | Level2)41 HWTEST_F(SharingEventUnitTest, Event_Base_01, Function | SmallTest | Level2)
42 {
43 SHARING_LOGD("trace");
44 SharingEvent event;
45 int32_t ret = -1;
46 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
47 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
48 EXPECT_NE(emitter, nullptr);
49
50 event.description = "test";
51 event.emitterType = CLASS_TYPE_PRODUCER;
52 event.eventMsg = contextEventMsgSptr;
53 event.listenerType = CLASS_TYPE_PRODUCER;
54
55 ret = emitter->SendEvent(event);
56 EXPECT_EQ(ret, 0);
57 }
58
HWTEST_F(SharingEventUnitTest, Event_Base_02, Function | SmallTest | Level2)59 HWTEST_F(SharingEventUnitTest, Event_Base_02, Function | SmallTest | Level2)
60 {
61 SHARING_LOGD("trace");
62 SharingEvent event;
63 int32_t ret = -1;
64 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
65 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
66 EXPECT_NE(emitter, nullptr);
67
68 event.description = "test";
69 event.emitterType = CLASS_TYPE_INTERACTION;
70 event.eventMsg = contextEventMsgSptr;
71 event.listenerType = CLASS_TYPE_INTERACTION;
72
73 ret = emitter->SendEvent(event);
74 EXPECT_EQ(ret, 0);
75 }
76
HWTEST_F(SharingEventUnitTest, Event_Base_03, Function | SmallTest | Level2)77 HWTEST_F(SharingEventUnitTest, Event_Base_03, Function | SmallTest | Level2)
78 {
79 SHARING_LOGD("trace");
80 int32_t ret = -1;
81 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
82 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
83 EXPECT_NE(emitter, nullptr);
84 SharingEvent event;
85
86 event.description = "test";
87 event.emitterType = CLASS_TYPE_SCHEDULER;
88 event.eventMsg = contextEventMsgSptr;
89 event.listenerType = CLASS_TYPE_SCHEDULER;
90
91 ret = emitter->SendEvent(event);
92 EXPECT_EQ(ret, 0);
93 }
94
HWTEST_F(SharingEventUnitTest, Event_Base_04, Function | SmallTest | Level2)95 HWTEST_F(SharingEventUnitTest, Event_Base_04, Function | SmallTest | Level2)
96 {
97 SHARING_LOGD("trace");
98 int32_t ret = -1;
99 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
100 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
101 EXPECT_NE(emitter, nullptr);
102 SharingEvent event;
103
104 event.description = "test";
105 event.emitterType = CLASS_TYPE_CONTEXT;
106 event.eventMsg = contextEventMsgSptr;
107 event.listenerType = CLASS_TYPE_CONTEXT;
108
109 ret = emitter->SendEvent(event);
110 EXPECT_EQ(ret, 0);
111 }
112
HWTEST_F(SharingEventUnitTest, Event_Base_05, Function | SmallTest | Level2)113 HWTEST_F(SharingEventUnitTest, Event_Base_05, Function | SmallTest | Level2)
114 {
115 SHARING_LOGD("trace");
116 int32_t ret = -1;
117 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
118 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
119 EXPECT_NE(emitter, nullptr);
120 SharingEvent event;
121
122 event.description = "test";
123 event.emitterType = CLASS_TYPE_AGENT;
124 event.eventMsg = contextEventMsgSptr;
125 event.listenerType = CLASS_TYPE_AGENT;
126
127 ret = emitter->SendEvent(event);
128 EXPECT_EQ(ret, 0);
129 }
130
HWTEST_F(SharingEventUnitTest, Event_Base_06, Function | SmallTest | Level2)131 HWTEST_F(SharingEventUnitTest, Event_Base_06, Function | SmallTest | Level2)
132 {
133 SHARING_LOGD("trace");
134 int32_t ret = -1;
135 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
136 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
137 EXPECT_NE(emitter, nullptr);
138 SharingEvent event;
139
140 event.description = "test";
141 event.emitterType = CLASS_TYPE_SESSION;
142 event.eventMsg = contextEventMsgSptr;
143 event.listenerType = CLASS_TYPE_SESSION;
144
145 ret = emitter->SendEvent(event);
146 EXPECT_EQ(ret, 0);
147 }
148
HWTEST_F(SharingEventUnitTest, Event_Manager_01, Function | SmallTest | Level2)149 HWTEST_F(SharingEventUnitTest, Event_Manager_01, Function | SmallTest | Level2)
150 {
151 SHARING_LOGD("trace");
152 EventManager::GetInstance().Init();
153 EventManager::GetInstance().StartEventLoop();
154 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
155 std::shared_ptr<EventListenerImpl> listener1 = std::make_shared<EventListenerImpl>();
156 std::shared_ptr<EventListenerImpl> listener2 = std::make_shared<EventListenerImpl>();
157
158 auto ret = EventManager::GetInstance().AddListener(listener);
159 EXPECT_EQ(ret, 0);
160
161 ret = EventManager::GetInstance().AddListener(listener1);
162 EXPECT_EQ(ret, 0);
163
164 ret = EventManager::GetInstance().AddListener(listener2);
165 EXPECT_EQ(ret, 0);
166
167 ret = EventManager::GetInstance().DelListener(listener);
168 EXPECT_EQ(ret, 0);
169
170 ret = EventManager::GetInstance().DrainAllListeners();
171 EXPECT_EQ(ret, 0);
172 SharingEvent event;
173
174 event.description = "test";
175 event.emitterType = CLASS_TYPE_PRODUCER;
176 event.eventMsg = std::make_shared<EventMsg>();
177 event.listenerType = CLASS_TYPE_SCHEDULER;
178 ret = EventManager::GetInstance().PushEvent(event);
179 EXPECT_EQ(ret, 0);
180
181 ret = EventManager::GetInstance().PushSyncEvent(event);
182 EXPECT_EQ(ret, 0);
183 }
184
HWTEST_F(SharingEventUnitTest, Event_Base_07, Function | SmallTest | Level2)185 HWTEST_F(SharingEventUnitTest, Event_Base_07, Function | SmallTest | Level2)
186 {
187 SHARING_LOGD("trace");
188 int32_t ret = -1;
189 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
190 EXPECT_NE(emitter, nullptr);
191 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
192 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
193 SharingEvent event;
194
195 listener->SetListenerClassType(CLASS_TYPE_INTERACTION);
196 listener->Register();
197
198 event.description = "test";
199 event.emitterType = CLASS_TYPE_INTERACTION;
200 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
201 event.eventMsg = contextEventMsgSptr;
202 event.listenerType = CLASS_TYPE_INTERACTION;
203
204 ret = emitter->SendSyncEvent(event);
205 EXPECT_EQ(ret, 0);
206 }
207
HWTEST_F(SharingEventUnitTest, Event_Base_08, Function | SmallTest | Level2)208 HWTEST_F(SharingEventUnitTest, Event_Base_08, Function | SmallTest | Level2)
209 {
210 SHARING_LOGD("trace");
211 int32_t ret = -1;
212 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
213 EXPECT_NE(emitter, nullptr);
214 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
215 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
216 SharingEvent event;
217
218 listener->SetListenerClassType(CLASS_TYPE_SCHEDULER);
219 listener->Register();
220
221 event.description = "test";
222 event.emitterType = CLASS_TYPE_SCHEDULER;
223 event.eventMsg = contextEventMsgSptr;
224 event.listenerType = CLASS_TYPE_SCHEDULER;
225
226 ret = emitter->SendSyncEvent(event);
227 EXPECT_EQ(ret, 0);
228 }
229
HWTEST_F(SharingEventUnitTest, Event_Base_09, Function | SmallTest | Level2)230 HWTEST_F(SharingEventUnitTest, Event_Base_09, Function | SmallTest | Level2)
231 {
232 SHARING_LOGD("trace");
233 int32_t ret = -1;
234 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
235 EXPECT_NE(emitter, nullptr);
236 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
237 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
238 SharingEvent event;
239
240 listener->SetListenerClassType(CLASS_TYPE_CONTEXT);
241 listener->Register();
242
243 event.description = "test";
244 event.emitterType = CLASS_TYPE_CONTEXT;
245 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
246 event.eventMsg = contextEventMsgSptr;
247 event.listenerType = CLASS_TYPE_CONTEXT;
248
249 ret = emitter->SendSyncEvent(event);
250 EXPECT_EQ(ret, 0);
251 }
252
HWTEST_F(SharingEventUnitTest, Event_Base_10, Function | SmallTest | Level2)253 HWTEST_F(SharingEventUnitTest, Event_Base_10, Function | SmallTest | Level2)
254 {
255 SHARING_LOGD("trace");
256 int32_t ret = -1;
257 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
258 EXPECT_NE(emitter, nullptr);
259 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
260 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
261 SharingEvent event;
262
263 listener->SetListenerClassType(CLASS_TYPE_AGENT);
264 listener->Register();
265
266 event.description = "test";
267 event.emitterType = CLASS_TYPE_AGENT;
268 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
269 event.eventMsg = contextEventMsgSptr;
270 event.listenerType = CLASS_TYPE_AGENT;
271 ret = emitter->SendSyncEvent(event);
272 EXPECT_EQ(ret, 0);
273 }
274
HWTEST_F(SharingEventUnitTest, Event_Base_11, Function | SmallTest | Level2)275 HWTEST_F(SharingEventUnitTest, Event_Base_11, Function | SmallTest | Level2)
276 {
277 SHARING_LOGD("trace");
278 int32_t ret = -1;
279 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
280 EXPECT_NE(emitter, nullptr);
281 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
282 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
283 SharingEvent event;
284
285 listener->SetListenerClassType(CLASS_TYPE_SESSION);
286 listener->Register();
287
288 event.description = "test";
289 event.emitterType = CLASS_TYPE_SESSION;
290 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
291 event.eventMsg = contextEventMsgSptr;
292 event.listenerType = CLASS_TYPE_SESSION;
293
294 ret = emitter->SendSyncEvent(event);
295 EXPECT_EQ(ret, 0);
296 }
297
HWTEST_F(SharingEventUnitTest, Event_Base_12, Function | SmallTest | Level2)298 HWTEST_F(SharingEventUnitTest, Event_Base_12, Function | SmallTest | Level2)
299 {
300 SHARING_LOGD("trace");
301 int32_t ret = -1;
302 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
303 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
304 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
305 SharingEvent event;
306
307 listener->SetListenerClassType(CLASS_TYPE_CONSUMER);
308 listener->Register();
309 EXPECT_NE(emitter, nullptr);
310
311 event.description = "test";
312 event.emitterType = CLASS_TYPE_CONSUMER;
313 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
314 event.eventMsg = contextEventMsgSptr;
315 event.listenerType = CLASS_TYPE_CONSUMER;
316
317 ret = emitter->SendSyncEvent(event);
318 EXPECT_EQ(ret, 0);
319 }
320
HWTEST_F(SharingEventUnitTest, Event_Base_13, Function | SmallTest | Level2)321 HWTEST_F(SharingEventUnitTest, Event_Base_13, Function | SmallTest | Level2)
322 {
323 SHARING_LOGD("trace");
324 int32_t ret = -1;
325 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
326 EXPECT_NE(emitter, nullptr);
327 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
328 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
329 SharingEvent event;
330
331 listener->SetListenerClassType(CLASS_TYPE_PRODUCER);
332 listener->Register();
333
334 event.description = "test";
335 event.emitterType = CLASS_TYPE_PRODUCER;
336 contextEventMsgSptr->type = EVENT_CONTEXT_BASE;
337 event.eventMsg = contextEventMsgSptr;
338 event.listenerType = CLASS_TYPE_PRODUCER;
339
340 ret = emitter->SendSyncEvent(event);
341 EXPECT_EQ(ret, 0);
342 EventManager::GetInstance().StartEventLoop();
343 }
344
HWTEST_F(SharingEventUnitTest, Event_Base_15, Function | SmallTest | Level2)345 HWTEST_F(SharingEventUnitTest, Event_Base_15, Function | SmallTest | Level2)
346 {
347 SHARING_LOGD("trace");
348 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
349
350 eventMsg->type = EVENT_AGENT_BASE;
351 eventMsg->toMgr = MODULE_CONTEXT;
352
353 EventChecker::CheckEvent(eventMsg);
354 }
355
HWTEST_F(SharingEventUnitTest, Event_Base_16, Function | SmallTest | Level2)356 HWTEST_F(SharingEventUnitTest, Event_Base_16, Function | SmallTest | Level2)
357 {
358 SHARING_LOGD("trace");
359 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
360
361 eventMsg->type = EVENT_SESSION_BASE;
362 eventMsg->toMgr = MODULE_MEDIACHANNEL;
363
364 EventChecker::CheckEvent(eventMsg);
365 }
366
HWTEST_F(SharingEventUnitTest, Event_Base_17, Function | SmallTest | Level2)367 HWTEST_F(SharingEventUnitTest, Event_Base_17, Function | SmallTest | Level2)
368 {
369 SHARING_LOGD("trace");
370 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
371
372 eventMsg->type = EVENT_SCHEDULER_BASE;
373 eventMsg->toMgr = MODULE_MEDIACHANNEL;
374
375 EventChecker::CheckEvent(eventMsg);
376 }
377
HWTEST_F(SharingEventUnitTest, Event_Base_18, Function | SmallTest | Level2)378 HWTEST_F(SharingEventUnitTest, Event_Base_18, Function | SmallTest | Level2)
379 {
380 SHARING_LOGD("trace");
381 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
382
383 eventMsg->type = EVENT_SCHEDULER_BASE;
384 eventMsg->toMgr = MODULE_CONFIGURE;
385
386 EventChecker::CheckEvent(eventMsg);
387 }
388
HWTEST_F(SharingEventUnitTest, Event_Base_19, Function | SmallTest | Level2)389 HWTEST_F(SharingEventUnitTest, Event_Base_19, Function | SmallTest | Level2)
390 {
391 SHARING_LOGD("trace");
392 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
393
394 eventMsg->type = (EventType)7000;
395 eventMsg->toMgr = MODULE_CONFIGURE;
396
397 EventChecker::CheckEvent(eventMsg);
398 }
399
HWTEST_F(SharingEventUnitTest, Event_Base_20, Function | SmallTest | Level2)400 HWTEST_F(SharingEventUnitTest, Event_Base_20, Function | SmallTest | Level2)
401 {
402 SHARING_LOGD("trace");
403 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
404
405 eventMsg->type = (EventType)7000;
406 eventMsg->toMgr = MODULE_INTERACTION;
407
408 EventChecker::CheckEvent(eventMsg);
409 }
410
HWTEST_F(SharingEventUnitTest, Event_Base_21, Function | SmallTest | Level2)411 HWTEST_F(SharingEventUnitTest, Event_Base_21, Function | SmallTest | Level2)
412 {
413 SHARING_LOGD("trace");
414 EventChecker::CheckEvent(nullptr);
415 }
416
HWTEST_F(SharingEventUnitTest, Event_Base_22, Function | SmallTest | Level2)417 HWTEST_F(SharingEventUnitTest, Event_Base_22, Function | SmallTest | Level2)
418 {
419 SHARING_LOGD("trace");
420 int32_t ret = -1;
421 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
422 EXPECT_NE(emitter, nullptr);
423 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
424 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
425 SharingEvent event;
426
427 ret = listener->Register();
428 EXPECT_EQ(ret, 0);
429 ret = listener->UnRegister();
430 EXPECT_EQ(ret, 0);
431 }
432
HWTEST_F(SharingEventUnitTest, Event_Base_23, Function | SmallTest | Level2)433 HWTEST_F(SharingEventUnitTest, Event_Base_23, Function | SmallTest | Level2)
434 {
435 SHARING_LOGD("trace");
436 int32_t ret = -1;
437 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
438 EXPECT_NE(emitter, nullptr);
439 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
440 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
441 SharingEvent event;
442
443 EventManager::GetInstance().DrainAllListeners();
444 ret = listener->Register();
445 EXPECT_EQ(ret, 0);
446 }
447
HWTEST_F(SharingEventUnitTest, Event_Base_24, Function | SmallTest | Level2)448 HWTEST_F(SharingEventUnitTest, Event_Base_24, Function | SmallTest | Level2)
449 {
450 SHARING_LOGD("trace");
451 bool ret = false;
452 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
453 SharingEvent event;
454
455 ret = listener->IsAcceptType(EVENT_COMMON_BASE);
456 EXPECT_EQ(ret, false);
457 }
458
HWTEST_F(SharingEventUnitTest, Event_Base_25, Function | SmallTest | Level2)459 HWTEST_F(SharingEventUnitTest, Event_Base_25, Function | SmallTest | Level2)
460 {
461 SHARING_LOGD("trace");
462 int32_t ret = -1;
463 bool tag = false;
464 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
465 SharingEvent event;
466
467 ret = listener->AddAcceptEventType(EVENT_COMMON_BASE);
468 EXPECT_EQ(ret, 0);
469 tag = listener->IsAcceptType(EVENT_COMMON_BASE);
470 EXPECT_EQ(tag, true);
471 }
472
HWTEST_F(SharingEventUnitTest, Event_Base_26, Function | SmallTest | Level2)473 HWTEST_F(SharingEventUnitTest, Event_Base_26, Function | SmallTest | Level2)
474 {
475 SHARING_LOGD("trace");
476 int32_t ret = -1;
477 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
478 SharingEvent event;
479
480 ret = listener->AddAcceptEventType(EVENT_COMMON_BASE);
481 EXPECT_EQ(ret, 0);
482 ret = listener->DelAcceptEventType(EVENT_COMMON_BASE);
483 EXPECT_EQ(ret, 0);
484 }
485
HWTEST_F(SharingEventUnitTest, Event_Base_27, Function | SmallTest | Level2)486 HWTEST_F(SharingEventUnitTest, Event_Base_27, Function | SmallTest | Level2)
487 {
488 SHARING_LOGD("trace");
489 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
490 SharingEvent event;
491
492 listener->GetAcceptTypes();
493 }
494
HWTEST_F(SharingEventUnitTest, Event_Base_28, Function | SmallTest | Level2)495 HWTEST_F(SharingEventUnitTest, Event_Base_28, Function | SmallTest | Level2)
496 {
497 SHARING_LOGD("trace");
498 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
499 SharingEvent event;
500
501 listener->GetListenerClassType();
502 }
503
testTask()504 int32_t testTask()
505 {
506 SHARING_LOGD("testTask");
507 sleep(2);
508 return 0;
509 }
510
HWTEST_F(SharingEventUnitTest, Task_Pool_01, Function | SmallTest | Level2)511 HWTEST_F(SharingEventUnitTest, Task_Pool_01, Function | SmallTest | Level2)
512 {
513 SHARING_LOGD("task_Pool_01");
514 std::shared_ptr<TaskPool> taskPool = std::make_shared<TaskPool>();
515 EXPECT_NE(taskPool, nullptr);
516
517 taskPool->SetMaxTaskNum(1000);
518 auto ret = taskPool->GetMaxTaskNum();
519 EXPECT_EQ(ret, (uint32_t)1000);
520
521 ret = taskPool->Start(100);
522 EXPECT_EQ(ret, (int32_t)0);
523
524 taskPool->SetTimeoutInterval(1000);
525
526 taskPool->Stop();
527 std::packaged_task<TaskPool::BindedTask> bindedTask(testTask);
528 taskPool->PushTask(bindedTask);
529
530 ret = taskPool->GetTaskNum();
531 EXPECT_EQ(ret, 1);
532 }
533
534 } // namespace
535 } // namespace Sharing
536 } // namespace OHOS