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 #include <gtest/gtest.h>
16 #include "vsync_distributor.h"
17 #include "vsync_controller.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Rosen {
24 class VSyncDistributorTest : public testing::Test {
25 public:
26 static void SetUpTestCase();
27 static void TearDownTestCase();
28
29 static inline sptr<VSyncController> vsyncController = nullptr;
30 static inline sptr<VSyncDistributor> vsyncDistributor = nullptr;
31 static inline sptr<VSyncGenerator> vsyncGenerator = nullptr;
32 };
33
SetUpTestCase()34 void VSyncDistributorTest::SetUpTestCase()
35 {
36 vsyncGenerator = CreateVSyncGenerator();
37 vsyncController = new VSyncController(vsyncGenerator, 0);
38 vsyncDistributor = new VSyncDistributor(vsyncController, "VSyncConnection");
39 }
40
TearDownTestCase()41 void VSyncDistributorTest::TearDownTestCase()
42 {
43 vsyncGenerator = nullptr;
44 DestroyVSyncGenerator();
45 vsyncController = nullptr;
46 vsyncDistributor = nullptr;
47 }
48
49 namespace {
50 /*
51 * Function: AddConnection001
52 * Type: Function
53 * Rank: Important(2)
54 * EnvConditions: N/A
55 * CaseDescription: 1. call AddConnection
56 */
57 HWTEST_F(VSyncDistributorTest, AddConnection001, Function | MediumTest| Level3)
58 {
59 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->AddConnection(nullptr), VSYNC_ERROR_NULLPTR);
60 }
61
62 /*
63 * Function: AddConnection002
64 * Type: Function
65 * Rank: Important(2)
66 * EnvConditions: N/A
67 * CaseDescription: 1. call AddConnection
68 */
69 HWTEST_F(VSyncDistributorTest, AddConnection002, Function | MediumTest| Level3)
70 {
71 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
72 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
73 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->AddConnection(conn), VSYNC_ERROR_INVALID_ARGUMENTS);
74 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
75 }
76
77 /*
78 * Function: RemoveConnection001
79 * Type: Function
80 * Rank: Important(2)
81 * EnvConditions: N/A
82 * CaseDescription: 1. call RemoveConnection
83 */
84 HWTEST_F(VSyncDistributorTest, RemoveConnection001, Function | MediumTest| Level3)
85 {
86 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(nullptr), VSYNC_ERROR_NULLPTR);
87 }
88
89 /*
90 * Function: RemoveConnection002
91 * Type: Function
92 * Rank: Important(2)
93 * EnvConditions: N/A
94 * CaseDescription: 1. call RemoveConnection
95 */
96 HWTEST_F(VSyncDistributorTest, RemoveConnection002, Function | MediumTest| Level3)
97 {
98 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
99 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_INVALID_ARGUMENTS);
100 }
101
102 /*
103 * Function: RemoveConnection003
104 * Type: Function
105 * Rank: Important(2)
106 * EnvConditions: N/A
107 * CaseDescription: 1. call RemoveConnection
108 */
109 HWTEST_F(VSyncDistributorTest, RemoveConnection003, Function | MediumTest| Level3)
110 {
111 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
112 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
113 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
114 }
115
116 /*
117 * Function: RequestNextVSync001
118 * Type: Function
119 * Rank: Important(2)
120 * EnvConditions: N/A
121 * CaseDescription: 1. call RequestNextVSync
122 */
123 HWTEST_F(VSyncDistributorTest, RequestNextVSync001, Function | MediumTest| Level3)
124 {
125 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RequestNextVSync(nullptr), VSYNC_ERROR_NULLPTR);
126 }
127
128 /*
129 * Function: RequestNextVSync002
130 * Type: Function
131 * Rank: Important(2)
132 * EnvConditions: N/A
133 * CaseDescription: 1. call RequestNextVSync
134 */
135 HWTEST_F(VSyncDistributorTest, RequestNextVSync002, Function | MediumTest| Level3)
136 {
137 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
138 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RequestNextVSync(conn), VSYNC_ERROR_INVALID_ARGUMENTS);
139 }
140
141 /*
142 * Function: RequestNextVSync003
143 * Type: Function
144 * Rank: Important(2)
145 * EnvConditions: N/A
146 * CaseDescription: 1. call RequestNextVSync
147 */
148 HWTEST_F(VSyncDistributorTest, RequestNextVSync003, Function | MediumTest| Level3)
149 {
150 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
151 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
152 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RequestNextVSync(conn), VSYNC_ERROR_OK);
153 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
154 }
155
156 /*
157 * Function: RequestNextVSync004
158 * Type: Function
159 * Rank: Important(2)
160 * EnvConditions: N/A
161 * CaseDescription: 1. call RequestNextVSync
162 */
163 HWTEST_F(VSyncDistributorTest, RequestNextVSync004, Function | MediumTest| Level3)
164 {
165 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
166 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
167 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RequestNextVSync(conn, "unknown", 0), VSYNC_ERROR_OK);
168 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
169 }
170
171 /*
172 * Function: RequestNextVSync005
173 * Type: Function
174 * Rank: Important(2)
175 * EnvConditions: N/A
176 * CaseDescription: 1. new VSyncConnection(nullptr, "VSyncDistributorTest")
177 * 2. call RequestNextVSync
178 * 3. return VSYNC_ERROR_NULLPTR
179 */
180 HWTEST_F(VSyncDistributorTest, RequestNextVSync005, Function | MediumTest| Level3)
181 {
182 sptr<VSyncConnection> conn = new VSyncConnection(nullptr, "VSyncDistributorTest");
183 ASSERT_EQ(conn->RequestNextVSync("unknown", 0), VSYNC_ERROR_NULLPTR);
184 }
185
186 /*
187 * Function: SetVSyncRate001
188 * Type: Function
189 * Rank: Important(2)
190 * EnvConditions: N/A
191 * CaseDescription: 1. call SetVSyncRate
192 */
193 HWTEST_F(VSyncDistributorTest, SetVSyncRate001, Function | MediumTest| Level3)
194 {
195 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetVSyncRate(0, nullptr), VSYNC_ERROR_INVALID_ARGUMENTS);
196 }
197
198 /*
199 * Function: SetVSyncRate002
200 * Type: Function
201 * Rank: Important(2)
202 * EnvConditions: N/A
203 * CaseDescription: 1. call SetVSyncRate
204 */
205 HWTEST_F(VSyncDistributorTest, SetVSyncRate002, Function | MediumTest| Level3)
206 {
207 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
208 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetVSyncRate(1, conn), VSYNC_ERROR_INVALID_ARGUMENTS);
209 }
210
211 /*
212 * Function: SetVSyncRate003
213 * Type: Function
214 * Rank: Important(2)
215 * EnvConditions: N/A
216 * CaseDescription: 1. call SetVSyncRate
217 */
218 HWTEST_F(VSyncDistributorTest, SetVSyncRate003, Function | MediumTest| Level3)
219 {
220 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
221 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
222 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetVSyncRate(1, conn), VSYNC_ERROR_OK);
223 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
224 }
225
226 /*
227 * Function: SetVSyncRate004
228 * Type: Function
229 * Rank: Important(2)
230 * EnvConditions: N/A
231 * CaseDescription: 1. call SetVSyncRate
232 */
233 HWTEST_F(VSyncDistributorTest, SetVSyncRate004, Function | MediumTest| Level3)
234 {
235 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
236 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
237 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetVSyncRate(1, conn), VSYNC_ERROR_OK);
238 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetVSyncRate(1, conn), VSYNC_ERROR_INVALID_ARGUMENTS);
239 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
240 }
241
242 /*
243 * Function: SetVSyncRate005
244 * Type: Function
245 * Rank: Important(2)
246 * EnvConditions: N/A
247 * CaseDescription: 1. set conn.distributor_ = nullptr
248 * 2. call SetVSyncRate
249 * 3. return VSYNC_ERROR_NULLPTR
250 */
251 HWTEST_F(VSyncDistributorTest, SetVSyncRate005, Function | MediumTest| Level3)
252 {
253 sptr<VSyncConnection> conn = new VSyncConnection(nullptr, "VSyncDistributorTest");
254 ASSERT_EQ(conn->SetVSyncRate(1), VSYNC_ERROR_NULLPTR);
255 }
256
257 /*
258 * Function: SetHighPriorityVSyncRate001
259 * Type: Function
260 * Rank: Important(2)
261 * EnvConditions: N/A
262 * CaseDescription: 1. call SetHighPriorityVSyncRate with abnormal parameters and check ret
263 */
264 HWTEST_F(VSyncDistributorTest, SetHighPriorityVSyncRate001, Function | MediumTest| Level3)
265 {
266 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(0, nullptr),
267 VSYNC_ERROR_INVALID_ARGUMENTS);
268 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(1, nullptr),
269 VSYNC_ERROR_INVALID_ARGUMENTS);
270 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
271 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_INVALID_ARGUMENTS);
272 }
273
274 /*
275 * Function: SetHighPriorityVSyncRate002
276 * Type: Function
277 * Rank: Important(2)
278 * EnvConditions: N/A
279 * CaseDescription: 1. call SetHighPriorityVSyncRate with normal parameters and check ret
280 */
281 HWTEST_F(VSyncDistributorTest, SetHighPriorityVSyncRate002, Function | MediumTest| Level3)
282 {
283 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
284 VSyncDistributorTest::vsyncDistributor->AddConnection(conn);
285 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_OK);
286 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_INVALID_ARGUMENTS);
287 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetHighPriorityVSyncRate(2, conn), VSYNC_ERROR_OK);
288 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->RemoveConnection(conn), VSYNC_ERROR_OK);
289 }
290
291 /*
292 * Function: SetFrameIsRender001
293 * Type: Function
294 * Rank: Important(2)
295 * EnvConditions: N/A
296 * CaseDescription: 1. call SetFrameIsRender with render is true
297 */
298 HWTEST_F(VSyncDistributorTest, SetFrameIsRender001, Function | MediumTest| Level3)
299 {
300 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->IsDVsyncOn(), false);
301 VSyncDistributorTest::vsyncDistributor->SetFrameIsRender(true);
302 }
303
304 /*
305 * Function: SetFrameIsRender002
306 * Type: Function
307 * Rank: Important(2)
308 * EnvConditions: N/A
309 * CaseDescription: 1. call SetFrameIsRender with render is false
310 */
311 HWTEST_F(VSyncDistributorTest, SetFrameIsRender002, Function | MediumTest| Level3)
312 {
313 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->IsDVsyncOn(), false);
314 VSyncDistributorTest::vsyncDistributor->SetFrameIsRender(false);
315 }
316
317 /*
318 * Function: GetRealTimeOffsetOfDvsync001
319 * Type: Function
320 * Rank: Important(2)
321 * EnvConditions: N/A
322 * CaseDescription: 1. call GetRealTimeOffsetOfDvsync
323 */
324 HWTEST_F(VSyncDistributorTest, GetRealTimeOffsetOfDvsync001, Function | MediumTest| Level3)
325 {
326 int64_t time = 1000;
327 uint64_t offset = VSyncDistributorTest::vsyncDistributor->GetRealTimeOffsetOfDvsync(time);
328 ASSERT_EQ(offset, 0);
329 }
330
331 /*
332 * Function: MarkRSAnimate001
333 * Type: Function
334 * Rank: Important(2)
335 * EnvConditions: N/A
336 * CaseDescription: 1. call MarkRSAnimate
337 */
338 HWTEST_F(VSyncDistributorTest, MarkRSAnimate001, Function | MediumTest| Level3)
339 {
340 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
341 auto res = VSyncDistributorTest::vsyncDistributor->SetUiDvsyncSwitch(true, conn);
342 ASSERT_EQ(res, VSYNC_ERROR_OK);
343 VSyncDistributorTest::vsyncDistributor->MarkRSAnimate();
344 }
345
346 /*
347 * Function: UnmarkRSAnimate001
348 * Type: Function
349 * Rank: Important(2)
350 * EnvConditions: N/A
351 * CaseDescription: 1. call UnmarkRSAnimate
352 */
353 HWTEST_F(VSyncDistributorTest, UnmarkRSAnimate001, Function | MediumTest| Level3)
354 {
355 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
356 auto res = VSyncDistributorTest::vsyncDistributor->SetUiDvsyncSwitch(false, conn);
357 ASSERT_EQ(res, VSYNC_ERROR_OK);
358 VSyncDistributorTest::vsyncDistributor->UnmarkRSAnimate();
359 }
360
361 /*
362 * Function: HasPendingUIRNV001
363 * Type: Function
364 * Rank: Important(2)
365 * EnvConditions: N/A
366 * CaseDescription: 1. call HasPendingUIRNV
367 */
368 HWTEST_F(VSyncDistributorTest, HasPendingUIRNV001, Function | MediumTest| Level3)
369 {
370 auto res = VSyncDistributorTest::vsyncDistributor->HasPendingUIRNV();
371 EXPECT_FALSE(res);
372 }
373
374 /*
375 * Function: UpdatePendingReferenceTime001
376 * Type: Function
377 * Rank: Important(2)
378 * EnvConditions: N/A
379 * CaseDescription: 1. call UpdatePendingReferenceTime
380 */
381 HWTEST_F(VSyncDistributorTest, UpdatePendingReferenceTime001, Function | MediumTest| Level3)
382 {
383 int64_t timeStamp = 0;
384 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
385 auto res = VSyncDistributorTest::vsyncDistributor->SetUiDvsyncSwitch(true, conn);
386 ASSERT_EQ(res, VSYNC_ERROR_OK);
387 VSyncDistributorTest::vsyncDistributor->UpdatePendingReferenceTime(timeStamp);
388 }
389
390 /*
391 * Function: SetHardwareTaskNum001
392 * Type: Function
393 * Rank: Important(2)
394 * EnvConditions: N/A
395 * CaseDescription: 1. call SetHardwareTaskNum
396 */
397 HWTEST_F(VSyncDistributorTest, SetHardwareTaskNum001, Function | MediumTest| Level3)
398 {
399 uint32_t num = 0;
400 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
401 auto res = VSyncDistributorTest::vsyncDistributor->SetUiDvsyncSwitch(true, conn);
402 ASSERT_EQ(res, VSYNC_ERROR_OK);
403 VSyncDistributorTest::vsyncDistributor->SetHardwareTaskNum(num);
404 }
405
406 /*
407 * Function: GetUiCommandDelayTime001
408 * Type: Function
409 * Rank: Important(2)
410 * EnvConditions: N/A
411 * CaseDescription: 1. call GetUiCommandDelayTime
412 */
413 HWTEST_F(VSyncDistributorTest, GetUiCommandDelayTime001, Function | MediumTest| Level3)
414 {
415 vsyncDistributor->isRs_ = false;
416 VSyncDistributorTest::vsyncDistributor->GetUiCommandDelayTime();
417 ASSERT_EQ(vsyncDistributor->isRs_, false);
418 }
419
420 /*
421 * Function: SetUiDvsyncConfig001
422 * Type: Function
423 * Rank: Important(2)
424 * EnvConditions: N/A
425 * CaseDescription: 1. call SetUiDvsyncConfig
426 */
427 HWTEST_F(VSyncDistributorTest, SetUiDvsyncConfig001, Function | MediumTest| Level3)
428 {
429 uint32_t bufferCount = 2;
430 ASSERT_EQ(VSyncDistributorTest::vsyncDistributor->SetUiDvsyncConfig(bufferCount), VSYNC_ERROR_OK);
431 }
432
433 /*
434 * Function: SetUiDvsyncSwitchTest
435 * Type: Function
436 * Rank: Important(2)
437 * EnvConditions: N/A
438 * CaseDescription: 1. call SetUiDvsyncSwitch
439 */
440 HWTEST_F(VSyncDistributorTest, SetUiDvsyncSwitchTest, Function | MediumTest| Level3)
441 {
442 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
443 ASSERT_EQ(conn->SetUiDvsyncSwitch(true), VSYNC_ERROR_OK);
444 ASSERT_EQ(conn->SetUiDvsyncSwitch(false), VSYNC_ERROR_OK);
445 }
446
447 /*
448 * Function: SetUiDvsyncSwitchTest001
449 * Type: Function
450 * Rank: Important(2)
451 * EnvConditions: N/A
452 * CaseDescription: 1. new VSyncConnection(nullptr, "VSyncDistributorTest")
453 * 2. call SetUiDvsyncSwitch
454 * 3. return VSYNC_ERROR_NULLPTR
455 */
456 HWTEST_F(VSyncDistributorTest, SetUiDvsyncSwitchTest001, Function | MediumTest| Level3)
457 {
458 sptr<VSyncConnection> conn = new VSyncConnection(nullptr, "VSyncDistributorTest");
459 ASSERT_EQ(conn->SetUiDvsyncSwitch(true), VSYNC_ERROR_NULLPTR);
460 ASSERT_EQ(conn->SetUiDvsyncSwitch(false), VSYNC_ERROR_NULLPTR);
461 }
462
463 /*
464 * Function: SetUiDvsyncConfigTest
465 * Type: Function
466 * Rank: Important(2)
467 * EnvConditions: N/A
468 * CaseDescription: 1. call SetUiDvsyncConfig
469 */
470 HWTEST_F(VSyncDistributorTest, SetUiDvsyncConfigTest, Function | MediumTest| Level3)
471 {
472 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "VSyncDistributorTest");
473 ASSERT_EQ(conn->SetUiDvsyncConfig(1), VSYNC_ERROR_OK);
474 }
475
476 /*
477 * Function: SetUiDvsyncConfigTest001
478 * Type: Function
479 * Rank: Important(2)
480 * EnvConditions: N/A
481 * CaseDescription: 1. new VSyncConnection(nullptr, "VSyncDistributorTest")
482 * 2. call SetUiDvsyncConfig
483 * 3. return VSYNC_ERROR_NULLPTR
484 */
485 HWTEST_F(VSyncDistributorTest, SetUiDvsyncConfigTest001, Function | MediumTest| Level3)
486 {
487 sptr<VSyncConnection> conn = new VSyncConnection(nullptr, "VSyncDistributorTest");
488 ASSERT_EQ(conn->SetUiDvsyncConfig(1), VSYNC_ERROR_NULLPTR);
489 }
490
491 /*
492 * Function: AddConnectionOverFlowTest
493 * Type: Function
494 * Rank: Important(2)
495 * EnvConditions: N/A
496 * CaseDescription: 1. call AddConnection over 256 times
497 */
498 HWTEST_F(VSyncDistributorTest, AddConnectionOverFlowTest, Function | MediumTest| Level3)
499 {
500 std::vector<sptr<VSyncConnection>> conns;
501 for (int i = 0; i < 257; i++) { // add 257 connections
502 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
503 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
504 conns.emplace_back(conn);
505 }
506 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_1234");
507 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_API_FAILED);
508 for (int i = 0; i < conns.size(); i++) {
509 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
510 }
511 }
512
513 /*
514 * Function: OnVSyncTriggerTest001
515 * Type: Function
516 * Rank: Important(2)
517 * EnvConditions: N/A
518 * CaseDescription: 1. test OnVSyncTrigger
519 */
520 HWTEST_F(VSyncDistributorTest, OnVSyncTriggerTest001, Function | MediumTest| Level3)
521 {
522 std::vector<sptr<VSyncConnection>> conns;
523 for (int i = 0; i < 10; i++) { // add 10 connections
524 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
525 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
526 conns.emplace_back(conn);
527 }
528 vsyncDistributor->OnVSyncTrigger(1000000000, 8333333, 120, VSYNC_MODE_LTPO, 360);
529 for (int i = 0; i < conns.size(); i++) {
530 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
531 }
532 }
533
534 /*
535 * Function: OnVSyncTriggerTest002
536 * Type: Function
537 * Rank: Important(2)
538 * EnvConditions: N/A
539 * CaseDescription: 1. test OnVSyncTrigger
540 */
541 HWTEST_F(VSyncDistributorTest, OnVSyncTriggerTest002, Function | MediumTest| Level3)
542 {
543 std::vector<sptr<VSyncConnection>> conns;
544 for (int i = 0; i < 10; i++) { // add 10 connections
545 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
546 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
547 conns.emplace_back(conn);
548 }
549 vsyncDistributor->OnVSyncTrigger(1000000000, -8333333, 120, VSYNC_MODE_LTPO, 360);
550 for (int i = 0; i < conns.size(); i++) {
551 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
552 }
553 }
554
555 /*
556 * Function: OnVSyncTriggerTest003
557 * Type: Function
558 * Rank: Important(2)
559 * EnvConditions: N/A
560 * CaseDescription: 1. test OnVSyncTrigger
561 */
562 HWTEST_F(VSyncDistributorTest, OnVSyncTriggerTest003, Function | MediumTest| Level3)
563 {
564 std::vector<sptr<VSyncConnection>> conns;
565 for (int i = 0; i < 10; i++) { // add 10 connections
566 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
567 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
568 conns.emplace_back(conn);
569 }
570 vsyncDistributor->OnVSyncTrigger(1000000000, 8333333, 120, VSYNC_MODE_LTPS, 360);
571 for (int i = 0; i < conns.size(); i++) {
572 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
573 }
574 }
575
576 /*
577 * Function: SetQosVSyncRateByPidTest001
578 * Type: Function
579 * Rank: Important(2)
580 * EnvConditions: N/A
581 * CaseDescription: 1. test SetQosVSyncRateByPid
582 */
583 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest001, Function | MediumTest| Level3)
584 {
585 std::vector<sptr<VSyncConnection>> conns;
586 for (int i = 0; i < 10; i++) { // add 10 connections
587 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
588 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
589 conns.emplace_back(conn);
590 }
591 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(0, 2, false), VSYNC_ERROR_OK);
592 for (int i = 0; i < conns.size(); i++) {
593 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
594 }
595 }
596
597 /*
598 * Function: SetQosVSyncRateByPidTest002
599 * Type: Function
600 * Rank: Important(2)
601 * EnvConditions: N/A
602 * CaseDescription: 1. test SetQosVSyncRateByPid
603 */
604 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest002, Function | MediumTest| Level3)
605 {
606 std::vector<sptr<VSyncConnection>> conns;
607 for (int i = 0; i < 10; i++) { // add 10 connections
608 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
609 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
610 conns.emplace_back(conn);
611 }
612 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
613 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
614 conns.emplace_back(conn);
615 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(0, 1, false), VSYNC_ERROR_INVALID_ARGUMENTS);
616 for (int i = 0; i < conns.size(); i++) {
617 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
618 }
619 }
620
621 /*
622 * Function: SetQosVSyncRateByPidTest003
623 * Type: Function
624 * Rank: Important(2)
625 * EnvConditions: N/A
626 * CaseDescription: 1. test SetQosVSyncRateByPid
627 */
628 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest003, Function | MediumTest| Level3)
629 {
630 std::vector<sptr<VSyncConnection>> conns;
631 for (int i = 0; i < 10; i++) { // add 10 connections
632 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
633 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
634 conns.emplace_back(conn);
635 }
636 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
637 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
638 conns.emplace_back(conn);
639 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(0, 2, true), VSYNC_ERROR_INVALID_ARGUMENTS);
640 for (int i = 0; i < conns.size(); i++) {
641 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
642 }
643 }
644
645 /*
646 * Function: SetQosVSyncRateByPidTest004
647 * Type: Function
648 * Rank: Important(2)
649 * EnvConditions: N/A
650 * CaseDescription: 1. test SetQosVSyncRateByPid
651 */
652 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest004, Function | MediumTest| Level3)
653 {
654 std::vector<sptr<VSyncConnection>> conns;
655 for (int i = 0; i < 10; i++) { // add 10 connections
656 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
657 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
658 conns.emplace_back(conn);
659 }
660 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
661 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
662 conns.emplace_back(conn);
663 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(0, 1, true), VSYNC_ERROR_INVALID_ARGUMENTS);
664 for (int i = 0; i < conns.size(); i++) {
665 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
666 }
667 }
668
669 /*
670 * Function: SetQosVSyncRateByPidTest005
671 * Type: Function
672 * Rank: Important(2)
673 * EnvConditions: N/A
674 * CaseDescription: 1. test SetQosVSyncRateByPid
675 */
676 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest005, Function | MediumTest| Level3)
677 {
678 std::vector<sptr<VSyncConnection>> conns;
679 for (int i = 0; i < 10; i++) { // add 10 connections
680 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
681 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
682 conns.emplace_back(conn);
683 }
684 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
685 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
686 conns.emplace_back(conn);
687 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(1, 1, true), VSYNC_ERROR_OK);
688 for (int i = 0; i < conns.size(); i++) {
689 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
690 }
691 }
692
693 /*
694 * Function: SetQosVSyncRateByPidTest006
695 * Type: Function
696 * Rank: Important(2)
697 * EnvConditions: N/A
698 * CaseDescription: 1. test SetQosVSyncRateByPid
699 */
700 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidTest006, Function | MediumTest| Level3)
701 {
702 std::vector<sptr<VSyncConnection>> conns;
703 for (int i = 0; i < 10; i++) { // add 10 connections
704 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
705 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
706 ASSERT_EQ(vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_OK);
707 conns.emplace_back(conn);
708 }
709 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
710 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
711 conns.emplace_back(conn);
712 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPid(1, 1, true), VSYNC_ERROR_OK);
713 for (int i = 0; i < conns.size(); i++) {
714 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
715 }
716 }
717
718 /*
719 * Function: SetQosVSyncRateTest001
720 * Type: Function
721 * Rank: Important(2)
722 * EnvConditions: N/A
723 * CaseDescription: 1. test SetQosVSyncRate
724 */
725 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateTest001, Function | MediumTest| Level3)
726 {
727 std::vector<sptr<VSyncConnection>> conns;
728 for (int i = 0; i < 10; i++) { // add 10 connections
729 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
730 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
731 ASSERT_EQ(vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_OK);
732 conns.emplace_back(conn);
733 }
734 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
735 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
736 conns.emplace_back(conn);
737 ASSERT_EQ(vsyncDistributor->SetQosVSyncRate(0xffffffffff, 1, true), VSYNC_ERROR_INVALID_ARGUMENTS);
738 for (int i = 0; i < conns.size(); i++) {
739 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
740 }
741 }
742
743 /*
744 * Function: SetQosVSyncRateTest002
745 * Type: Function
746 * Rank: Important(2)
747 * EnvConditions: N/A
748 * CaseDescription: 1. test SetQosVSyncRate
749 */
750 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateTest002, Function | MediumTest| Level3)
751 {
752 std::vector<sptr<VSyncConnection>> conns;
753 for (int i = 0; i < 10; i++) { // add 10 connections
754 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
755 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
756 ASSERT_EQ(vsyncDistributor->SetHighPriorityVSyncRate(1, conn), VSYNC_ERROR_OK);
757 conns.emplace_back(conn);
758 }
759 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
760 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
761 conns.emplace_back(conn);
762 ASSERT_EQ(vsyncDistributor->SetQosVSyncRate(0x1ffffffff, 1, true), VSYNC_ERROR_OK);
763 for (int i = 0; i < conns.size(); i++) {
764 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
765 }
766 }
767
768 /*
769 * Function: SetQosVSyncRateTest003
770 * Type: Function
771 * Rank: Important(2)
772 * EnvConditions: N/A
773 * CaseDescription: 1. test SetQosVSyncRate
774 */
775 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateTest003, Function | MediumTest| Level3)
776 {
777 std::vector<sptr<VSyncConnection>> conns;
778 for (int i = 0; i < 10; i++) { // add 10 connections
779 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
780 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
781 conns.emplace_back(conn);
782 }
783 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
784 ASSERT_EQ(vsyncDistributor->AddConnection(conn), VSYNC_ERROR_OK);
785 conns.emplace_back(conn);
786 ASSERT_EQ(vsyncDistributor->SetQosVSyncRate(0x1ffffffff, 1, true), VSYNC_ERROR_OK);
787 for (int i = 0; i < conns.size(); i++) {
788 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
789 }
790 }
791
792 /*
793 * Function: SetQosVSyncRateByPidPublicTest001
794 * Type: Function
795 * Rank: Important(2)
796 * EnvConditions: N/A
797 * CaseDescription: 1. test SetQosVSyncRateByPidPublic
798 */
799 HWTEST_F(VSyncDistributorTest, SetQosVSyncRateByPidPublicTest001, Function | MediumTest| Level3)
800 {
801 std::vector<sptr<VSyncConnection>> conns;
802 for (int i = 0; i < 10; i++) { // add 10 connections
803 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "WM_" + std::to_string(i+1));
804 ASSERT_EQ(vsyncDistributor->AddConnection(conn, 1), VSYNC_ERROR_OK);
805 conns.emplace_back(conn);
806 }
807 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPidPublic(0, 1, false), VSYNC_ERROR_OK);
808 ASSERT_EQ(vsyncDistributor->SetQosVSyncRateByPidPublic(0, 2, false), VSYNC_ERROR_OK);
809 for (int i = 0; i < conns.size(); i++) {
810 ASSERT_EQ(vsyncDistributor->RemoveConnection(conns[i]), VSYNC_ERROR_OK);
811 }
812 }
813
814 /*
815 * Function: TriggerNextConnPostEventTest001
816 * Type: Function
817 * Rank: Important(2)
818 * EnvConditions: N/A
819 * CaseDescription: 1. test TriggerNext 2. test ConnPostEvent
820 */
821 HWTEST_F(VSyncDistributorTest, TriggerNextConnPostEventTest001, Function | MediumTest| Level3)
822 {
823 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
824 conn->triggerThisTime_ = false;
825 vsyncDistributor->TriggerNext(conn);
826 vsyncDistributor->ConnPostEvent(conn, 10000000, 8333333, 1);
827 ASSERT_EQ(conn->triggerThisTime_, true);
828 }
829
830 /*
831 * Function: ConnectionsPostEventTest001
832 * Type: Function
833 * Rank: Important(2)
834 * EnvConditions: N/A
835 * CaseDescription: 1. test ConnectionsPostEvent
836 */
837 HWTEST_F(VSyncDistributorTest, ConnectionsPostEventTest001, Function | MediumTest| Level3)
838 {
839 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
840 std::vector<sptr<VSyncConnection>> conns = {conn};
841 int64_t now = 10000000;
842 int64_t period = 16666666;
843 int64_t generatorRefreshRate = 60;
844 int64_t vsyncCount = 1;
845 bool isDvsyncController = false;
846 vsyncDistributor->ConnectionsPostEvent(conns, now, period, generatorRefreshRate, vsyncCount, isDvsyncController);
847 ASSERT_EQ(isDvsyncController, false);
848 }
849
850 /*
851 * Function: DisableDVSyncControllerTest001
852 * Type: Function
853 * Rank: Important(2)
854 * EnvConditions: N/A
855 * CaseDescription: 1. test DisableDVSyncController
856 */
857 HWTEST_F(VSyncDistributorTest, DisableDVSyncControllerTest001, Function | MediumTest| Level3)
858 {
859 vsyncDistributor->dvsyncControllerEnabled_ = false;
860 vsyncDistributor->DisableDVSyncController();
861 ASSERT_EQ(vsyncDistributor->dvsyncControllerEnabled_, false);
862 }
863
864 /*
865 * Function: OnDVSyncEventTest001
866 * Type: Function
867 * Rank: Important(2)
868 * EnvConditions: N/A
869 * CaseDescription: 1. test OnDVSyncEvent
870 */
871 HWTEST_F(VSyncDistributorTest, OnDVSyncEventTest001, Function | MediumTest| Level3)
872 {
873 int64_t now = 10000000;
874 int64_t period = 16666666;
875 uint32_t refreshRate = 60;
876 VSyncMode vsyncMode = VSYNC_MODE_LTPO;
877 uint32_t vsyncMaxRefreshRate = 120;
878 vsyncDistributor->OnDVSyncEvent(now, period, refreshRate, vsyncMode, vsyncMaxRefreshRate);
879 ASSERT_EQ(period, 16666666);
880 }
881
882 /*
883 * Function: InitDVSyncTest001
884 * Type: Function
885 * Rank: Important(2)
886 * EnvConditions: N/A
887 * CaseDescription: 1. test InitDVSync
888 */
889 HWTEST_F(VSyncDistributorTest, InitDVSyncTest001, Function | MediumTest| Level3)
890 {
891 vsyncDistributor->isRs_ = false;
892 vsyncDistributor->InitDVSync();
893 ASSERT_EQ(vsyncDistributor->isRs_, false);
894 }
895
896 /*
897 * Function: DVSyncAddConnectionDVSyncDisableVSyncTest001
898 * Type: Function
899 * Rank: Important(2)
900 * EnvConditions: N/A
901 * CaseDescription: 1. test DVSyncAddConnection 2. test DVSyncDisableVSync
902 */
903 HWTEST_F(VSyncDistributorTest, DVSyncAddConnectionDVSyncDisableVSyncTest001, Function | MediumTest| Level3)
904 {
905 vsyncDistributor->isRs_ = false;
906 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
907 vsyncDistributor->DVSyncAddConnection(conn);
908 vsyncDistributor->DVSyncDisableVSync();
909 ASSERT_EQ(vsyncDistributor->isRs_, false);
910 }
911
912 /*
913 * Function: DVSyncRecordVSyncTest001
914 * Type: Function
915 * Rank: Important(2)
916 * EnvConditions: N/A
917 * CaseDescription: 1. test DVSyncRecordVSync
918 */
919 HWTEST_F(VSyncDistributorTest, DVSyncRecordVSyncTest001, Function | MediumTest| Level3)
920 {
921 int64_t now = 10000000;
922 int64_t period = 16666666;
923 uint32_t refreshRate = 60;
924 bool isDvsyncController = false;
925 vsyncDistributor->DVSyncRecordVSync(now, period, refreshRate, isDvsyncController);
926 ASSERT_EQ(isDvsyncController, false);
927 }
928
929 /*
930 * Function: DVSyncCheckSkipAndUpdateTsTest001
931 * Type: Function
932 * Rank: Important(2)
933 * EnvConditions: N/A
934 * CaseDescription: 1. test DVSyncCheckSkipAndUpdateTs
935 */
936 HWTEST_F(VSyncDistributorTest, DVSyncCheckSkipAndUpdateTsTest001, Function | MediumTest| Level3)
937 {
938 vsyncDistributor->isRs_ = false;
939 int64_t timeStamp = 10000000;
940 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
941 vsyncDistributor->DVSyncCheckSkipAndUpdateTs(conn, timeStamp);
942 ASSERT_EQ(vsyncDistributor->isRs_, false);
943 }
944
945 /*
946 * Function: DVSyncNeedSkipUiTest001
947 * Type: Function
948 * Rank: Important(2)
949 * EnvConditions: N/A
950 * CaseDescription: 1. test DVSyncNeedSkipUi
951 */
952 HWTEST_F(VSyncDistributorTest, DVSyncNeedSkipUiTest001, Function | MediumTest| Level3)
953 {
954 vsyncDistributor->isRs_ = false;
955 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
956 vsyncDistributor->DVSyncNeedSkipUi(conn);
957 ASSERT_EQ(vsyncDistributor->isRs_, false);
958 }
959
960 /*
961 * Function: RecordEnableVsyncTest001
962 * Type: Function
963 * Rank: Important(2)
964 * EnvConditions: N/A
965 * CaseDescription: 1. test RecordEnableVsync
966 */
967 HWTEST_F(VSyncDistributorTest, RecordEnableVsyncTest001, Function | MediumTest| Level3)
968 {
969 vsyncDistributor->isRs_ = false;
970 vsyncDistributor->RecordEnableVsync();
971 ASSERT_EQ(vsyncDistributor->isRs_, false);
972 }
973
974 /*
975 * Function: DVSyncRecordRNVTest001
976 * Type: Function
977 * Rank: Important(2)
978 * EnvConditions: N/A
979 * CaseDescription: 1. test DVSyncRecordRNV
980 */
981 HWTEST_F(VSyncDistributorTest, DVSyncRecordRNVTest001, Function | MediumTest| Level3)
982 {
983 std::string fromWhom = "test";
984 vsyncDistributor->isRs_ = false;
985 int64_t ts = 10000000;
986 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
987 vsyncDistributor->DVSyncRecordRNV(conn, fromWhom, ts);
988 ASSERT_EQ(vsyncDistributor->isRs_, false);
989 }
990
991 /*
992 * Function: DVSyncCheckPreexecuteAndUpdateTsTest001
993 * Type: Function
994 * Rank: Important(2)
995 * EnvConditions: N/A
996 * CaseDescription: 1. test DVSyncCheckPreexecuteAndUpdateTs
997 */
998 HWTEST_F(VSyncDistributorTest, DVSyncCheckPreexecuteAndUpdateTsTest001, Function | MediumTest| Level3)
999 {
1000 vsyncDistributor->isRs_ = false;
1001 int64_t timestamp = 10000000;
1002 int64_t period = 8333333;
1003 int64_t vsyncCount = 1;
1004 sptr<VSyncConnection> conn = new VSyncConnection(vsyncDistributor, "test");
1005 vsyncDistributor->DVSyncCheckPreexecuteAndUpdateTs(conn, timestamp, period, vsyncCount);
1006 ASSERT_EQ(vsyncDistributor->isRs_, false);
1007 }
1008
1009 /*
1010 * Function: NotifyPackageEventTest001
1011 * Type: Function
1012 * Rank: Important(2)
1013 * EnvConditions: N/A
1014 * CaseDescription: 1. test NotifyPackageEvent
1015 */
1016 HWTEST_F(VSyncDistributorTest, NotifyPackageEventTest001, Function | MediumTest| Level3)
1017 {
1018 std::vector<std::string> packageList = {};
1019 vsyncDistributor->NotifyPackageEvent(packageList);
1020 ASSERT_EQ(packageList.size(), 0);
1021 }
1022
1023 /*
1024 * Function: NotifyTouchEventTest001
1025 * Type: Function
1026 * Rank: Important(2)
1027 * EnvConditions: N/A
1028 * CaseDescription: 1. test NotifyTouchEvent
1029 */
1030 HWTEST_F(VSyncDistributorTest, NotifyTouchEventTest001, Function | MediumTest| Level3)
1031 {
1032 int32_t touchStatus = 0;
1033 int32_t touchCnt = 0;
1034 vsyncDistributor->NotifyTouchEvent(touchStatus, touchCnt);
1035 ASSERT_EQ(touchStatus, 0);
1036 }
1037
1038 /*
1039 * Function: AdaptiveDVSyncEnableTest001
1040 * Type: Function
1041 * Rank: Important(2)
1042 * EnvConditions: N/A
1043 * CaseDescription: 1. test AdaptiveDVSyncEnable
1044 */
1045 HWTEST_F(VSyncDistributorTest, AdaptiveDVSyncEnableTest001, Function | MediumTest| Level3)
1046 {
1047 std::string nodeName = "test";
1048 bool needConsume = true;
1049 vsyncDistributor->AdaptiveDVSyncEnable(nodeName, 0, 0, needConsume);
1050 ASSERT_EQ(needConsume, true);
1051 }
1052 } // namespace
1053 } // namespace Rosen
1054 } // namespace OHOS