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
20 #include <gtest/gtest.h>
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
SystemTime()27 static int64_t SystemTime()
28 {
29 timespec t = {};
30 clock_gettime(CLOCK_MONOTONIC, &t);
31 return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s
32 }
33
34 class VSyncGeneratorTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38
39 static inline sptr<VSyncGenerator> vsyncGenerator_;
40 static constexpr const int32_t WAIT_SYSTEM_ABILITY_REPORT_DATA_SECONDS = 5;
41 static inline sptr<VSyncController> appController;
42 static inline sptr<VSyncController> rsController;
43 static inline sptr<VSyncDistributor> appDistributor;
44 static inline sptr<VSyncDistributor> rsDistributor;
45 };
46
SetUpTestCase()47 void VSyncGeneratorTest::SetUpTestCase()
48 {
49 vsyncGenerator_ = CreateVSyncGenerator();
50 appController = new VSyncController(vsyncGenerator_, 0);
51 rsController = new VSyncController(vsyncGenerator_, 0);
52 appDistributor = new VSyncDistributor(appController, "app");
53 rsDistributor = new VSyncDistributor(rsController, "app");
54 vsyncGenerator_->SetRSDistributor(rsDistributor);
55 vsyncGenerator_->SetAppDistributor(appDistributor);
56 }
57
TearDownTestCase()58 void VSyncGeneratorTest::TearDownTestCase()
59 {
60 sleep(WAIT_SYSTEM_ABILITY_REPORT_DATA_SECONDS);
61 vsyncGenerator_ = nullptr;
62 DestroyVSyncGenerator();
63 }
64
65 class VSyncGeneratorTestCallback : public VSyncGenerator::Callback {
66 public:
67 void OnVSyncEvent(int64_t now, int64_t period, uint32_t refreshRate, VSyncMode vsyncMode) override;
68 void OnPhaseOffsetChanged(int64_t phaseOffset) override;
69 void OnConnsRefreshRateChanged(const std::vector<std::pair<uint64_t, uint32_t>> &refreshRates) override;
70 };
71
OnVSyncEvent(int64_t now,int64_t period,uint32_t refreshRate,VSyncMode vsyncMode)72 void VSyncGeneratorTestCallback::OnVSyncEvent(int64_t now, int64_t period, uint32_t refreshRate, VSyncMode vsyncMode)
73 {
74 }
75
OnPhaseOffsetChanged(int64_t phaseOffset)76 void VSyncGeneratorTestCallback::OnPhaseOffsetChanged(int64_t phaseOffset)
77 {
78 }
79
OnConnsRefreshRateChanged(const std::vector<std::pair<uint64_t,uint32_t>> & refreshRates)80 void VSyncGeneratorTestCallback::OnConnsRefreshRateChanged(
81 const std::vector<std::pair<uint64_t, uint32_t>> &refreshRates)
82 {
83 }
84
85 namespace {
86 /*
87 * Function: UpdateMode001
88 * Type: Function
89 * Rank: Important(2)
90 * EnvConditions: N/A
91 * CaseDescription: 1. call UpdateMode
92 */
93 HWTEST_F(VSyncGeneratorTest, UpdateMode001, Function | MediumTest| Level0)
94 {
95 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, 0), VSYNC_ERROR_OK);
96 }
97
98 /*
99 * Function: UpdateMode002
100 * Type: Function
101 * Rank: Important(2)
102 * EnvConditions: N/A
103 * CaseDescription: 1. call UpdateMode
104 */
105 HWTEST_F(VSyncGeneratorTest, UpdateMode002, Function | MediumTest| Level0)
106 {
107 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, -1), VSYNC_ERROR_INVALID_ARGUMENTS);
108 }
109
110 /*
111 * Function: UpdateMode003
112 * Type: Function
113 * Rank: Important(2)
114 * EnvConditions: N/A
115 * CaseDescription: 1. call UpdateMode
116 */
117 HWTEST_F(VSyncGeneratorTest, UpdateMode003, Function | MediumTest| Level0)
118 {
119 VSyncGeneratorTest::vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
120 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(0, 0, 0), VSYNC_ERROR_OK);
121 // 25000000 is period, refreshRate is 40hz，for JudgeRefreshRateLocked test
122 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->UpdateMode(25000000, 0, 0), VSYNC_ERROR_OK);
123 }
124
125 /*
126 * Function: AddListener001
127 * Type: Function
128 * Rank: Important(2)
129 * EnvConditions: N/A
130 * CaseDescription: 1. call AddListener
131 */
132 HWTEST_F(VSyncGeneratorTest, AddListener001, Function | MediumTest| Level0)
133 {
134 sptr<VSyncGeneratorTestCallback> callback1 = new VSyncGeneratorTestCallback;
135 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback1), VSYNC_ERROR_OK);
136 }
137
138 /*
139 * Function: AddListener002
140 * Type: Function
141 * Rank: Important(2)
142 * EnvConditions: N/A
143 * CaseDescription: 1. call AddListener
144 */
145 HWTEST_F(VSyncGeneratorTest, AddListener002, Function | MediumTest| Level0)
146 {
147 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, nullptr), VSYNC_ERROR_INVALID_ARGUMENTS);
148 }
149
150 /*
151 * Function: AddListener003
152 * Type: Function
153 * Rank: Important(2)
154 * EnvConditions: N/A
155 * CaseDescription: 1. call AddListener
156 */
157 HWTEST_F(VSyncGeneratorTest, AddListener003, Function | MediumTest| Level0)
158 {
159 VSyncGeneratorTest::vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
160 VSyncGeneratorTest::vsyncGenerator_->UpdateMode(2, 0, 0);
161 sptr<VSyncGeneratorTestCallback> callback = new VSyncGeneratorTestCallback;
162 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback), VSYNC_ERROR_OK);
163 }
164
165 /*
166 * Function: RemoveListener001
167 * Type: Function
168 * Rank: Important(2)
169 * EnvConditions: N/A
170 * CaseDescription: 1. call RemoveListener
171 */
172 HWTEST_F(VSyncGeneratorTest, RemoveListener001, Function | MediumTest| Level0)
173 {
174 sptr<VSyncGeneratorTestCallback> callback2 = new VSyncGeneratorTestCallback;
175 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback2);
176 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(callback2), VSYNC_ERROR_OK);
177 }
178
179 /*
180 * Function: RemoveListener002
181 * Type: Function
182 * Rank: Important(2)
183 * EnvConditions: N/A
184 * CaseDescription: 1. call RemoveListener
185 */
186 HWTEST_F(VSyncGeneratorTest, RemoveListener002, Function | MediumTest| Level0)
187 {
188 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(nullptr), VSYNC_ERROR_INVALID_ARGUMENTS);
189 }
190
191 /*
192 * Function: RemoveListener003
193 * Type: Function
194 * Rank: Important(2)
195 * EnvConditions: N/A
196 * CaseDescription: 1. call RemoveListener
197 */
198 HWTEST_F(VSyncGeneratorTest, RemoveListener003, Function | MediumTest| Level0)
199 {
200 sptr<VSyncGeneratorTestCallback> callback3 = new VSyncGeneratorTestCallback;
201 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback3);
202 sptr<VSyncGeneratorTestCallback> callback4 = new VSyncGeneratorTestCallback;
203 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->RemoveListener(callback4), VSYNC_ERROR_INVALID_ARGUMENTS);
204 }
205
206 /*
207 * Function: ChangePhaseOffset001
208 * Type: Function
209 * Rank: Important(2)
210 * EnvConditions: N/A
211 * CaseDescription: 1. call ChangePhaseOffset
212 */
213 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset001, Function | MediumTest| Level0)
214 {
215 sptr<VSyncGeneratorTestCallback> callback5 = new VSyncGeneratorTestCallback;
216 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback5);
217 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(callback5, 1), VSYNC_ERROR_OK);
218 }
219
220 /*
221 * Function: ChangePhaseOffset002
222 * Type: Function
223 * Rank: Important(2)
224 * EnvConditions: N/A
225 * CaseDescription: 1. call ChangePhaseOffset
226 */
227 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset002, Function | MediumTest| Level0)
228 {
229 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(nullptr, 1), VSYNC_ERROR_INVALID_ARGUMENTS);
230 }
231
232 /*
233 * Function: ChangePhaseOffset003
234 * Type: Function
235 * Rank: Important(2)
236 * EnvConditions: N/A
237 * CaseDescription: 1. call ChangePhaseOffset
238 */
239 HWTEST_F(VSyncGeneratorTest, ChangePhaseOffset003, Function | MediumTest| Level0)
240 {
241 sptr<VSyncGeneratorTestCallback> callback6 = new VSyncGeneratorTestCallback;
242 VSyncGeneratorTest::vsyncGenerator_->AddListener(2, callback6);
243 sptr<VSyncGeneratorTestCallback> callback7 = new VSyncGeneratorTestCallback;
244 ASSERT_EQ(VSyncGeneratorTest::vsyncGenerator_->ChangePhaseOffset(callback7, 1), VSYNC_ERROR_INVALID_OPERATING);
245 }
246
247 /*
248 * Function: expectNextVsyncTimeTest001
249 * Type: Function
250 * Rank: Important(2)
251 * EnvConditions: N/A
252 * CaseDescription: Test expectNextVsyncTime 0
253 */
254 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest001, Function | MediumTest| Level0)
255 {
256 int64_t period = 8333333; // 8333333ns
257 int64_t referenceTime = SystemTime();
258 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
259 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
260 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
261 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
262 int64_t refreshRate = 120; // 120hz
263 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
264 listenerRefreshRates, listenerPhaseOffset, refreshRate, 0); // expectNextVsyncTime 0
265 ASSERT_EQ(ret, VSYNC_ERROR_OK);
266 }
267
268 /*
269 * Function: expectNextVsyncTimeTest002
270 * Type: Function
271 * Rank: Important(2)
272 * EnvConditions: N/A
273 * CaseDescription: Test expectNextVsyncTime -1
274 */
275 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest002, Function | MediumTest| Level0)
276 {
277 int64_t period = 8333333; // 8333333ns
278 int64_t referenceTime = SystemTime();
279 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
280 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
281 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
282 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
283 int64_t refreshRate = 120; // 120hz
284 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
285 listenerRefreshRates, listenerPhaseOffset, refreshRate, -1); // expectNextVsyncTime -1
286 ASSERT_EQ(ret, VSYNC_ERROR_OK);
287 }
288
289 /*
290 * Function: expectNextVsyncTimeTest003
291 * Type: Function
292 * Rank: Important(2)
293 * EnvConditions: N/A
294 * CaseDescription: Test expectNextVsyncTime earlier than referenceTime.
295 */
296 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest003, Function | MediumTest| Level0)
297 {
298 int64_t period = 8333333; // 8333333ns
299 int64_t referenceTime = SystemTime();
300 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
301 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
302 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
303 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
304 int64_t refreshRate = 120; // 120hz
305 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
306 listenerRefreshRates, listenerPhaseOffset, refreshRate, referenceTime - 10000000); // 10ms == 10000000ns
307 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
308 }
309
310 /*
311 * Function: expectNextVsyncTimeTest004
312 * Type: Function
313 * Rank: Important(2)
314 * EnvConditions: N/A
315 * CaseDescription: Test expectNextVsyncTime current system time.
316 */
317 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest004, Function | MediumTest| Level0)
318 {
319 int64_t period = 8333333; // 8333333ns
320 int64_t referenceTime = SystemTime();
321 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
322 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
323 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
324 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
325 int64_t refreshRate = 120; // 120hz
326 int64_t now = SystemTime();
327 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
328 listenerRefreshRates, listenerPhaseOffset, refreshRate, now);
329 ASSERT_EQ(ret, VSYNC_ERROR_OK);
330 }
331
332 /*
333 * Function: expectNextVsyncTimeTest005
334 * Type: Function
335 * Rank: Important(2)
336 * EnvConditions: N/A
337 * CaseDescription: Test expectNextVsyncTime current system time plus 5ms.
338 */
339 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest005, Function | MediumTest| Level0)
340 {
341 int64_t period = 8333333; // 8333333ns
342 int64_t referenceTime = SystemTime();
343 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
344 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
345 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
346 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
347 int64_t refreshRate = 120; // 120hz
348 int64_t now = SystemTime();
349 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
350 listenerRefreshRates, listenerPhaseOffset, refreshRate, now + 5000000); // 5ms == 5000000ns
351 ASSERT_EQ(ret, VSYNC_ERROR_OK);
352 }
353
354 /*
355 * Function: expectNextVsyncTimeTest006
356 * Type: Function
357 * Rank: Important(2)
358 * EnvConditions: N/A
359 * CaseDescription: Test expectNextVsyncTime current system time plus 5.5ms.
360 */
361 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest006, Function | MediumTest| Level0)
362 {
363 int64_t period = 8333333; // 8333333ns
364 int64_t referenceTime = SystemTime();
365 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
366 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
367 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
368 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
369 int64_t refreshRate = 120; // 120hz
370 int64_t now = SystemTime();
371 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
372 listenerRefreshRates, listenerPhaseOffset, refreshRate, now + 5500000); // 5.5ms == 5500000ns
373 ASSERT_EQ(ret, VSYNC_ERROR_OK);
374 }
375
376 /*
377 * Function: expectNextVsyncTimeTest007
378 * Type: Function
379 * Rank: Important(2)
380 * EnvConditions: N/A
381 * CaseDescription: Test expectNextVsyncTime current system time plus 90ms.
382 */
383 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest007, Function | MediumTest| Level0)
384 {
385 int64_t period = 8333333; // 8333333ns
386 int64_t referenceTime = SystemTime();
387 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
388 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
389 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
390 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
391 int64_t refreshRate = 120; // 120hz
392 int64_t now = SystemTime();
393 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
394 listenerRefreshRates, listenerPhaseOffset, refreshRate, now + 90000000); // 90ms == 90000000ns
395 ASSERT_EQ(ret, VSYNC_ERROR_OK);
396 }
397
398 /*
399 * Function: expectNextVsyncTimeTest008
400 * Type: Function
401 * Rank: Important(2)
402 * EnvConditions: N/A
403 * CaseDescription: Test expectNextVsyncTime current system time plus 110ms.
404 */
405 HWTEST_F(VSyncGeneratorTest, expectNextVsyncTimeTest008, Function | MediumTest| Level0)
406 {
407 int64_t period = 8333333; // 8333333ns
408 int64_t referenceTime = SystemTime();
409 vsyncGenerator_->SetVSyncMode(VSYNC_MODE_LTPO);
410 vsyncGenerator_->UpdateMode(period, 0, referenceTime);
411 VSyncGenerator::ListenerRefreshRateData listenerRefreshRates = {};
412 VSyncGenerator::ListenerPhaseOffsetData listenerPhaseOffset = {};
413 int64_t refreshRate = 120; // 120hz
414 int64_t now = SystemTime();
415 VsyncError ret = VSyncGeneratorTest::vsyncGenerator_->ChangeGeneratorRefreshRateModel(
416 listenerRefreshRates, listenerPhaseOffset, refreshRate, now + 110000000); // 110ms == 110000000ns
417 ASSERT_EQ(ret, VSYNC_ERROR_INVALID_ARGUMENTS);
418 }
419 } // namespace
420 } // namespace Rosen
421 } // namespace OHOS