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
18 #include "core/components_ng/manager/display_sync/ui_display_sync.h"
19 #include "core/components_ng/manager/display_sync/ui_display_sync_manager.h"
20 #include "test/mock/core/pipeline/mock_pipeline_context.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 namespace OHOS::Ace::NG {
25
26 constexpr int32_t LOW_FRAME_NUMBER = 30;
27 constexpr int32_t MEDIUM_FRAME_NUMBER = 60;
28
29 class DisplaySyncManagerTestNg : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 };
34
SetUpTestCase()35 void DisplaySyncManagerTestNg::SetUpTestCase()
36 {
37 MockPipelineContext::SetUp();
38 }
39
TearDownTestCase()40 void DisplaySyncManagerTestNg::TearDownTestCase()
41 {
42 MockPipelineContext::TearDown();
43 }
44
45 /**
46 * @tc.name: DisplaySyncManagerTest001
47 * @tc.desc: DisplaySyncManager adds and deletes a DisplaySync.
48 * @tc.type: FUNC
49 */
50 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest001, TestSize.Level1)
51 {
52 /**
53 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
54 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
55 */
56 auto pipeline = PipelineContext::GetCurrentContext();
57 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
58
59 int32_t initSize = 0;
60 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
61
62 /**
63 * @tc.steps: step2. Construct DisplaySync and set the callback function and expected frame rate.
64 */
65 RefPtr<UIDisplaySync> displaySync = AceType::MakeRefPtr<UIDisplaySync>();
__anonc265d7230102() 66 displaySync->RegisterOnFrame([] () {});
67 displaySync->SetExpectedFrameRateRange({0, 120, 60});
68
69 /**
70 * @tc.steps: step3. Add a DisplaySync to DisplaySyncManager for management.
71 */
72 displaySync->AddToPipelineOnContainer();
73 EXPECT_FALSE(displaySyncManager->AddDisplaySync(displaySync));
74
75 /**
76 * @tc.steps: step4. Check whether DisplaySync is added to the DisplaySyncManager and whether the
77 * number of DisplaySync to be managed is correct.
78 */
79 int32_t capacity1 = displaySyncManager->GetUIDisplaySyncMap().size();
80 EXPECT_EQ(initSize + 1, capacity1);
81
82 bool isExisted1 = displaySyncManager->HasDisplaySync(displaySync);
83 EXPECT_TRUE(isExisted1);
84
85 /**
86 * @tc.steps: step5. Remove DisplaySync from DisplaySyncManager.
87 */
88 EXPECT_TRUE(displaySyncManager->RemoveDisplaySync(displaySync));
89 displaySync->DelFromPipelineOnContainer();
90 EXPECT_FALSE(displaySyncManager->RemoveDisplaySync(displaySync));
91
92 /**
93 * @tc.steps: step6. Check whether DisplaySync is added to the DisplaySyncManager and whether the
94 * number of DisplaySync to be managed is correct.
95 */
96 int32_t capacity2 = displaySyncManager->GetUIDisplaySyncMap().size();
97 EXPECT_EQ(initSize, capacity2);
98
99 bool isExisted2 = displaySyncManager->HasDisplaySync(displaySync);
100 EXPECT_FALSE(isExisted2);
101
102 displaySync = nullptr;
103 EXPECT_FALSE(displaySyncManager->HasDisplaySync(displaySync));
104 }
105
106 /**
107 * @tc.name: DisplaySyncManagerTest002
108 * @tc.desc: DisplaySyncManager adds and deletes multiple DisplaySync.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest002, TestSize.Level1)
112 {
113 /**
114 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
115 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
116 */
117 auto pipeline = PipelineContext::GetCurrentContext();
118 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
119
120 int32_t initSize = 0;
121 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
122
123 /**
124 * @tc.steps: step2. Construct three DisplaySync and set the callback function and expected frame rate.
125 */
126 RefPtr<UIDisplaySync> displaySync1 = AceType::MakeRefPtr<UIDisplaySync>();
__anonc265d7230202() 127 displaySync1->RegisterOnFrame([] () {});
128 displaySync1->SetExpectedFrameRateRange({0, 120, 60});
129
130 RefPtr<UIDisplaySync> displaySync2 = AceType::MakeRefPtr<UIDisplaySync>();
__anonc265d7230302() 131 displaySync2->RegisterOnFrame([] () {});
132 displaySync2->SetExpectedFrameRateRange({0, 120, 60});
133
134 RefPtr<UIDisplaySync> displaySync3 = AceType::MakeRefPtr<UIDisplaySync>();
__anonc265d7230402() 135 displaySync3->RegisterOnFrame([] () {});
136 displaySync3->SetExpectedFrameRateRange({0, 120, 60});
137
138 /**
139 * @tc.steps: step3. Add a DisplaySync to DisplaySyncManager for management.
140 */
141 displaySync1->AddToPipelineOnContainer();
142 displaySync2->AddToPipelineOnContainer();
143 displaySync3->AddToPipelineOnContainer();
144
145 /**
146 * @tc.steps: step4. Check whether DisplaySync is added to the DisplaySyncManager and whether the
147 * number of DisplaySync to be managed is correct.
148 */
149 int32_t capacity1 = displaySyncManager->GetUIDisplaySyncMap().size();
150 EXPECT_EQ(initSize + 3, capacity1);
151
152 bool isExisted1 = displaySyncManager->HasDisplaySync(displaySync1);
153 EXPECT_TRUE(isExisted1);
154
155 bool isExisted2 = displaySyncManager->HasDisplaySync(displaySync2);
156 EXPECT_TRUE(isExisted2);
157
158 bool isExisted3 = displaySyncManager->HasDisplaySync(displaySync3);
159 EXPECT_TRUE(isExisted3);
160
161 /**
162 * @tc.steps: step5. Remove a DisplaySync from DisplaySyncManager.
163 */
164 displaySync2->DelFromPipelineOnContainer();
165
166 /**
167 * @tc.steps: step6. Check whether DisplaySync is added to the DisplaySyncManager and whether the
168 * number of DisplaySync to be managed is correct.
169 */
170 int32_t capacity2 = displaySyncManager->GetUIDisplaySyncMap().size();
171 EXPECT_EQ(initSize + 2, capacity2);
172
173 bool isExisted4 = displaySyncManager->HasDisplaySync(displaySync2);
174 EXPECT_FALSE(isExisted4);
175
176 /**
177 * @tc.steps: step7. Remove two DisplaySync from DisplaySyncManager.
178 */
179 displaySync1->DelFromPipelineOnContainer();
180 displaySync3->DelFromPipelineOnContainer();
181
182 /**
183 * @tc.steps: step8. Check whether DisplaySync is added to the DisplaySyncManager and whether the
184 * number of DisplaySync to be managed is correct.
185 */
186 int32_t capacity3 = displaySyncManager->GetUIDisplaySyncMap().size();
187 EXPECT_EQ(initSize, capacity3);
188
189 bool isExisted5 = displaySyncManager->HasDisplaySync(displaySync1);
190 EXPECT_FALSE(isExisted5);
191
192 bool isExisted6 = displaySyncManager->HasDisplaySync(displaySync3);
193 EXPECT_FALSE(isExisted6);
194 }
195
196 /**
197 * @tc.name: DisplaySyncManagerTest003
198 * @tc.desc: DisplaySync call callback function.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest003, TestSize.Level1)
202 {
203 /**
204 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
205 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
206 */
207 auto pipeline = PipelineContext::GetCurrentContext();
208 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
209
210 int32_t initSize = 0;
211 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
212
213 /**
214 * @tc.steps: step2. Construct DisplaySync and set the callback function and expected frame rate.
215 */
216 int32_t count = 0;
217 int32_t countCopy = count;
218 RefPtr<UIDisplaySync> displaySync = AceType::MakeRefPtr<UIDisplaySync>();
__anonc265d7230502() 219 displaySync->RegisterOnFrame([&count] () {
220 count++;
221 });
222 displaySync->SetExpectedFrameRateRange({0, 120, 60});
223
224 displaySync->AddToPipelineOnContainer();
225
226 /**
227 * @tc.steps: step3. DisplaySync call the callback function.
228 */
229 int32_t onFrameTimes = 5;
230
231 for (int32_t i = 0; i < onFrameTimes; ++i) {
232 displaySync->OnFrame();
233 }
234
235 /**
236 * @tc.steps: step4. Check the count value and remove DisplaySync from DisplaySyncManager.
237 * @tc.expected: step4. Check whether the computed count involved in the callback function is correct.
238 */
239 EXPECT_EQ(countCopy + onFrameTimes, count);
240 displaySync->DelFromPipelineOnContainer();
241 }
242
243 /**
244 * @tc.name: DisplaySyncManagerTest004
245 * @tc.desc: DisplaySyncManager sets the frame rate of the pipeline.
246 * @tc.type: FUNC
247 */
248 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest004, TestSize.Level1)
249 {
250 /**
251 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
252 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
253 */
254 auto pipeline = PipelineContext::GetCurrentContext();
255 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
256
257 int32_t initSize = 0;
258 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
259
260 /**
261 * @tc.steps: step2. Set the valid frame rate (A) of the DisplaySyncManager currently applied.
262 * @tc.expected: step2. The current frame rate should be equal to frame rate (A).
263 */
264 int32_t vsyncRate1 = 72;
265 displaySyncManager->SetVsyncRate(vsyncRate1);
266 EXPECT_EQ(vsyncRate1, displaySyncManager->GetVsyncRate());
267
268 /**
269 * @tc.steps: step3. Set the valid frame rate (B) of the DisplaySyncManager currently applied.
270 * @tc.expected: step3. The current frame rate should be equal to frame rate (B).
271 */
272 int32_t vsyncRate2 = 120;
273 displaySyncManager->SetVsyncRate(vsyncRate2);
274 EXPECT_EQ(vsyncRate2, displaySyncManager->GetVsyncRate());
275
276 /**
277 * @tc.steps: step4. Set the invalid frame rate (C) of the DisplaySyncManager currently applied.
278 * @tc.expected: step4. The current frame rate should be equal to frame rate (B).
279 */
280 int32_t vsyncRate3 = -10;
281 displaySyncManager->SetVsyncRate(vsyncRate3);
282 EXPECT_EQ(vsyncRate2, displaySyncManager->GetVsyncRate());
283 }
284
285 /**
286 * @tc.name: DisplaySyncManagerTest005
287 * @tc.desc: DisplaySyncManager sets the vsync period of the pipeline.
288 * @tc.type: FUNC
289 */
290 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest005, TestSize.Level1)
291 {
292 /**
293 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
294 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
295 */
296 auto pipeline = PipelineContext::GetCurrentContext();
297 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
298
299 int32_t initSize = 0;
300 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
301
302 /**
303 * @tc.steps: step2. Set the valid vsync period (A) of the DisplaySyncManager currently applied.
304 * @tc.expected: step2. The vsync period should be equal to vsync period (A).
305 */
306 int64_t vsyncPeriod1 = 16666667;
307 displaySyncManager->SetVsyncPeriod(vsyncPeriod1);
308 EXPECT_EQ(vsyncPeriod1, displaySyncManager->GetVsyncPeriod());
309 EXPECT_FALSE(displaySyncManager->SetVsyncPeriod(vsyncPeriod1));
310
311 /**
312 * @tc.steps: step3. Set the valid vsync period (B) of the DisplaySyncManager currently applied.
313 * @tc.expected: step3. The vsync period should be equal to vsync period (B).
314 */
315 int64_t vsyncPeriod2 = 16666677;
316 displaySyncManager->SetVsyncPeriod(vsyncPeriod2);
317 EXPECT_EQ(vsyncPeriod2, displaySyncManager->GetVsyncPeriod());
318
319 /**
320 * @tc.steps: step4. Set the invalid vsync period (C) of the DisplaySyncManager currently applied.
321 * @tc.expected: step4. The vsync period should be equal to vsync period (C).
322 */
323 int64_t vsyncPeriod3 = -10;
324 displaySyncManager->SetVsyncPeriod(vsyncPeriod3);
325 EXPECT_EQ(vsyncPeriod2, displaySyncManager->GetVsyncPeriod());
326 EXPECT_TRUE(displaySyncManager->SetVsyncPeriod(10));
327 }
328
329 /**
330 * @tc.name: DisplaySyncManagerTest006
331 * @tc.desc: DisplaySyncManager sets the refresh rate mode of the pipeline.
332 * @tc.type: FUNC
333 */
334 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest006, TestSize.Level1)
335 {
336 /**
337 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
338 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
339 */
340 auto pipeline = PipelineContext::GetCurrentContext();
341 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
342
343 int32_t initSize = 0;
344 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
345
346 /**
347 * @tc.steps: step2. Set the valid refresh rate mode (B) of the DisplaySyncManager currently applied.
348 * @tc.expected: step2. The refresh rate mode should be equal to refresh rate mode (A).
349 */
350 int32_t refreshRateMode1 = 1;
351 displaySyncManager->SetRefreshRateMode(refreshRateMode1);
352 EXPECT_EQ(refreshRateMode1, displaySyncManager->GetRefreshRateMode());
353 EXPECT_FALSE(displaySyncManager->SetRefreshRateMode(refreshRateMode1));
354
355 /**
356 * @tc.steps: step3. Set the valid refresh rate mode (B) of the DisplaySyncManager currently applied.
357 * @tc.expected: step3. The refresh rate mode should be equal to refresh rate mode (B).
358 */
359 int32_t refreshRateMode2 = -1;
360 displaySyncManager->SetRefreshRateMode(refreshRateMode2);
361 EXPECT_EQ(refreshRateMode2, displaySyncManager->GetRefreshRateMode());
362
363 /**
364 * @tc.steps: step4. Set the invalid refresh rate mode (C) of the DisplaySyncManager currently applied.
365 * @tc.expected: step4. The refresh rate mode should be equal to refresh rate mode (B).
366 */
367 int32_t refreshRateMode3 = -10;
368 displaySyncManager->SetRefreshRateMode(refreshRateMode3);
369 EXPECT_EQ(refreshRateMode2, displaySyncManager->GetRefreshRateMode());
370 }
371
372 /**
373 * @tc.name: DisplaySyncManagerTest007
374 * @tc.desc: DisplaySyncManager determines the DisplaySync frame rate on the UI, excluding invalid frame rate.
375 * @tc.type: FUNC
376 */
377 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest007, TestSize.Level1)
378 {
379 /**
380 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
381 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
382 */
383 auto pipeline = PipelineContext::GetCurrentContext();
384 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
385 int32_t initSize = 0;
386 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
387
388 /**
389 * @tc.steps: step2. Construct DisplaySync and set the callback function and different expected frame rate.
390 */
391 uint64_t nanoTimestamp = 0;
392 RefPtr<UIDisplaySync> displaySync1 = AceType::MakeRefPtr<UIDisplaySync>();
393 displaySync1->SetExpectedFrameRateRange({0, 120, 30});
394 displaySync1->AddToPipelineOnContainer();
395
396 RefPtr<UIDisplaySync> displaySync2 = AceType::MakeRefPtr<UIDisplaySync>();
397 displaySync2->SetExpectedFrameRateRange({0, 120, 60});
398 displaySync2->AddToPipelineOnContainer();
399
400 /**
401 * @tc.steps: step3. DisplaySyncManager do distribution and decision operations.
402 */
403 displaySyncManager->DispatchFunc(nanoTimestamp);
404 int32_t displaySyncRate1 = displaySyncManager->GetDisplaySyncRate();
405 EXPECT_EQ(60, displaySyncRate1);
406
407 int32_t monitorSyncRate = displaySyncManager->GetMonitorVsyncRate();
408 EXPECT_TRUE(monitorSyncRate == MEDIUM_FRAME_NUMBER || monitorSyncRate == LOW_FRAME_NUMBER);
409
410 displaySync2->DelFromPipelineOnContainer();
411 displaySyncManager->DispatchFunc(nanoTimestamp);
412 int32_t displaySyncRate2 = displaySyncManager->GetDisplaySyncRate();
413
414 /**
415 * @tc.steps: step4. Check the decision frame rate in DisplaySyncManager.
416 * @tc.expected: step4. The decision frame rate should be equal to the maximum valid frame rate.
417 */
418 EXPECT_EQ(30, displaySyncRate2);
419
420 monitorSyncRate = displaySyncManager->GetMonitorVsyncRate();
421 EXPECT_TRUE(monitorSyncRate == MEDIUM_FRAME_NUMBER || monitorSyncRate == LOW_FRAME_NUMBER);
422
423 displaySync1->DelFromPipelineOnContainer();
424 displaySyncManager->DispatchFunc(nanoTimestamp);
425 int32_t displaySyncRate3 = displaySyncManager->GetDisplaySyncRate();
426
427 EXPECT_EQ(0, displaySyncRate3);
428
429 monitorSyncRate = displaySyncManager->GetMonitorVsyncRate();
430 EXPECT_EQ(displaySyncManager->GetVsyncRate(), monitorSyncRate);
431 }
432
433 /**
434 * @tc.name: DisplaySyncManagerTest008
435 * @tc.desc: DisplaySyncManager determines the DisplaySync frame rate on the UI, including invalid frame rate.
436 * @tc.type: FUNC
437 */
438 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest008, TestSize.Level1)
439 {
440 /**
441 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
442 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
443 */
444 auto pipeline = PipelineContext::GetCurrentContext();
445 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
446 int32_t initSize = 0;
447 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
448
449 /**
450 * @tc.steps: step2. Construct DisplaySync and set the callback function and different expected frame rate.
451 */
452 uint64_t nanoTimestamp = 0;
453 RefPtr<UIDisplaySync> displaySync1 = AceType::MakeRefPtr<UIDisplaySync>();
454 displaySync1->SetExpectedFrameRateRange({0, 10, 30});
455 displaySync1->AddToPipelineOnContainer();
456
457 RefPtr<UIDisplaySync> displaySync2 = AceType::MakeRefPtr<UIDisplaySync>();
458 displaySync2->SetExpectedFrameRateRange({0, 120, 60});
459 displaySync2->AddToPipelineOnContainer();
460
461 /**
462 * @tc.steps: step3. DisplaySyncManager do distribution and decision operations.
463 */
464 displaySyncManager->DispatchFunc(nanoTimestamp);
465 int32_t displaySyncRate1 = displaySyncManager->GetDisplaySyncRate();
466 EXPECT_EQ(60, displaySyncRate1);
467
468 displaySync2->DelFromPipelineOnContainer();
469 displaySyncManager->DispatchFunc(nanoTimestamp);
470 int32_t displaySyncRate2 = displaySyncManager->GetDisplaySyncRate();
471 EXPECT_EQ(nanoTimestamp, displaySync1->GetTimestampData());
472 EXPECT_NE(nanoTimestamp, displaySync1->GetTargetTimestampData());
473
474 /**
475 * @tc.steps: step4. Check the decision frame rate in DisplaySyncManager.
476 * @tc.expected: step4. The decision frame rate should be equal to the maximum valid frame rate.
477 */
478 EXPECT_EQ(0, displaySyncRate2);
479
480 displaySync1->DelFromPipelineOnContainer();
481 displaySyncManager->DispatchFunc(nanoTimestamp);
482 int32_t displaySyncRate3 = displaySyncManager->GetDisplaySyncRate();
483
484 EXPECT_EQ(0, displaySyncRate3);
485 }
486
487 /**
488 * @tc.name: DisplaySyncManagerTest009
489 * @tc.desc: DisplaySync registers and unregisters callback functions, and sets refreshrate mode.
490 * @tc.type: FUNC
491 */
492 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest009, TestSize.Level1)
493 {
494 /**
495 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
496 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
497 */
498 auto pipeline = PipelineContext::GetCurrentContext();
499 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
500 int32_t initSize = 0;
501 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
502
503 /**
504 * @tc.steps: step2. Construct DisplaySync and add the DisplaySync to DisplaySyncManager.
505 */
506 RefPtr<UIDisplaySync> displaySync = AceType::MakeRefPtr<UIDisplaySync>();
507 displaySync->AddToPipelineOnContainer();
508 EXPECT_TRUE(displaySync->IsOnPipeline());
509
510 /**
511 * @tc.steps: step3. Register different callback functions.
512 */
__anonc265d7230602() 513 displaySync->RegisterOnFrame([]() {});
__anonc265d7230702(RefPtr<DisplaySyncData> data) 514 displaySync->RegisterOnFrameWithData([](RefPtr<DisplaySyncData> data) {});
__anonc265d7230802(uint64_t timestamp) 515 displaySync->RegisterOnFrameWithTimestamp([](uint64_t timestamp) {});
516
517 int32_t onFrameTimes = 5;
518 for (int32_t i = 0; i < onFrameTimes; ++i) {
519 displaySync->OnFrame();
520 }
521
522 /**
523 * @tc.steps: step4. Unregister callback functions.
524 */
525 displaySync->UnregisterOnFrame();
526 EXPECT_EQ(nullptr, displaySync->GetDisplaySyncData()->onFrame_);
527 EXPECT_EQ(nullptr, displaySync->GetDisplaySyncData()->onFrameWithData_);
528 EXPECT_EQ(nullptr, displaySync->GetDisplaySyncData()->onFrameWithTimestamp_);
529
530 /**
531 * @tc.steps: step5. Set refreshrate mode.
532 */
533 displaySync->SetRefreshRateMode(0);
534 EXPECT_TRUE(displaySync->IsNonAutoRefreshRateMode());
535 EXPECT_FALSE(displaySync->IsAutoRefreshRateMode());
536 EXPECT_TRUE(displaySyncManager->IsSupportSkip());
537 EXPECT_FALSE(displaySyncManager->IsNonAutoRefreshRateMode());
538
539 /**
540 * @tc.steps: step6. Remove the DisplaySync from DisplaySyncManager.
541 */
542 displaySync->DelFromPipelineOnContainer();
543 EXPECT_FALSE(displaySync->IsOnPipeline());
544 }
545
546 /**
547 * @tc.name: DisplaySyncManagerTest010
548 * @tc.desc: DisplaySync FindMatchedRefreshRate and SearchMatchedRate.
549 * @tc.type: FUNC
550 */
551 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest010, TestSize.Level1)
552 {
553 /**
554 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
555 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
556 */
557 auto pipeline = PipelineContext::GetCurrentContext();
558 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
559 int32_t initSize = 0;
560 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
561
562 /**
563 * @tc.steps: step2. Test FindMatchedRefreshRate function of DisplaySyncManager.
564 */
565 displaySyncManager->FindAllRefreshRateFactors();
566 int32_t matchedRefreshRate1 = displaySyncManager->FindMatchedRefreshRate(65);
567 EXPECT_EQ(60, matchedRefreshRate1);
568
569 int32_t matchedRefreshRate2 = displaySyncManager->FindMatchedRefreshRate(68);
570 EXPECT_EQ(72, matchedRefreshRate2);
571
572 int32_t matchedRefreshRate3 = displaySyncManager->FindMatchedRefreshRate(121);
573 EXPECT_EQ(120, matchedRefreshRate3);
574
575 /**
576 * @tc.steps: step3. Test SearchMatchedRate function of DisplaySync.
577 */
578 RefPtr<UIDisplaySync> displaySync = AceType::MakeRefPtr<UIDisplaySync>();
579 displaySync->AddToPipelineOnContainer();
580 EXPECT_TRUE(displaySync->IsOnPipeline());
581
582 int32_t matchedRate = displaySync->FindMatchedRefreshRate(120, 70);
583 EXPECT_EQ(60, matchedRate);
584
585 displaySync->SetExpectedFrameRateRange({0, 120, 60});
586 int32_t matchedRate1 = displaySync->SearchMatchedRate(90);
587 EXPECT_EQ(90, matchedRate1);
588
589 displaySync->SetExpectedFrameRateRange({30, 60, 60});
590 int32_t matchedRate2 = displaySync->SearchMatchedRate(90);
591 EXPECT_EQ(45, matchedRate2);
592
593 /**
594 * @tc.steps: step4. Remove the DisplaySync from DisplaySyncManager.
595 */
596 displaySync->DelFromPipelineOnContainer();
597 EXPECT_FALSE(displaySync->IsOnPipeline());
598 }
599
600 /**
601 * @tc.name: DisplaySyncManagerTest011
602 * @tc.desc: Test DisplaySync's animator status.
603 * @tc.type: FUNC
604 */
605 HWTEST_F(DisplaySyncManagerTestNg, DisplaySyncManagerTest011, TestSize.Level1)
606 {
607 /**
608 * @tc.steps: step1. Get DisplaySyncManager from PipelineContext.
609 * @tc.expected: step1. Check the number of DisplaySync initially managed by the DisplaySyncManager is 0.
610 */
611 auto pipeline = PipelineContext::GetCurrentContext();
612 auto displaySyncManager = pipeline->GetOrCreateUIDisplaySyncManager();
613 int32_t initSize = 0;
614 EXPECT_EQ(initSize, displaySyncManager->GetUIDisplaySyncMap().size());
615
616 /**
617 * @tc.steps: step2. Test SearchMatchedRate function of DisplaySync.
618 */
619 RefPtr<UIDisplaySync> displaySync = AceType::MakeRefPtr<UIDisplaySync>();
620 displaySync->AddToPipelineOnContainer();
621 EXPECT_TRUE(displaySync->IsOnPipeline());
622
623 /**
624 * @tc.steps: step3. Test DisplaySync's animator status.
625 */
626 int32_t mgrAnimatorRate = displaySyncManager->GetAnimatorRate();
627 EXPECT_EQ(-1, mgrAnimatorRate);
628 EXPECT_TRUE(displaySyncManager->IsAnimatorStopped());
629 int32_t animatorExpectedRate = displaySync->GetAnimatorExpectedRate();
630 EXPECT_EQ(-1, animatorExpectedRate);
631
__anonc265d7230902(uint64_t timestamp) 632 displaySync->RegisterOnFrameWithTimestamp([](uint64_t timestamp) {});
633 mgrAnimatorRate = displaySyncManager->GetAnimatorRate();
634 EXPECT_EQ(0, mgrAnimatorRate);
635 EXPECT_FALSE(displaySyncManager->IsAnimatorStopped());
636 animatorExpectedRate = displaySync->GetAnimatorExpectedRate();
637 EXPECT_EQ(0, animatorExpectedRate);
638
639 displaySync->SetExpectedFrameRateRange({0, 120, 60});
640 mgrAnimatorRate = displaySyncManager->GetAnimatorRate();
641 EXPECT_EQ(60, mgrAnimatorRate);
642 EXPECT_FALSE(displaySyncManager->IsAnimatorStopped());
643 animatorExpectedRate = displaySync->GetAnimatorExpectedRate();
644 EXPECT_EQ(60, animatorExpectedRate);
645
646 /**
647 * @tc.steps: step4. Remove the DisplaySync from DisplaySyncManager.
648 */
649 displaySync->DelFromPipelineOnContainer();
650 EXPECT_FALSE(displaySync->IsOnPipeline());
651 }
652 } // namespace OHOS::Ace::NG
653