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