1 /*
2 * Copyright (c) 2023 iSoftStone Information Technology (Group) 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 #define private public
17 #define protected public
18 #include "core/common/flutter/flutter_task_executor.h"
19 #include "core/common/flutter/flutter_window.h"
20 #include "core/common/flutter/flutter_thread_model.h"
21
22 #include "test/mock/core/common/mock_container.h"
23 #include "core/components/plugin/file_asset_provider.h"
24 #include "mock_flutter.h"
25
26 #undef private
27 #undef protected
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS::Ace {
33 namespace {
34 const std::string UISYNCTASK = "ui task has executed";
35 const std::string BACKGROUNDSYNCTASK = "background task has executed";
36 const std::string LABEL_TEST = "task executor";
37 const std::string THREAD_FIRST = "thread_first";
38 const std::string THREAD_SECOND = "thread_second";
39 const std::string THREAD_THIRD = "thread_third";
40 const std::string THREAD_FOURTH = "thread_fourth";
41 const std::string RET_TEST = "error";
42 const std::string HAP_PATH = "test";
43
44 uint64_t test_result = 2;
45 int32_t instanceId = 1;
46 MediaFileInfo FILE_INFO = { .fileName = RET_TEST, .offset = 1, .length = 1, .lastModTime = 1, .lastModDate = 1 };
47
MakeTaskRunner()48 flutter::TaskRunners MakeTaskRunner()
49 {
50 std::string label = LABEL_TEST;
51 std::unique_ptr<fml::Thread> threadFirst = std::make_unique<fml::Thread>(THREAD_FIRST);
52 std::unique_ptr<fml::Thread> threadSecond = std::make_unique<fml::Thread>(THREAD_SECOND);
53 std::unique_ptr<fml::Thread> threadThird = std::make_unique<fml::Thread>(THREAD_THIRD);
54 std::unique_ptr<fml::Thread> threadFourth = std::make_unique<fml::Thread>(THREAD_FOURTH);
55
56 fml::RefPtr<fml::TaskRunner> platform = threadFirst->GetTaskRunner();
57 fml::RefPtr<fml::TaskRunner> gpu = threadSecond->GetTaskRunner();
58 fml::RefPtr<fml::TaskRunner> ui = threadThird->GetTaskRunner();
59 fml::RefPtr<fml::TaskRunner> io = threadFourth->GetTaskRunner();
60 flutter::TaskRunners testTaskRunner(label, platform, gpu, ui, io);
61
62 RefPtr<FlutterTaskExecutor> taskExecutor = AceType::MakeRefPtr<FlutterTaskExecutor>(testTaskRunner);
63 taskExecutor->InitOtherThreads(testTaskRunner);
64
65 return testTaskRunner;
66 };
67
MakeTaskExecutor()68 RefPtr<FlutterTaskExecutor> MakeTaskExecutor()
69 {
70 auto taskRunner = MakeTaskRunner();
71 RefPtr<FlutterTaskExecutor> taskExecutor = AceType::MakeRefPtr<FlutterTaskExecutor>(taskRunner);
72
73 return taskExecutor;
74 };
75 }
76
77 class FlutterTest : public testing::Test {
78 public:
SetUpTestSuite()79 static void SetUpTestSuite()
80 {
81 MockContainer::SetUp();
82 }
TeardownTestSuite()83 static void TeardownTestSuite()
84 {
85 MockContainer::TearDown();
86 }
87 };
88
89 /**
90 * @tc.name: Flutter_Task_ExecutorTest01
91 * @tc.desc: Test the operation of flutter
92 * @tc.type: FUNC
93 */
94 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest01, TestSize.Level1)
95 {
96 /**
97 * @tc.steps1: Build a flutterTaskExecutor object is null.
98 */
99 FlutterTaskExecutor flutterTaskExecutor;
100
101 /**
102 * @tc.steps2: callback WillRunOnCurrentThread.
103 * @tc.expected: The return run thread is false.
104 */
105 for (int32_t id = 0; id < 7; id++) {
106 auto taskType = static_cast<TaskExecutor::TaskType>(id);
107 auto result = flutterTaskExecutor.WillRunOnCurrentThread(taskType);
108 switch (taskType) {
109 case TaskExecutor::TaskType::PLATFORM:
110 case TaskExecutor::TaskType::UI:
111 case TaskExecutor::TaskType::IO:
112 case TaskExecutor::TaskType::GPU:
113 case TaskExecutor::TaskType::JS:
114 case TaskExecutor::TaskType::BACKGROUND:
115 EXPECT_FALSE(result);
116 break;
117 default:
118 EXPECT_FALSE(result);
119 }
120 }
121 }
122
123 /**
124 * @tc.name: Flutter_Task_ExecutorTest02
125 * @tc.desc: Test the operation of flutter
126 * @tc.type: FUNC
127 */
128 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest02, TestSize.Level1)
129 {
130 /**
131 * @tc.steps1: Build a flutterTaskExecutor object is not null.
132 */
133 auto flutterTaskExecutor = MakeTaskExecutor();
134
135 /**
136 * @tc.steps2: callback WillRunOnCurrentThread.
137 * @tc.expected: The return run thread is task type.
138 */
139 for (int32_t id = 0; id < 7; id++) {
140 auto taskType = static_cast<TaskExecutor::TaskType>(id);
141 auto result = flutterTaskExecutor->WillRunOnCurrentThread(taskType);
142 switch (taskType) {
143 case TaskExecutor::TaskType::PLATFORM:
144 EXPECT_EQ(result, flutterTaskExecutor->platformRunner_->RunsTasksOnCurrentThread());
145 break;
146 case TaskExecutor::TaskType::UI:
147 EXPECT_EQ(result, flutterTaskExecutor->uiRunner_->RunsTasksOnCurrentThread());
148 break;
149 case TaskExecutor::TaskType::IO:
150 EXPECT_EQ(result, flutterTaskExecutor->ioRunner_->RunsTasksOnCurrentThread());
151 break;
152 case TaskExecutor::TaskType::GPU:
153 EXPECT_EQ(result, flutterTaskExecutor->gpuRunner_->RunsTasksOnCurrentThread());
154 break;
155 case TaskExecutor::TaskType::JS:
156 EXPECT_EQ(result, flutterTaskExecutor->jsRunner_->RunsTasksOnCurrentThread());
157 break;
158 case TaskExecutor::TaskType::BACKGROUND:
159 EXPECT_FALSE(result);
160 break;
161 default:
162 EXPECT_FALSE(result);
163 }
164 }
165 }
166
167 /**
168 * @tc.name: Flutter_Task_ExecutorTest03
169 * @tc.desc: Test the operation of flutter
170 * @tc.type: FUNC
171 */
172 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest03, TestSize.Level1)
173 {
174 /**
175 * @tc.steps1: Build a flutterTaskExecutor object is not null.
176 */
177 auto flutterTaskExecutor = MakeTaskExecutor();
178
179 /**
180 * @tc.steps2: callback InitJsThread push newThread is true.
181 * @tc.expected: Return expected results.
182 */
183 flutterTaskExecutor->InitJsThread(true);
184 EXPECT_EQ(flutterTaskExecutor->jsRunner_, flutterTaskExecutor->jsThread_->GetTaskRunner());
185
186 /**
187 * @tc.steps3: callback InitJsThread push newThread is false.
188 * @tc.expected: Return expected results.
189 */
190 flutterTaskExecutor->InitJsThread(false);
191 EXPECT_EQ(flutterTaskExecutor->jsRunner_, flutterTaskExecutor->uiRunner_);
192 }
193
194 /**
195 * @tc.name: Flutter_Task_ExecutorTest04
196 * @tc.desc: Test the operation of flutter
197 * @tc.type: FUNC
198 */
199 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest04, TestSize.Level1)
200 {
201 /**
202 * @tc.steps1: Build a flutterTaskExecutor object is not null.
203 */
204 auto flutterTaskExecutor = MakeTaskExecutor();
205
206 /**
207 * @tc.steps2: callback InitPlatformThread push useCurrentEventRunner is true.
208 * @tc.expected: Return expected results.
209 */
210 flutterTaskExecutor->InitPlatformThread(true);
211 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.size(), 1);
212
213 /**
214 * @tc.steps3: callback InitOtherThreads.
215 * @tc.expected: Return expected results.
216 */
217 flutter::TaskRunners taskRunner = MakeTaskRunner();
218 flutterTaskExecutor->InitOtherThreads(taskRunner);
219 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.size(), 1);
220 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.bucket_count(), 2);
221 }
222
223 /**
224 * @tc.name: Flutter_Task_ExecutorTest05
225 * @tc.desc: Test the operation of flutter
226 * @tc.type: FUNC
227 */
228 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest05, TestSize.Level1)
229 {
230 /**
231 * @tc.steps1: Build a flutterTaskExecutor object is not null.
232 */
233 auto taskExecutor = MakeTaskExecutor();
234 FlutterTaskExecutor flutterTaskExecutor(taskExecutor);
235
236 /**
237 * @tc.steps2: callback InitOtherThreads push threadModel is null..
238 * @tc.expected: Return expected results.
239 */
240 flutterTaskExecutor.InitOtherThreads(nullptr);
241 EXPECT_EQ(flutterTaskExecutor.taskTypeTable_.size(), 0);
242
243 /**
244 * @tc.steps3: create a threadHost, taskRunner = MakeTaskRunner().
245 */
246 flutter::ThreadHost threadHost;
247 threadHost.platform_thread = std::make_unique<fml::Thread>(THREAD_FIRST);
248 threadHost.ui_thread = std::make_unique<fml::Thread>(THREAD_SECOND);
249 threadHost.gpu_thread = std::make_unique<fml::Thread>(THREAD_THIRD);
250 threadHost.io_thread = std::make_unique<fml::Thread>(THREAD_FOURTH);
251 flutter::TaskRunners taskRunner = MakeTaskRunner();
252
253 /**
254 * @tc.steps4: callback InitOtherThreads push threadModel is new value.
255 * @tc.expected: Return expected results.
256 */
257 FlutterThreadModel* threadModel = new FlutterThreadModel(std::move(threadHost), taskRunner);
258 flutterTaskExecutor.InitOtherThreads(threadModel);
259 EXPECT_EQ(flutterTaskExecutor.uiRunner_, taskRunner.GetUITaskRunner());
260 EXPECT_EQ(flutterTaskExecutor.ioRunner_, taskRunner.GetIOTaskRunner());
261 }
262
263 /**
264 * @tc.name: Flutter_Task_ExecutorTest06
265 * @tc.desc: Test the operation of flutter
266 * @tc.type: FUNC
267 */
268 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest06, TestSize.Level1)
269 {
270 /**
271 * @tc.steps1: Build a flutterTaskExecutor object is not null.
272 */
273 auto flutterTaskExecutor = MakeTaskExecutor();
274
275 /**
276 * @tc.steps2: callback FillTaskTypeTable push weak is null..
277 * @tc.expected: Return expected results.
278 */
279 flutterTaskExecutor->FillTaskTypeTable(nullptr, TaskExecutor::TaskType::UI);
280 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.size(), 0);
281
282 /**
283 * @tc.steps3: callback FillTaskTypeTable push weak is flutterTaskExecutor.
284 * @tc.expected: Return expected results.
285 */
286 flutterTaskExecutor->FillTaskTypeTable(flutterTaskExecutor, TaskExecutor::TaskType::UI);
287 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.size(), 1);
288 EXPECT_EQ(flutterTaskExecutor->taskTypeTable_.bucket_count(), 2);
289 }
290
291 /**
292 * @tc.name: Flutter_Task_ExecutorTest07
293 * @tc.desc: Test the operation of flutter
294 * @tc.type: FUNC
295 */
296 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest07, TestSize.Level1)
297 {
298 /**
299 * @tc.steps1: Build a flutterTaskExecutor object is not null.
300 */
301 auto flutterTaskExecutor = MakeTaskExecutor();
302
303 /**
304 * @tc.steps2: Create a callBack task.
305 */
306 std::string uiTask = "";
__anonf0a29e7f0202() 307 auto callBack = [&uiTask]() {
308 uiTask = UISYNCTASK;
309 };
310
311 /**
312 * @tc.steps3: Set CurrentId_ >= 0.
313 * @tc.steps3: call OnPostTask.set asynchronous task.delayTime is 1.
314 * @tc.expected: task gets executed.
315 */
316 for (int32_t id = 0; id < 7; id++) {
317 auto taskType = static_cast<TaskExecutor::TaskType>(id);
318 auto result = flutterTaskExecutor->OnPostTask(callBack, taskType, 1);
319 switch (taskType) {
320 case TaskExecutor::TaskType::PLATFORM:
321 case TaskExecutor::TaskType::UI:
322 case TaskExecutor::TaskType::IO:
323 case TaskExecutor::TaskType::GPU:
324 case TaskExecutor::TaskType::JS:
325 case TaskExecutor::TaskType::BACKGROUND:
326 EXPECT_TRUE(result);
327 break;
328 case TaskExecutor::TaskType::UNKNOWN:
329 EXPECT_FALSE(result);
330 break;
331 default:
332 EXPECT_FALSE(result);
333 }
334 }
335 }
336
337 /**
338 * @tc.name: Flutter_Task_ExecutorTest08
339 * @tc.desc: Test the operation of flutter
340 * @tc.type: FUNC
341 */
342 HWTEST_F(FlutterTest, Flutter_Task_ExecutorTest08, TestSize.Level1)
343 {
344 /**
345 * @tc.steps1: Build a flutterTaskExecutor object is null.
346 */
347 auto flutterTaskExecutor = MakeTaskExecutor();
348
349 /**
350 * @tc.steps2: Create a callBack task.
351 */
352 std::string backgroudTask = "";
__anonf0a29e7f0302() 353 auto callBack = [&backgroudTask]() {
354 backgroudTask = BACKGROUNDSYNCTASK;
355 };
356
357 /**
358 * @tc.steps3: Set CurrentId_ < 0.
359 * @tc.steps3: call OnPostTask.set asynchronous task.TaskType is GPU.delayTime is 2.
360 * @tc.expected: task gets executed.
361 */
362 Container::UpdateCurrent(-1);
363 flutterTaskExecutor->OnPostTask(callBack, TaskExecutor::TaskType::BACKGROUND, 2);
364 EXPECT_EQ(backgroudTask, "");
365 sleep(2);
366 EXPECT_EQ(backgroudTask, BACKGROUNDSYNCTASK);
367
368 /**
369 * @tc.steps4: call WrapTaskWithTraceId.
370 * @tc.expected: The return result is true.
371 */
372 flutterTaskExecutor->RemoveTaskObserver();
373 auto result = flutterTaskExecutor->WrapTaskWithTraceId(callBack, 1);
374 EXPECT_TRUE(result);
375 }
376
377 /**
378 * @tc.name: Flutter_Thread_Model01
379 * @tc.desc: Test the operation of flutter
380 * @tc.type: FUNC
381 */
382 HWTEST_F(FlutterTest, Flutter_Thread_Model01, TestSize.Level1)
383 {
384 /**
385 * @tc.steps1: Create a threadHost, taskRunner = MakeTaskRunner().
386 * @tc.steps1: New a threadModel with threadHost and taskRunner.
387 */
388 flutter::ThreadHost threadHost;
389 threadHost.platform_thread = std::make_unique<fml::Thread>(THREAD_FIRST);
390 threadHost.ui_thread = std::make_unique<fml::Thread>(THREAD_SECOND);
391 threadHost.gpu_thread = std::make_unique<fml::Thread>(THREAD_THIRD);
392 threadHost.io_thread = std::make_unique<fml::Thread>(THREAD_FOURTH);
393 flutter::TaskRunners taskRunner = MakeTaskRunner();
394 FlutterThreadModel* threadModel = new FlutterThreadModel(std::move(threadHost), taskRunner);
395
396 /**
397 * @tc.steps2: call CreateThreadModel push hasUiThread is true useGpuThread is false.
398 * @tc.expected: return expected results.
399 */
400 auto test_taskRunner = threadModel->taskRunners_;
401 threadModel->CreateThreadModel(true, true, false);
402 EXPECT_TRUE(test_taskRunner.GetUITaskRunner());
403
404 /**
405 * @tc.steps3: call CreateThreadModel, push hasUiThread is false useGpuThread is true.
406 * @tc.expected: return expected results.
407 */
408 threadModel->CreateThreadModel(true, false, true);
409 EXPECT_TRUE(test_taskRunner.GetGPUTaskRunner());
410 }
411
412 /**
413 * @tc.name: Flutter_Asset_Manager01
414 * @tc.desc: Test the operation of flutter
415 * @tc.type: FUNC
416 */
417 HWTEST_F(FlutterTest, Flutter_Asset_Manager01, TestSize.Level1)
418 {
419 /**
420 * @tc.steps1: Create a flutterAssetManager.
421 */
422 auto flutterAssetManager = AceType::MakeRefPtr<FlutterAssetManager>();
423 std::vector<std::string> assetList;
424
425 /**
426 * @tc.steps2: call GetAsset input assetName is "".
427 * @tc.expected: The expected result is null.
428 */
429 auto result = flutterAssetManager->GetAsset("");
430 EXPECT_EQ(result, nullptr);
431
432 /**
433 * @tc.steps3: call PushBack with fileAssetProvider.
434 * @tc.steps3: call GetAsset input assetName is RET_TEST.
435 * @tc.expected: The expected result is null.
436 */
437 auto fileAssetProvider = AceType::MakeRefPtr<Plugin::FileAssetProvider>();
438 flutterAssetManager->PushBack(std::move(fileAssetProvider));
439 auto ass_Result = flutterAssetManager->GetAsset(RET_TEST);
440 EXPECT_EQ(ass_Result, nullptr);
441
442 /**
443 * @tc.steps4: call GetAssetPath input providers_ is Default value.
444 * @tc.expected: The expected result is null.
445 */
446 std::string path_Result = flutterAssetManager->GetAssetPath(RET_TEST, true);
447 EXPECT_EQ(path_Result, "");
448
449 /**
450 * @tc.steps5: call GetAssetList input assetName is RET_TEST.
451 * @tc.expected: The assetList.empty().
452 */
453 flutterAssetManager->GetAssetList(RET_TEST, assetList);
454 EXPECT_TRUE(assetList.empty());
455
456 /**
457 * @tc.steps6: call GetFileInfo input providers_ is Default value.
458 * @tc.expected: The expected result is false.
459 */
460 bool info_Result = flutterAssetManager->GetFileInfo(RET_TEST, FILE_INFO);
461 EXPECT_FALSE(info_Result);
462 flutterAssetManager->ReloadProvider();
463 }
464
465 /**
466 * @tc.name: Flutter_Asset_Manager02
467 * @tc.desc: Test the operation of flutter
468 * @tc.type: FUNC
469 */
470 HWTEST_F(FlutterTest, Flutter_Asset_Manager02, TestSize.Level1)
471 {
472 /**
473 * @tc.steps1: Create a flutterAssetManager.
474 */
475 auto flutterAssetManager = AceType::MakeRefPtr<FlutterAssetManager>();
476
477 /**
478 * @tc.steps2: Create a MockFileAssetProvider.
479 * @tc.steps2: call PushBack with MockFileAssetProvider.
480 */
481 auto mockAssetProvider = AceType::MakeRefPtr<MockFileAssetProvider>();
482 EXPECT_CALL(*mockAssetProvider, IsValid()).Times(1).WillOnce(Return(true));
483 EXPECT_CALL(*mockAssetProvider, GetAssetPath(RET_TEST, true)).Times(1).WillOnce(Return(HAP_PATH));
484 flutterAssetManager->PushBack(std::move(mockAssetProvider));
485
486 /**
487 * @tc.steps3: call GetAssetPath input assetName is RET_TEST.
488 * @tc.expected: The expected result is HAP_PATH.
489 */
490 std::string path_Result = flutterAssetManager->GetAssetPath(RET_TEST, true);
491 EXPECT_EQ(path_Result, "test");
492
493 /**
494 * @tc.steps4: call GetAssetPath input assetName is RET_TEST.
495 * @tc.expected: The expected result is true.
496 * @tc.steps5: call ReloadProvider.
497 */
498 bool result = flutterAssetManager->GetFileInfo(RET_TEST, FILE_INFO);
499 EXPECT_TRUE(result);
500 flutterAssetManager->ReloadProvider();
501 }
502
503 /**
504 * @tc.name: Flutter_Asset_Manager03
505 * @tc.desc: Test the operation of flutter
506 * @tc.type: FUNC
507 */
508 HWTEST_F(FlutterTest, Flutter_Asset_Manager03, TestSize.Level1)
509 {
510 /**
511 * @tc.steps1: Create a flutterAssetManager.
512 */
513 auto flutterAssetManager = AceType::MakeRefPtr<FlutterAssetManager>();
514
515 /**
516 * @tc.steps2: Create a MockFileAssetProvider.
517 * @tc.steps2: call PushBack with MockFileAssetProvider.
518 */
519 auto mockAssetProvider = AceType::MakeRefPtr<MockFileAssetProvider>();
520 EXPECT_CALL(*mockAssetProvider, IsValid()).Times(1).WillOnce(Return(true));
521 flutterAssetManager->PushBack(std::move(mockAssetProvider));
522
523 /**
524 * @tc.steps3: call GetAsset input assetName is RET_TEST.
525 * @tc.expected: The expected result is not null.
526 * @tc.steps4: call ReloadProvider.
527 */
528 auto ass_Result = flutterAssetManager->GetAsset(RET_TEST);
529 ASSERT_NE(ass_Result, nullptr);
530 flutterAssetManager->ReloadProvider();
531 }
532
533 /**
534 * @tc.name: Flutter_window01
535 * @tc.desc: Test the operation of flutter
536 * @tc.type: FUNC
537 */
538 HWTEST_F(FlutterTest, Flutter_window01, TestSize.Level1)
539 {
540 /**
541 * @tc.steps1: Create a flutterWindow object.
542 */
543 Platform::FlutterWindow flutterWindow(instanceId);
544 auto* testview = new FlutterAssetManager();
545
546 /**
547 * @tc.steps2: call Create with nullptr.
548 * @tc.expected: expected Return result_one is null.
549 */
550 auto result_one = flutterWindow.Create(nullptr);
551 EXPECT_EQ(result_one, nullptr);
552
553 /**
554 * @tc.steps3: Create a MockContainer.call GetView Return testview
555 * @tc.steps3: Create a nativeView.
556 */
557 auto container = AceType::MakeRefPtr<MockContainer>();
558 EXPECT_CALL(*container, GetView()).Times(1).WillOnce(Return(testview));
559 auto nativeView = static_cast<AceView*>(container->GetView());
560
561 /**
562 * @tc.steps3: call Create with nativeView.
563 * @tc.expected: expected Return result_two is not null.
564 */
565 auto result_two = flutterWindow.Create(nativeView);
566 ASSERT_NE(result_two, nullptr);
567
568 /**
569 * @tc.steps3: callback Destroy.
570 * @tc.expected: Return expected results..
571 */
572 flutterWindow.Destroy();
573 EXPECT_EQ(flutterWindow.vsyncCallbacks_.size(), 0);
574 }
575
576 /**
577 * @tc.name: Flutter_window02
578 * @tc.desc: Test the operation of flutter
579 * @tc.type: FUNC
580 */
581 HWTEST_F(FlutterTest, Flutter_window02, TestSize.Level1)
582 {
583 /**
584 * @tc.steps1: Create a flutterWindow object.
585 */
586 Platform::FlutterWindow flutterWindow(instanceId);
587
588 /**
589 * @tc.steps2: call RequestFrame and SetRootRenderNode.
590 * @tc.expected: Return expected results..
591 */
592 flutterWindow.RequestFrame();
593 flutterWindow.SetRootRenderNode(nullptr);
594 EXPECT_EQ(flutterWindow.instanceId_, 1);
595 }
596
597 /**
598 * @tc.name: Flutter_window03
599 * @tc.desc: Test the operation of flutter
600 * @tc.type: FUNC
601 */
602 HWTEST_F(FlutterTest, Flutter_window03, TestSize.Level1)
603 {
604 /**
605 * @tc.steps1: Create a flutterWindow object.
606 */
607 Platform::FlutterWindow flutterWindow(instanceId);
608
609 /**
610 * @tc.steps2: callback RegisterVsyncCallback.
611 * @tc.expected: Return expected results..
612 */
__anonf0a29e7f0402(uint64_t timestamp, uint32_t frameCount) 613 auto callback = [](uint64_t timestamp, uint32_t frameCount) {
614 test_result = timestamp;
615 };
616 flutterWindow.RegisterVsyncCallback(callback);
617 EXPECT_EQ(test_result, 2);
618
619 /**
620 * @tc.steps3: call OnVsyncCallback with 5.
621 * @tc.expected: expected results test_result = 5.
622 */
623 flutterWindow.OnVsyncCallback(5);
624 EXPECT_EQ(test_result, 5);
625 }
626 } // namespace OHOS::Ace
627