1 /*
2 * Copyright (c) 2021 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 "vsync_generator.h"
17 #include "vsync_controller.h"
18 #include "vsync_distributor.h"
19 #include "vsync_receiver.h"
20 #include "vsync_iconnection_token.h"
21 #include <event_handler.h>
22
23 #include <gtest/gtest.h>
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
SystemTime()30 static int64_t SystemTime()
31 {
32 timespec t = {};
33 clock_gettime(CLOCK_MONOTONIC, &t);
34 return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s
35 }
36
37 class VSyncGeneratorTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
OnVSync(int64_t now,void * data)41 static inline void OnVSync(int64_t now, void* data) {}
42
43 static inline sptr<VSyncGenerator> vsyncGenerator_;
44 static constexpr const int32_t WAIT_SYSTEM_ABILITY_REPORT_DATA_SECONDS = 5;
45 static inline sptr<VSyncController> appController;
46 static inline sptr<VSyncController> rsController;
47 static inline sptr<VSyncDistributor> appDistributor;
48 static inline sptr<VSyncDistributor> rsDistributor;
49 static inline std::shared_ptr<VSyncReceiver> receiver;
50 static inline std::shared_ptr<AppExecFwk::EventRunner> runner_ = nullptr;
51 static inline std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr;
52 };
53
SetUpTestCase()54 void VSyncGeneratorTest::SetUpTestCase()
55 {
56 vsyncGenerator_ = CreateVSyncGenerator();
57 appController = new VSyncController(vsyncGenerator_, 0);
58 rsController = new VSyncController(vsyncGenerator_, 0);
59 appDistributor = new VSyncDistributor(appController, "app");
60 rsDistributor = new VSyncDistributor(rsController, "rs");
61 vsyncGenerator_->SetRSDistributor(rsDistributor);
62 vsyncGenerator_->SetAppDistributor(appDistributor);
63 sptr<VSyncIConnectionToken> token = new IRemoteStub<VSyncIConnectionToken>();
64 sptr<VSyncConnection> conn = new VSyncConnection(rsDistributor, "generator_test", token->AsObject());
65 rsDistributor->AddConnection(conn);
66 runner_ = AppExecFwk::EventRunner::Create(false);
67 handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
68 receiver = std::make_shared<VSyncReceiver>(conn, token->AsObject(), handler_, "generator_test");
69 receiver->Init();
70 }
71
TearDownTestCase()72 void VSyncGeneratorTest::TearDownTestCase()
73 {
74 sleep(WAIT_SYSTEM_ABILITY_REPORT_DATA_SECONDS);
75 vsyncGenerator_ = nullptr;
76 DestroyVSyncGenerator();
77 receiver->looper_->RemoveFileDescriptorListener(receiver->fd_);
78 receiver->looper_ = nullptr;
79 receiver->fd_ = -1;
80 }
81
82 class VSyncGeneratorTestCallback : public VSyncGenerator::Callback {
83 public:
84 void OnVSyncEvent(int64_t now, int64_t period,
85 uint32_t refreshRate, VSyncMode vsyncMode, uint32_t vsyncMaxRefreshRate) override;
86 void OnPhaseOffsetChanged(int64_t phaseOffset) override;
87 void OnConnsRefreshRateChanged(const std::vector<std::pair<uint64_t, uint32_t>> &refreshRates) override;
88 };
89
OnVSyncEvent(int64_t now,int64_t period,uint32_t refreshRate,VSyncMode vsyncMode,uint32_t vsyncMaxRefreshRate)90 void VSyncGeneratorTestCallback::OnVSyncEvent(int64_t now, int64_t period,
91 uint32_t refreshRate, VSyncMode vsyncMode, uint32_t vsyncMaxRefreshRate)
92 {
93 }
94
OnPhaseOffsetChanged(int64_t phaseOffset)95 void VSyncGeneratorTestCallback::OnPhaseOffsetChanged(int64_t phaseOffset)
96 {
97 }
98
OnConnsRefreshRateChanged(const std::vector<std::pair<uint64_t,uint32_t>> & refreshRates)99 void VSyncGeneratorTestCallback::OnConnsRefreshRateChanged(
100 const std::vector<std::pair<uint64_t, uint32_t>> &refreshRates)
101 {
102 }
103
104 namespace {
105 /*
106 * Function: CheckAndUpdateReferenceTimeTest001
107 * Type: Function
108 * Rank: Important(2)
109 * EnvConditions: N/A
110 * CaseDescription: 1. Test CheckAndUpdateReferenceTime
111 */
112 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest001, Function | MediumTest| Level0)
113 {
114 ASSERT_EQ(vsyncGenerator_->CheckAndUpdateReferenceTime(-1, -1), VSYNC_ERROR_INVALID_ARGUMENTS);
115 // 2000000000ns
116 ASSERT_EQ(vsyncGenerator_->CheckAndUpdateReferenceTime(-1, 2000000000), VSYNC_ERROR_INVALID_ARGUMENTS);
117 ASSERT_EQ(vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, -1), VSYNC_ERROR_INVALID_ARGUMENTS); // 8333333ns
118 // 8333333ns, 2000000000ns
119 ASSERT_EQ(vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, 2000000000), VSYNC_ERROR_API_FAILED);
120 }
121
122 /*
123 * Function: CheckAndUpdateReferenceTimeTest002
124 * Type: Function
125 * Rank: Important(2)
126 * EnvConditions: N/A
127 * CaseDescription: 1. Test CheckAndUpdateReferenceTime
128 */
129 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest002, Function | MediumTest| Level0)
130 {
131 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
132 ASSERT_EQ(ret, VSYNC_ERROR_OK);
133 vsyncGenerator_->SetPendingMode(16666667, 1000000000); // 16666667ns, 1000000000ns
134 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000); // 8333333ns, 1000000000ns
135 ASSERT_EQ(ret, VSYNC_ERROR_OK);
136 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
137 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
138 int64_t refreshRate = 120; // 120hz
139 int64_t rsVsyncCount = 0;
140 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
141 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
142 ASSERT_EQ(ret, VSYNC_ERROR_OK);
143 usleep(100000); // 100000us
144 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, 2000000000); // 8333333ns, 2000000000ns
145 ASSERT_EQ(ret, VSYNC_ERROR_OK);
146 }
147
148 /*
149 * Function: CheckAndUpdateReferenceTimeTest003
150 * Type: Function
151 * Rank: Important(2)
152 * EnvConditions: N/A
153 * CaseDescription: 1. Test CheckAndUpdateReferenceTime
154 */
155 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest003, Function | MediumTest| Level0)
156 {
157 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
158 ASSERT_EQ(ret, VSYNC_ERROR_OK);
159 vsyncGenerator_->SetPendingMode(8333333, 1000000000); // 8333333ns, 1000000000ns
160 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000); // 8333333ns, 1000000000ns
161 ASSERT_EQ(ret, VSYNC_ERROR_OK);
162 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
163 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
164 int64_t refreshRate = 60; // 60hz
165 int64_t rsVsyncCount = 0;
166 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
167 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
168 ASSERT_EQ(ret, VSYNC_ERROR_OK);
169 VSyncReceiver::FrameCallback fcb = {
170 .userData_ = this,
171 .callback_ = OnVSync,
172 };
173 ret = receiver->RequestNextVSync(fcb);
174 ASSERT_EQ(ret, VSYNC_ERROR_OK);
175 usleep(100000); // 100000us
176 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, 2000000000); // 8333333ns, 2000000000ns
177 ASSERT_EQ(ret, VSYNC_ERROR_OK);
178 }
179
180 /*
181 * Function: CheckAndUpdateReferenceTimeTest004
182 * Type: Function
183 * Rank: Important(2)
184 * EnvConditions: N/A
185 * CaseDescription: 1. Test CheckAndUpdateReferenceTime
186 */
187 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest004, Function | MediumTest| Level0)
188 {
189 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
190 ASSERT_EQ(ret, VSYNC_ERROR_OK);
191 vsyncGenerator_->SetPendingMode(16666667, 1000000000); // 16666667ns, 1000000000ns
192 int64_t refreshRate = 120; // 120hz
193 int64_t rsVsyncCount = 0;
194 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
195 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
196 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
197 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
198 ASSERT_EQ(ret, VSYNC_ERROR_OK);
199 VSyncReceiver::FrameCallback fcb = {
200 .userData_ = this,
201 .callback_ = OnVSync,
202 };
203 ret = receiver->RequestNextVSync(fcb);
204 ASSERT_EQ(ret, VSYNC_ERROR_OK);
205 usleep(100000); // 100000us
206 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000); // 8333333ns, 1000000000ns
207 ASSERT_EQ(ret, VSYNC_ERROR_OK);
208 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, 2000000000); // 8333333ns, 2000000000ns
209 ASSERT_EQ(ret, VSYNC_ERROR_OK);
210 }
211
212 /*
213 * Function: CheckAndUpdateReferenceTimeTest005
214 * Type: Function
215 * Rank: Important(2)
216 * EnvConditions: N/A
217 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and set pendingPeriod_ 8.3ms
218 */
219 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest005, Function | MediumTest| Level0)
220 {
221 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
222 ASSERT_EQ(ret, VSYNC_ERROR_OK);
223 vsyncGenerator_->SetPendingMode(8333333, 1000000000); // 8333333ns, 1000000000ns
224 int64_t refreshRate = 120; // 120hz
225 int64_t rsVsyncCount = 0;
226 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
227 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
228 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
229 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
230 ASSERT_EQ(ret, VSYNC_ERROR_OK);
231 VSyncReceiver::FrameCallback fcb = {
232 .userData_ = this,
233 .callback_ = OnVSync,
234 };
235 ret = receiver->RequestNextVSync(fcb);
236 ASSERT_EQ(ret, VSYNC_ERROR_OK);
237 usleep(100000); // 100000us
238 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000); // 8333333ns, 1000000000ns
239 ASSERT_EQ(ret, VSYNC_ERROR_OK);
240 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(8333333, 2000000000); // 8333333ns, 2000000000ns
241 ASSERT_EQ(ret, VSYNC_ERROR_OK);
242 }
243
244 /*
245 * Function: CheckAndUpdateReferenceTimeTest006
246 * Type: Function
247 * Rank: Important(2)
248 * EnvConditions: N/A
249 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and set pendingPeriod_ 11.1ms
250 */
251 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest006, Function | MediumTest| Level0)
252 {
253 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
254 ASSERT_EQ(ret, VSYNC_ERROR_OK);
255 vsyncGenerator_->SetPendingMode(11111111, 1000000000); // 11111111ns, 1000000000ns
256 int64_t refreshRate = 90; // 90hz
257 int64_t rsVsyncCount = 0;
258 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
259 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
260 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
261 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
262 ASSERT_EQ(ret, VSYNC_ERROR_OK);
263 VSyncReceiver::FrameCallback fcb = {
264 .userData_ = this,
265 .callback_ = OnVSync,
266 };
267 ret = receiver->RequestNextVSync(fcb);
268 ASSERT_EQ(ret, VSYNC_ERROR_OK);
269 usleep(100000); // 100000us
270 ret = vsyncGenerator_->UpdateMode(11111111, 0, 1000000000); // 11111111ns, 1000000000ns
271 ASSERT_EQ(ret, VSYNC_ERROR_OK);
272 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(11111111, 2000000000); // 11111111ns, 2000000000ns
273 ASSERT_EQ(ret, VSYNC_ERROR_OK);
274 }
275
276 /*
277 * Function: CheckAndUpdateReferenceTimeTest007
278 * Type: Function
279 * Rank: Important(2)
280 * EnvConditions: N/A
281 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and set pendingPeriod_ 16.6ms
282 */
283 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest007, Function | MediumTest| Level0)
284 {
285 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
286 ASSERT_EQ(ret, VSYNC_ERROR_OK);
287 vsyncGenerator_->SetPendingMode(16666667, 1000000000); // 16666667ns, 1000000000ns
288 int64_t refreshRate = 60; // 60hz
289 int64_t rsVsyncCount = 0;
290 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
291 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
292 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
293 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
294 ASSERT_EQ(ret, VSYNC_ERROR_OK);
295 VSyncReceiver::FrameCallback fcb = {
296 .userData_ = this,
297 .callback_ = OnVSync,
298 };
299 ret = receiver->RequestNextVSync(fcb);
300 ASSERT_EQ(ret, VSYNC_ERROR_OK);
301 usleep(100000); // 100000us
302 ret = vsyncGenerator_->UpdateMode(16666667, 0, 1000000000); // 16666667ns, 1000000000ns
303 ASSERT_EQ(ret, VSYNC_ERROR_OK);
304 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(16666667, 2000000000); // 16666667ns, 2000000000ns
305 ASSERT_EQ(ret, VSYNC_ERROR_OK);
306 }
307
308 /*
309 * Function: CheckAndUpdateReferenceTimeTest008
310 * Type: Function
311 * Rank: Important(2)
312 * EnvConditions: N/A
313 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and set pendingPeriod_ 33.3ms
314 */
315 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest008, Function | MediumTest| Level0)
316 {
317 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
318 ASSERT_EQ(ret, VSYNC_ERROR_OK);
319 vsyncGenerator_->SetPendingMode(33333333, 1000000000); // 33333333ns, 1000000000ns
320 int64_t refreshRate = 30; // 30hz
321 int64_t rsVsyncCount = 0;
322 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
323 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
324 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
325 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
326 ASSERT_EQ(ret, VSYNC_ERROR_OK);
327 VSyncReceiver::FrameCallback fcb = {
328 .userData_ = this,
329 .callback_ = OnVSync,
330 };
331 ret = receiver->RequestNextVSync(fcb);
332 ASSERT_EQ(ret, VSYNC_ERROR_OK);
333 usleep(100000); // 100000us
334 ret = vsyncGenerator_->UpdateMode(33333333, 0, 1000000000); // 33333333ns, 1000000000ns
335 ASSERT_EQ(ret, VSYNC_ERROR_OK);
336 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(33333333, 2000000000); // 33333333ns, 2000000000ns
337 ASSERT_EQ(ret, VSYNC_ERROR_OK);
338 }
339
340 /*
341 * Function: CheckAndUpdateReferenceTimeTest009
342 * Type: Function
343 * Rank: Important(2)
344 * EnvConditions: N/A
345 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and StartRefresh
346 */
347 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest009, Function | MediumTest| Level0)
348 {
349 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
350 ASSERT_EQ(ret, VSYNC_ERROR_OK);
351 vsyncGenerator_->SetPendingMode(33333333, 1000000000); // 33333333ns, 1000000000ns
352 int64_t refreshRate = 30; // 30hz
353 int64_t rsVsyncCount = 0;
354 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
355 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
356 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
357 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
358 ASSERT_EQ(ret, VSYNC_ERROR_OK);
359 VSyncReceiver::FrameCallback fcb = {
360 .userData_ = this,
361 .callback_ = OnVSync,
362 };
363 ret = receiver->RequestNextVSync(fcb);
364 ASSERT_EQ(ret, VSYNC_ERROR_OK);
365 usleep(100000); // 100000us
366 ret = vsyncGenerator_->UpdateMode(33333333, 0, 1000000000); // 33333333ns, 1000000000ns
367 ASSERT_EQ(ret, VSYNC_ERROR_OK);
368 ret = vsyncGenerator_->StartRefresh();
369 ASSERT_EQ(ret, VSYNC_ERROR_OK);
370 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(33333333, 2000000000); // 33333333ns, 2000000000ns
371 ASSERT_EQ(ret, VSYNC_ERROR_OK);
372 }
373
374 /*
375 * Function: CheckAndUpdateReferenceTimeTest010
376 * Type: Function
377 * Rank: Important(2)
378 * EnvConditions: N/A
379 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and SetVSyncPhaseByPulseNum
380 */
381 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest010, Function | MediumTest| Level0)
382 {
383 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
384 ASSERT_EQ(ret, VSYNC_ERROR_OK);
385 vsyncGenerator_->SetPendingMode(33333333, 1000000000); // 33333333ns, 1000000000ns
386 int64_t refreshRate = 30; // 30hz
387 int64_t rsVsyncCount = 0;
388 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
389 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
390 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
391 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
392 ASSERT_EQ(ret, VSYNC_ERROR_OK);
393 VSyncReceiver::FrameCallback fcb = {
394 .userData_ = this,
395 .callback_ = OnVSync,
396 };
397 ret = receiver->RequestNextVSync(fcb);
398 ASSERT_EQ(ret, VSYNC_ERROR_OK);
399 usleep(100000); // 100000us
400 ret = vsyncGenerator_->UpdateMode(33333333, 0, 1000000000); // 33333333ns, 1000000000ns
401 ASSERT_EQ(ret, VSYNC_ERROR_OK);
402 ret = vsyncGenerator_->SetReferenceTimeOffset(1);
403 ASSERT_EQ(ret, VSYNC_ERROR_OK);
404 ret = vsyncGenerator_->SetVSyncPhaseByPulseNum(1);
405 ASSERT_EQ(ret, VSYNC_ERROR_OK);
406 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(33333333, 2000000000); // 33333333ns, 2000000000ns
407 ASSERT_EQ(ret, VSYNC_ERROR_OK);
408 }
409
410 /*
411 * Function: CheckAndUpdateReferenceTimeTest011
412 * Type: Function
413 * Rank: Important(2)
414 * EnvConditions: N/A
415 * CaseDescription: 1. Test CheckAndUpdateReferenceTime and StartRefresh, SetVSyncPhaseByPulseNum
416 */
417 HWTEST_F(VSyncGeneratorTest, CheckAndUpdateReferenceTimeTest011, Function | MediumTest| Level0)
418 {
419 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
420 ASSERT_EQ(ret, VSYNC_ERROR_OK);
421 vsyncGenerator_->SetPendingMode(33333333, 1000000000); // 33333333ns, 1000000000ns
422 int64_t refreshRate = 30; // 30hz
423 int64_t rsVsyncCount = 0;
424 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
425 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
426 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
427 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
428 ASSERT_EQ(ret, VSYNC_ERROR_OK);
429 VSyncReceiver::FrameCallback fcb = {
430 .userData_ = this,
431 .callback_ = OnVSync,
432 };
433 ret = receiver->RequestNextVSync(fcb);
434 ASSERT_EQ(ret, VSYNC_ERROR_OK);
435 usleep(100000); // 100000us
436 ret = vsyncGenerator_->UpdateMode(33333333, 0, 1000000000); // 33333333ns, 1000000000ns
437 ASSERT_EQ(ret, VSYNC_ERROR_OK);
438 ret = vsyncGenerator_->SetReferenceTimeOffset(1);
439 ASSERT_EQ(ret, VSYNC_ERROR_OK);
440 ret = vsyncGenerator_->SetVSyncPhaseByPulseNum(1);
441 ASSERT_EQ(ret, VSYNC_ERROR_OK);
442 ret = vsyncGenerator_->StartRefresh();
443 ASSERT_EQ(ret, VSYNC_ERROR_OK);
444 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(33333333, 2000000000); // 33333333ns, 2000000000ns
445 ASSERT_EQ(ret, VSYNC_ERROR_OK);
446 }
447
448 /*
449 * Function: PeriodCheckLockedTest
450 * Type: Function
451 * Rank: Important(2)
452 * EnvConditions: N/A
453 * CaseDescription: 1. Test PeriodCheckLocked
454 */
455 HWTEST_F(VSyncGeneratorTest, PeriodCheckLockedTest, Function | MediumTest| Level0)
456 {
457 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
458 ASSERT_EQ(ret, VSYNC_ERROR_OK);
459 for (int i = 0; i < 20; i++) { // test 20 times
460 int64_t testPeriod = i < 2 ? 8333333 : 16666667; // 2, 8333333ns, 16666667ns
461 vsyncGenerator_->SetPendingMode(testPeriod, 1000000000); // 1000000000ns
462 int64_t refreshRate = 120; // 120hz
463 int64_t rsVsyncCount = 0;
464 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
465 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
466 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
467 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
468 ASSERT_EQ(ret, VSYNC_ERROR_OK);
469 VSyncReceiver::FrameCallback fcb = {
470 .userData_ = this,
471 .callback_ = OnVSync,
472 };
473 ret = receiver->RequestNextVSync(fcb);
474 ASSERT_EQ(ret, VSYNC_ERROR_OK);
475 usleep(100000); // 100000us
476 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000); // 8333333ns, 1000000000ns
477 ASSERT_EQ(ret, VSYNC_ERROR_OK);
478 ret = vsyncGenerator_->CheckAndUpdateReferenceTime(testPeriod, 2000000000); // 2000000000ns
479 ASSERT_EQ(ret, VSYNC_ERROR_OK);
480 }
481 }
482
483 /*
484 * Function: NowLessThanReferenceTimeTest
485 * Type: Function
486 * Rank: Important(2)
487 * EnvConditions: N/A
488 * CaseDescription: 1. Test now is less than referenceTime
489 */
490 HWTEST_F(VSyncGeneratorTest, NowLessThanReferenceTimeTest, Function | MediumTest| Level0)
491 {
492 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPS);
493 ASSERT_EQ(ret, VSYNC_ERROR_OK);
494 VSyncReceiver::FrameCallback fcb = {
495 .userData_ = this,
496 .callback_ = OnVSync,
497 };
498 ret = receiver->RequestNextVSync(fcb);
499 ASSERT_EQ(ret, VSYNC_ERROR_OK);
500 usleep(100000); // 100000us
501 ASSERT_EQ(vsyncGenerator_->GetVSyncMode(), VSYNC_MODE_LTPS);
502 int64_t refreshRate = 120; // 120hz
503 int64_t rsVsyncCount = 0;
504 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
505 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
506 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
507 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
508 ASSERT_EQ(ret, VSYNC_ERROR_NOT_SUPPORT);
509 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000000000); // 8333333ns, 1000000000000000ns
510 ASSERT_EQ(ret, VSYNC_ERROR_OK);
511 ret = receiver->RequestNextVSync(fcb);
512 ASSERT_EQ(ret, VSYNC_ERROR_OK);
513 usleep(100000); // 100000us
514 }
515
516 /*
517 * Function: ChangeGeneratorRefreshRateModelTest001
518 * Type: Function
519 * Rank: Important(2)
520 * EnvConditions: N/A
521 * CaseDescription: 1. Test ChangeGeneratorRefreshRateModel for LTPO
522 */
523 HWTEST_F(VSyncGeneratorTest, ChangeGeneratorRefreshRateModelTest001, Function | MediumTest| Level0)
524 {
525 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
526 ASSERT_EQ(ret, VSYNC_ERROR_OK);
527 VSyncReceiver::FrameCallback fcb = {
528 .userData_ = this,
529 .callback_ = OnVSync,
530 };
531 ret = receiver->RequestNextVSync(fcb);
532 ASSERT_EQ(ret, VSYNC_ERROR_OK);
533 int64_t refreshRate = 120; // 120hz
534 int64_t rsVsyncCount = 0;
535 std::vector<std::pair<uint64_t, uint32_t>> refreshRates = {};
536 refreshRates.push_back({0, 60});
537 refreshRates.push_back({1, 120});
538 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {
539 .cb = appController,
540 .refreshRates = refreshRates,
541 };
542 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {
543 .cb = rsController,
544 .phaseByPulseNum = 3,
545 };
546 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
547 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
548 ASSERT_EQ(ret, VSYNC_ERROR_OK);
549 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000000); // 8333333ns, 1000000000000ns
550 ASSERT_EQ(ret, VSYNC_ERROR_OK);
551 usleep(100000); // 100000us
552 ASSERT_EQ(vsyncGenerator_->GetVSyncMode(), VSYNC_MODE_LTPO);
553 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
554 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
555 ASSERT_EQ(ret, VSYNC_ERROR_OK);
556 }
557
558 /*
559 * Function: ChangeGeneratorRefreshRateModelTest002
560 * Type: Function
561 * Rank: Important(2)
562 * EnvConditions: N/A
563 * CaseDescription: 1. Test ChangeGeneratorRefreshRateModel for LTPS
564 */
565 HWTEST_F(VSyncGeneratorTest, ChangeGeneratorRefreshRateModelTest002, Function | MediumTest| Level0)
566 {
567 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPS);
568 ASSERT_EQ(ret, VSYNC_ERROR_OK);
569 VSyncReceiver::FrameCallback fcb = {
570 .userData_ = this,
571 .callback_ = OnVSync,
572 };
573 ret = receiver->RequestNextVSync(fcb);
574 ASSERT_EQ(ret, VSYNC_ERROR_OK);
575 usleep(100000); // 100000us
576 ASSERT_EQ(vsyncGenerator_->GetVSyncMode(), VSYNC_MODE_LTPS);
577 int64_t refreshRate = 120; // 120hz
578 int64_t rsVsyncCount = 0;
579 std::vector<std::pair<uint64_t, uint32_t>> refreshRates = {};
580 refreshRates.push_back({0, 60});
581 refreshRates.push_back({1, 120});
582 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {
583 .cb = appController,
584 .refreshRates = refreshRates,
585 };
586 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {
587 .cb = rsController,
588 .phaseByPulseNum = 3,
589 };
590 ret = vsyncGenerator_->ChangeGeneratorRefreshRateModel(
591 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
592 ASSERT_EQ(ret, VSYNC_ERROR_NOT_SUPPORT);
593 ret = vsyncGenerator_->UpdateMode(8333333, 0, 1000000000000); // 8333333ns, 1000000000000ns
594 ASSERT_EQ(ret, VSYNC_ERROR_OK);
595 }
596
597 /*
598 * Function: SetVSyncModeTest
599 * Type: Function
600 * Rank: Important(2)
601 * EnvConditions: N/A
602 * CaseDescription: 1. Test SetVSyncMode and GetVSyncMode
603 */
604 HWTEST_F(VSyncGeneratorTest, SetVSyncModeTest, Function | MediumTest| Level0)
605 {
606 VsyncError ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPS);
607 ASSERT_EQ(ret, VSYNC_ERROR_OK);
608 VSyncReceiver::FrameCallback fcb = {
609 .userData_ = this,
610 .callback_ = OnVSync,
611 };
612 ret = receiver->RequestNextVSync(fcb);
613 ASSERT_EQ(ret, VSYNC_ERROR_OK);
614 usleep(100000); // 100000us
615 ASSERT_EQ(vsyncGenerator_->GetVSyncMode(), VSYNC_MODE_LTPS);
616 ret = vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
617 ASSERT_EQ(ret, VSYNC_ERROR_OK);
618 }
619
620 /*
621 * Function: SetVSyncMaxRefreshRateTest
622 * Type: Function
623 * Rank: Important(2)
624 * EnvConditions: N/A
625 * CaseDescription: 1. Test SetVSyncMaxRefreshRateTest and GetVSyncMaxRefreshRateTest
626 */
627 HWTEST_F(VSyncGeneratorTest, SetVSyncMaxRefreshRateTest, Function | MediumTest| Level0)
628 {
629 // set invalid value 30 smaller than VSYNC_MAX_REFRESHRATE_RANGE_MIN
630 VsyncError ret = vsyncGenerator_->SetVSyncMaxRefreshRate(30);
631 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
632
633 // set invalid value 600 greater than VSYNC_MAX_REFRESHRATE_RANGE_MAX
634 ret = vsyncGenerator_->SetVSyncMaxRefreshRate(600);
635 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
636
637 // set valid value
638 ret = vsyncGenerator_->SetVSyncMaxRefreshRate(240);
639 ASSERT_EQ(ret, VSYNC_ERROR_OK);
640 uint32_t vsyncMaxRefreshRate = vsyncGenerator_->GetVSyncMaxRefreshRate();
641 ASSERT_EQ(vsyncMaxRefreshRate, 240);
642 }
643
644 /*
645 * Function: SetHighPriorityVSyncRateTest
646 * Type: Function
647 * Rank: Important(2)
648 * EnvConditions: N/A
649 * CaseDescription: 1. Test SetHighPriorityVSyncRate
650 */
651 HWTEST_F(VSyncGeneratorTest, SetHighPriorityVSyncRateTest, Function | MediumTest| Level0)
652 {
653 sptr<VSyncConnection> conn = new VSyncConnection(rsDistributor, "SetHighPriorityVSyncRateTest");
654 rsDistributor->AddConnection(conn);
655 VsyncError ret = rsDistributor->SetHighPriorityVSyncRate(2, conn); // rate is 2
656 ASSERT_EQ(ret, VSYNC_ERROR_OK);
657 VSyncReceiver::FrameCallback fcb = {
658 .userData_ = this,
659 .callback_ = OnVSync,
660 };
661 for (int i = 0; i < 10; i++) {
662 ret = receiver->RequestNextVSync(fcb);
663 ASSERT_EQ(ret, VSYNC_ERROR_OK);
664 usleep(10000); // 10000us
665 }
666 usleep(100000); // 100000us
667 }
668
669 /*
670 * Function: UpdateMode001
671 * Type: Function
672 * Rank: Important(2)
673 * EnvConditions: N/A
674 * CaseDescription: 1. call UpdateMode
675 */
676 HWTEST_F(VSyncGeneratorTest, UpdateMode001, Function | MediumTest| Level0)
677 {
678 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, 0), VSYNC_ERROR_OK);
679 }
680
681 /*
682 * Function: UpdateMode002
683 * Type: Function
684 * Rank: Important(2)
685 * EnvConditions: N/A
686 * CaseDescription: 1. call UpdateMode
687 */
688 HWTEST_F(VSyncGeneratorTest, UpdateMode002, Function | MediumTest| Level0)
689 {
690 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, -1), VSYNC_ERROR_INVALID_ARGUMENTS);
691 }
692
693 /*
694 * Function: UpdateMode003
695 * Type: Function
696 * Rank: Important(2)
697 * EnvConditions: N/A
698 * CaseDescription: 1. call UpdateMode
699 */
700 HWTEST_F(VSyncGeneratorTest, UpdateMode003, Function | MediumTest| Level0)
701 {
702 VSyncGeneratorTest::vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
703 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(0, 0, 0), VSYNC_ERROR_OK);
704 // 25000000 is period, refreshRate is 40hz，for JudgeRefreshRateLocked test
705 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(25000000, 0, 0), VSYNC_ERROR_OK);
706 }
707
708 /*
709 * Function: AddListener001
710 * Type: Function
711 * Rank: Important(2)
712 * EnvConditions: N/A
713 * CaseDescription: 1. call AddListener
714 */
715 HWTEST_F(VSyncGeneratorTest, AddListener001, Function | MediumTest| Level0)
716 {
717 sptr<VSyncGeneratorTestCallback> callback1 = new VSyncGeneratorTestCallback;
718 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback1), VSYNC_ERROR_OK);
719 }
720
721 /*
722 * Function: AddListener002
723 * Type: Function
724 * Rank: Important(2)
725 * EnvConditions: N/A
726 * CaseDescription: 1. call AddListener
727 */
728 HWTEST_F(VSyncGeneratorTest, AddListener002, Function | MediumTest| Level0)
729 {
730 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, nullptr), VSYNC_ERROR_INVALID_ARGUMENTS);
731 }
732
733 /*
734 * Function: AddListener003
735 * Type: Function
736 * Rank: Important(2)
737 * EnvConditions: N/A
738 * CaseDescription: 1. call AddListener
739 */
740 HWTEST_F(VSyncGeneratorTest, AddListener003, Function | MediumTest| Level0)
741 {
742 VSyncGeneratorTest::vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
743 VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, 0);
744 sptr<VSyncGeneratorTestCallback> callback = new VSyncGeneratorTestCallback;
745 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback), VSYNC_ERROR_OK);
746 }
747
748 /*
749 * Function: AddListener004
750 * Type: Function
751 * Rank: Important(2)
752 * EnvConditions: N/A
753 * CaseDescription: 1. call AddListener
754 */
755 HWTEST_F(VSyncGeneratorTest, AddListener004, Function | MediumTest| Level0)
756 {
757 auto generatorImpl = static_cast<impl::VSyncGenerator*>(VSyncGeneratorTest::vsyncGenerator_.GetRefPtr());
758 generatorImpl->listeners_.clear();
759 sptr<VSyncGeneratorTestCallback> callback = new VSyncGeneratorTestCallback;
760 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(0, callback), VSYNC_ERROR_OK);
761 ASSERT_EQ(generatorImpl->listeners_.size(), 1);
762 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(0, callback), VSYNC_ERROR_OK);
763 ASSERT_EQ(generatorImpl->listeners_.size(), 1);
764 }
765
766 /*
767 * Function: RemoveListener001
768 * Type: Function
769 * Rank: Important(2)
770 * EnvConditions: N/A
771 * CaseDescription: 1. call RemoveListener
772 */
773 HWTEST_F(VSyncGeneratorTest, RemoveListener001, Function | MediumTest| Level0)
774 {
775 sptr<VSyncGeneratorTestCallback> callback2 = new VSyncGeneratorTestCallback;
776 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback2);
777 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(callback2), VSYNC_ERROR_OK);
778 }
779
780 /*
781 * Function: RemoveListener002
782 * Type: Function
783 * Rank: Important(2)
784 * EnvConditions: N/A
785 * CaseDescription: 1. call RemoveListener
786 */
787 HWTEST_F(VSyncGeneratorTest, RemoveListener002, Function | MediumTest| Level0)
788 {
789 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(nullptr), VSYNC_ERROR_INVALID_ARGUMENTS);
790 }
791
792 /*
793 * Function: RemoveListener003
794 * Type: Function
795 * Rank: Important(2)
796 * EnvConditions: N/A
797 * CaseDescription: 1. call RemoveListener
798 */
799 HWTEST_F(VSyncGeneratorTest, RemoveListener003, Function | MediumTest| Level0)
800 {
801 sptr<VSyncGeneratorTestCallback> callback3 = new VSyncGeneratorTestCallback;
802 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback3);
803 sptr<VSyncGeneratorTestCallback> callback4 = new VSyncGeneratorTestCallback;
804 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(callback4), VSYNC_ERROR_OK);
805 }
806
807 /*
808 * Function: ChangePhaseOffset001
809 * Type: Function
810 * Rank: Important(2)
811 * EnvConditions: N/A
812 * CaseDescription: 1. call ChangePhaseOffset
813 */
814 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset001, Function | MediumTest| Level0)
815 {
816 sptr<VSyncGeneratorTestCallback> callback5 = new VSyncGeneratorTestCallback;
817 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback5);
818 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(callback5, 1), VSYNC_ERROR_OK);
819 }
820
821 /*
822 * Function: ChangePhaseOffset002
823 * Type: Function
824 * Rank: Important(2)
825 * EnvConditions: N/A
826 * CaseDescription: 1. call ChangePhaseOffset
827 */
828 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset002, Function | MediumTest| Level0)
829 {
830 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(nullptr, 1), VSYNC_ERROR_INVALID_ARGUMENTS);
831 }
832
833 /*
834 * Function: ChangePhaseOffset003
835 * Type: Function
836 * Rank: Important(2)
837 * EnvConditions: N/A
838 * CaseDescription: 1. call ChangePhaseOffset
839 */
840 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset003, Function | MediumTest| Level0)
841 {
842 sptr<VSyncGeneratorTestCallback> callback6 = new VSyncGeneratorTestCallback;
843 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback6);
844 sptr<VSyncGeneratorTestCallback> callback7 = new VSyncGeneratorTestCallback;
845 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(callback7, 1), VSYNC_ERROR_INVALID_OPERATING);
846 }
847
848 /*
849 * Function: expectNextVsyncTimeTest001
850 * Type: Function
851 * Rank: Important(2)
852 * EnvConditions: N/A
853 * CaseDescription: Test expectNextVsyncTime 0
854 */
855 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest001, Function | MediumTest| Level0)
856 {
857 int64_t period = 8333333; // 8333333ns
858 int64_t referenceTime = SystemTime();
859 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
860 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
861 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
862 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
863 int64_t refreshRate = 120; // 120hz
864 int64_t rsVsyncCount = 0;
865 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
866 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0); // expectNextVsyncTime 0
867 ASSERT_EQ(ret, VSYNC_ERROR_OK);
868 }
869
870 /*
871 * Function: expectNextVsyncTimeTest002
872 * Type: Function
873 * Rank: Important(2)
874 * EnvConditions: N/A
875 * CaseDescription: Test expectNextVsyncTime -1
876 */
877 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest002, Function | MediumTest| Level0)
878 {
879 int64_t period = 8333333; // 8333333ns
880 int64_t referenceTime = SystemTime();
881 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
882 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
883 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
884 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
885 int64_t refreshRate = 120; // 120hz
886 int64_t rsVsyncCount = 0;
887 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
888 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, -1); // expectNextVsyncTime -1
889 ASSERT_EQ(ret, VSYNC_ERROR_OK);
890 }
891
892 /*
893 * Function: expectNextVsyncTimeTest003
894 * Type: Function
895 * Rank: Important(2)
896 * EnvConditions: N/A
897 * CaseDescription: Test expectNextVsyncTime earlier than referenceTime.
898 */
899 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest003, Function | MediumTest| Level0)
900 {
901 int64_t period = 8333333; // 8333333ns
902 int64_t referenceTime = SystemTime();
903 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
904 VsyncError ret = vsyncGenerator_->UpdateMode(period, 0, referenceTime);
905 ASSERT_EQ(ret, VSYNC_ERROR_OK);
906 int64_t refreshRate = 120; // 120hz
907 int64_t rsVsyncCount = 0;
908 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
909 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
910 ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
911 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 0);
912 ASSERT_EQ(ret, VSYNC_ERROR_OK);
913 VSyncReceiver::FrameCallback fcb = {
914 .userData_ = this,
915 .callback_ = OnVSync,
916 };
917 ret = receiver->RequestNextVSync(fcb);
918 ASSERT_EQ(ret, VSYNC_ERROR_OK);
919 usleep(100000); // 100000us
920 ret = vsyncGenerator_->UpdateMode(period, 0, referenceTime);
921 ASSERT_EQ(ret, VSYNC_ERROR_OK);
922 ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
923 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, 10000000); // 10ms == 10000000ns
924 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
925 }
926
927 /*
928 * Function: expectNextVsyncTimeTest004
929 * Type: Function
930 * Rank: Important(2)
931 * EnvConditions: N/A
932 * CaseDescription: Test expectNextVsyncTime current system time.
933 */
934 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest004, Function | MediumTest| Level0)
935 {
936 int64_t period = 8333333; // 8333333ns
937 int64_t referenceTime = SystemTime();
938 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
939 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
940 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
941 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
942 int64_t refreshRate = 120; // 120hz
943 int64_t now = SystemTime();
944 int64_t rsVsyncCount = 0;
945 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
946 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, now);
947 ASSERT_EQ(ret, VSYNC_ERROR_OK);
948 }
949
950 /*
951 * Function: expectNextVsyncTimeTest005
952 * Type: Function
953 * Rank: Important(2)
954 * EnvConditions: N/A
955 * CaseDescription: Test expectNextVsyncTime current system time plus 5ms.
956 */
957 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest005, Function | MediumTest| Level0)
958 {
959 int64_t period = 8333333; // 8333333ns
960 int64_t referenceTime = SystemTime();
961 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
962 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
963 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
964 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
965 int64_t refreshRate = 120; // 120hz
966 int64_t now = SystemTime();
967 int64_t rsVsyncCount = 0;
968 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
969 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, now + 5000000); // 5ms == 5000000ns
970 ASSERT_EQ(ret, VSYNC_ERROR_OK);
971 }
972
973 /*
974 * Function: expectNextVsyncTimeTest006
975 * Type: Function
976 * Rank: Important(2)
977 * EnvConditions: N/A
978 * CaseDescription: Test expectNextVsyncTime current system time plus 5.5ms.
979 */
980 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest006, Function | MediumTest| Level0)
981 {
982 int64_t period = 8333333; // 8333333ns
983 int64_t referenceTime = SystemTime();
984 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
985 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
986 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
987 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
988 int64_t refreshRate = 120; // 120hz
989 int64_t now = SystemTime();
990 int64_t rsVsyncCount = 0;
991 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
992 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, now + 5500000); // 5.5ms == 5500000ns
993 ASSERT_EQ(ret, VSYNC_ERROR_OK);
994 }
995
996 /*
997 * Function: expectNextVsyncTimeTest007
998 * Type: Function
999 * Rank: Important(2)
1000 * EnvConditions: N/A
1001 * CaseDescription: Test expectNextVsyncTime current system time plus 90ms.
1002 */
1003 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest007, Function | MediumTest| Level0)
1004 {
1005 int64_t period = 8333333; // 8333333ns
1006 int64_t referenceTime = SystemTime();
1007 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
1008 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
1009 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
1010 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
1011 int64_t refreshRate = 120; // 120hz
1012 int64_t now = SystemTime();
1013 int64_t rsVsyncCount = 0;
1014 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
1015 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, now + 90000000); // 90ms == 90000000ns
1016 ASSERT_EQ(ret, VSYNC_ERROR_OK);
1017 }
1018
1019 /*
1020 * Function: expectNextVsyncTimeTest008
1021 * Type: Function
1022 * Rank: Important(2)
1023 * EnvConditions: N/A
1024 * CaseDescription: Test expectNextVsyncTime current system time plus 110ms.
1025 */
1026 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest008, Function | MediumTest| Level0)
1027 {
1028 int64_t period = 8333333; // 8333333ns
1029 int64_t referenceTime = SystemTime();
1030 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
1031 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
1032 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
1033 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
1034 int64_t refreshRate = 120; // 120hz
1035 int64_t now = SystemTime();
1036 int64_t rsVsyncCount = 0;
1037 auto ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
1038 listenerRefreshRates, listenerPhaseOffset, refreshRate, rsVsyncCount, now + 110000000); // 110ms == 110000000ns
1039 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
1040 }
1041
1042 /*
1043 * Function: SetCurrentRefreshRateTest001
1044 * Type: Function
1045 * Rank: Important(2)
1046 * EnvConditions: N/A
1047 * CaseDescription: Test SetCurrentRefreshRate
1048 */
1049 HWTEST_F(VSyncGeneratorTest, SetCurrentRefreshRateTest001, Function | MediumTest| Level0)
1050 {
1051 uint32_t currRefreshRate = 60;
1052 uint32_t lastRefreshRate = 30;
1053 int64_t delayTime = VSyncGeneratorTest::vsyncGenerator_->SetCurrentRefreshRate(currRefreshRate, lastRefreshRate);
1054 ASSERT_EQ(delayTime, 0);
1055 }
1056
1057 /*
1058 * Function: DVSyncRateChangedTest001
1059 * Type: Function
1060 * Rank: Important(2)
1061 * EnvConditions: N/A
1062 * CaseDescription: Test DVSyncRateChanged
1063 */
1064 HWTEST_F(VSyncGeneratorTest, DVSyncRateChangedTest001, Function | MediumTest| Level0)
1065 {
1066 uint32_t currRefreshRate = 60;
1067 bool frameRateChanged = false;
1068 VSyncGeneratorTest::vsyncGenerator_->DVSyncRateChanged(currRefreshRate, frameRateChanged);
1069 ASSERT_EQ(frameRateChanged, false);
1070 }
1071
1072 /*
1073 * Function: AddDVSyncListenerTest001
1074 * Type: Function
1075 * Rank: Important(2)
1076 * EnvConditions: N/A
1077 * CaseDescription: Test AddDVSyncListener
1078 */
1079 HWTEST_F(VSyncGeneratorTest, AddDVSyncListenerTest001, Function | MediumTest| Level0)
1080 {
1081 sptr<VSyncGenerator::Callback> cb = nullptr;
1082 int64_t phase = 0;
1083 VsyncError error = VSyncGeneratorTest::vsyncGenerator_->AddDVSyncListener(phase, cb);
1084 ASSERT_EQ(error, VSYNC_ERROR_INVALID_ARGUMENTS);
1085 }
1086
1087 /*
1088 * Function: RemoveDVSyncListenerTest001
1089 * Type: Function
1090 * Rank: Important(2)
1091 * EnvConditions: N/A
1092 * CaseDescription: Test RemoveDVSyncListener
1093 */
1094 HWTEST_F(VSyncGeneratorTest, RemoveDVSyncListenerTest001, Function | MediumTest| Level0)
1095 {
1096 sptr<VSyncGenerator::Callback> cb = nullptr;
1097 VsyncError error = VSyncGeneratorTest::vsyncGenerator_->RemoveDVSyncListener(cb);
1098 ASSERT_EQ(error, VSYNC_ERROR_INVALID_ARGUMENTS);
1099 }
1100 } // namespace
1101 } // namespace Rosen
1102 } // namespace OHOS