1 /**************************************************************************
3 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
6 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
7 * Contact: Roman Marchenko <r.marchenko@samsung.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sub license, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
24 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
25 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
35 static void _tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data);
36 static void _tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data);
38 class TDMVblank : public TDMOutput
52 bool TestCreateVblanks(void);
53 bool TestCreateVblanks3(void);
54 void TestDestroyVblanks(void);
56 bool TestPrepareOutput(void);
59 TDMVblank::TDMVblank()
67 void TDMVblank::SetUp(void)
72 void TDMVblank::TearDown(void)
74 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
75 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
76 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, this);
77 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, NULL);
81 tdm_vblank_enable_global_fps(0, 0);
83 TDMOutput::TearDown();
86 bool TDMVblank::TestCreateVblanks(void)
88 TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
90 vblanks = (tdm_vblank**)calloc(output_count, sizeof(tdm_vblank*));
91 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
93 vblank_count = output_count;
96 for (int v = 0; v < vblank_count; v++) {
98 vblanks[v] = tdm_vblank_create(dpy, outputs[v], &ret);
99 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
100 TDM_UT_GOTO_IF_FAIL(vblanks[v] != NULL, failed);
105 TestDestroyVblanks();
110 bool TDMVblank::TestCreateVblanks3(void)
112 TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
118 for (int o = 0; o < output_count; o++) {
119 if (!tc_tdm_output_is_connected(outputs[o]))
125 vblanks = (tdm_vblank**)calloc(vblank_count, sizeof(tdm_vblank*));
126 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
128 for (int v = 0; v < vblank_count; v++) {
129 vblanks[v] = tdm_vblank_create(dpy, outputs[o], &ret);
130 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
131 TDM_UT_GOTO_IF_FAIL(vblanks[v] != NULL, failed);
139 TestDestroyVblanks();
144 void TDMVblank::TestDestroyVblanks(void)
147 for (int v = 0; v < vblank_count; v++)
148 tdm_vblank_destroy(vblanks[v]);
156 bool TDMVblank::TestPrepareOutput(void)
158 for (int o = 0; o < output_count; o++) {
159 if (!tc_tdm_output_is_connected(outputs[o]))
162 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare(dpy, outputs[o], false) == true);
168 bool tc_tdm_vblank_is_avaiable(tdm_vblank *vblank)
171 tdm_output *output = tdm_vblank_get_output(vblank, &ret);
172 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
173 TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
175 /* only check if connected */
176 return tc_tdm_output_is_connected(output);
179 /* tdm_vblank_set_client_vblank_fps */
180 TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
182 /* tested in tc_tdm_client.c */
185 TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
187 ASSERT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER);
188 ASSERT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
191 /* tdm_vblank_set_client_vblank_fps */
192 TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
194 /* tested in tc_tdm_client.c */
197 TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
199 ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
200 ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER);
203 /* tdm_vblank_create() */
204 TEST_P(TDMVblank, VblankCreateDestroy)
206 TDM_UT_SKIP_FLAG(has_outputs);
208 for (int o = 0; o < output_count; o++) {
210 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
211 ASSERT_EQ(ret, TDM_ERROR_NONE);
212 ASSERT_NE(vblank, NULL);
214 tdm_vblank_destroy(vblank);
218 TEST_P(TDMVblank, VblankCreateNullDpy)
220 TDM_UT_SKIP_FLAG(has_outputs);
224 tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret);
225 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
226 ASSERT_EQ(vblank, NULL);
229 TEST_P(TDMVblank, VblankCreateNullOutput)
233 tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret);
234 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
235 ASSERT_EQ(vblank, NULL);
238 TEST_P(TDMVblank, VblankCreateNullOther)
240 TDM_UT_SKIP_FLAG(has_outputs);
242 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
243 ASSERT_NE(vblank, NULL);
245 tdm_vblank_destroy(vblank);
248 /* tdm_vblank_destroy() */
249 TEST_P(TDMVblank, VblankDestroyNullObject)
251 tdm_vblank_destroy(NULL);
255 _tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
257 TDMVblank *test_vblank = (TDMVblank*)user_data;
259 test_vblank->done = true;
262 /* tdm_vblank_add_create_handler */
263 TEST_P(TDMVblank, VblankAddCreateHandler)
265 TDM_UT_SKIP_FLAG(has_outputs);
267 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
269 for (int o = 0; o < output_count; o++) {
274 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
275 ASSERT_EQ(ret, TDM_ERROR_NONE);
276 ASSERT_NE(vblank, NULL);
277 ASSERT_EQ(done, true);
279 tdm_vblank_destroy(vblank);
283 TEST_P(TDMVblank, VblankAddCreateHandlerTwice)
285 TDM_UT_SKIP_FLAG(has_outputs);
287 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
288 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
291 TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
293 TDM_UT_SKIP_FLAG(has_outputs);
295 ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
298 TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
300 TDM_UT_SKIP_FLAG(has_outputs);
302 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
305 /* tdm_vblank_remove_create_handler */
306 TEST_P(TDMVblank, VblankRemoveCreateHandler)
308 TDM_UT_SKIP_FLAG(has_outputs);
310 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
311 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
313 for (int o = 0; o < output_count; o++) {
318 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
319 ASSERT_EQ(ret, TDM_ERROR_NONE);
320 ASSERT_NE(vblank, NULL);
321 ASSERT_EQ(done, false);
323 tdm_vblank_destroy(vblank);
327 TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
329 TDM_UT_SKIP_FLAG(has_outputs);
331 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
333 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
334 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
335 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this);
337 for (int o = 0; o < output_count; o++) {
342 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
343 ASSERT_EQ(ret, TDM_ERROR_NONE);
344 ASSERT_NE(vblank, NULL);
345 ASSERT_EQ(done, false);
347 tdm_vblank_destroy(vblank);
351 TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
353 TDM_UT_SKIP_FLAG(has_outputs);
355 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
357 tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
359 for (int o = 0; o < output_count; o++) {
364 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
365 ASSERT_EQ(ret, TDM_ERROR_NONE);
366 ASSERT_NE(vblank, NULL);
367 ASSERT_EQ(done, true);
369 tdm_vblank_destroy(vblank);
374 _tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
376 TDMVblank *test_vblank = (TDMVblank*)user_data;
377 test_vblank->done = true;
378 tdm_vblank_remove_create_handler(test_vblank->dpy, _tc_tdm_vblank_create_cb2, user_data);
381 TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
383 TDM_UT_SKIP_FLAG(has_outputs);
385 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
387 for (int o = 0; o < output_count; o++) {
392 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
393 ASSERT_EQ(ret, TDM_ERROR_NONE);
394 ASSERT_NE(vblank, NULL);
396 ASSERT_EQ(done, true);
398 ASSERT_EQ(done, false);
400 tdm_vblank_destroy(vblank);
404 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullObject)
406 TDM_UT_SKIP_FLAG(has_outputs);
408 tdm_vblank_remove_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL);
411 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther)
413 TDM_UT_SKIP_FLAG(has_outputs);
415 tdm_vblank_remove_create_handler(dpy, NULL, NULL);
418 /* tdm_vblank_get_output() */
419 TEST_P(TDMVblank, VblankGetOutput)
421 TDM_UT_SKIP_FLAG(has_outputs);
423 ASSERT_EQ(TestCreateVblanks(), true);
425 for (int v = 0; v < vblank_count; v++) {
427 ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
428 ASSERT_EQ(ret, TDM_ERROR_NONE);
432 TEST_P(TDMVblank, VblankGetOutputNullObject)
435 ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
436 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
439 TEST_P(TDMVblank, VblankGetOutputNullOther)
441 TDM_UT_SKIP_FLAG(has_outputs);
443 ASSERT_EQ(TestCreateVblanks(), true);
445 ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
448 /* tdm_vblank_get_client_pid() */
449 TEST_P(TDMVblank, VblankGetClientPid)
451 TDM_UT_SKIP_FLAG(has_outputs);
453 ASSERT_EQ(TestCreateVblanks(), true);
455 for (int v = 0; v < vblank_count; v++) {
456 pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
457 ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE);
458 /* client pid should be 0 in case vblank is created in server side */
463 TEST_P(TDMVblank, VblankGetClientPidNullObject)
465 pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
466 ASSERT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER);
467 ASSERT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE);
470 TEST_P(TDMVblank, VblankGetClientPidNullOther)
472 TDM_UT_SKIP_FLAG(has_outputs);
474 ASSERT_EQ(TestCreateVblanks(), true);
476 ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
479 /* tdm_vblank_set_name() */
480 TEST_P(TDMVblank, VblankSetName)
482 TDM_UT_SKIP_FLAG(has_outputs);
484 ASSERT_EQ(TestCreateVblanks(), true);
486 for (int v = 0; v < vblank_count; v++)
487 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
490 TEST_P(TDMVblank, VblankSetNameNullObject)
492 ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
495 TEST_P(TDMVblank, VblankSetNameNullOther)
497 TDM_UT_SKIP_FLAG(has_outputs);
499 ASSERT_EQ(TestCreateVblanks(), true);
501 for (int v = 0; v < vblank_count; v++)
502 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
505 /* tdm_vblank_get_name() */
506 TEST_P(TDMVblank, VblankGetName)
508 TDM_UT_SKIP_FLAG(has_outputs);
510 ASSERT_EQ(TestCreateVblanks(), true);
512 for (int v = 0; v < vblank_count; v++) {
513 const char *name = (const char *)TDM_UT_INVALID_VALUE;
514 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
515 ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
516 ASSERT_STREQ(name, TDM_UT_VBLANK_NAME);
520 TEST_P(TDMVblank, VblankGetNameNullObject)
522 const char *name = (const char *)TDM_UT_INVALID_VALUE;
523 ASSERT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER);
524 ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
527 TEST_P(TDMVblank, VblankGetNameNullOther)
529 TDM_UT_SKIP_FLAG(has_outputs);
531 ASSERT_EQ(TestCreateVblanks(), true);
533 ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
536 TEST_P(TDMVblank, VblankGetNameNoSet)
538 TDM_UT_SKIP_FLAG(has_outputs);
540 ASSERT_EQ(TestCreateVblanks(), true);
542 for (int v = 0; v < vblank_count; v++) {
543 const char *name = (const char *)TDM_UT_INVALID_VALUE;
544 ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
545 ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME);
549 /* tdm_vblank_set_fps() */
550 TEST_P(TDMVblank, VblankSetFps)
552 TDM_UT_SKIP_FLAG(has_outputs);
554 ASSERT_EQ(TestCreateVblanks(), true);
556 for (int v = 0; v < vblank_count; v++)
557 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
560 TEST_P(TDMVblank, VblankSetFpsNullObject)
562 ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
565 TEST_P(TDMVblank, VblankSetFpsTwice)
567 TDM_UT_SKIP_FLAG(has_outputs);
569 ASSERT_EQ(TestCreateVblanks(), true);
571 for (int v = 0; v < vblank_count; v++) {
572 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
573 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
577 /* tdm_vblank_set_fixed_fps() */
578 TEST_P(TDMVblank, VblankSetFixedFps)
580 TDM_UT_SKIP_FLAG(has_outputs);
582 ASSERT_EQ(TestCreateVblanks(), true);
584 for (int v = 0; v < vblank_count; v++)
585 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
588 TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
590 ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
593 TEST_P(TDMVblank, VblankSetFixedFpsTwice)
595 TDM_UT_SKIP_FLAG(has_outputs);
597 ASSERT_EQ(TestCreateVblanks(), true);
599 for (int v = 0; v < vblank_count; v++) {
600 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
601 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
605 /* tdm_vblank_get_fps() */
606 TEST_P(TDMVblank, VblankGetFps)
608 TDM_UT_SKIP_FLAG(has_outputs);
610 ASSERT_EQ(TestCreateVblanks(), true);
612 for (int v = 0; v < vblank_count; v++) {
613 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
614 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
615 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
620 TEST_P(TDMVblank, VblankGetFpsNullObject)
622 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
623 ASSERT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER);
624 ASSERT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE);
627 TEST_P(TDMVblank, VblankGetFpsNullOther)
629 TDM_UT_SKIP_FLAG(has_outputs);
631 ASSERT_EQ(TestCreateVblanks(), true);
633 ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
636 TEST_P(TDMVblank, VblankGetFpsNoSet)
638 TDM_UT_SKIP_FLAG(has_outputs);
640 ASSERT_EQ(TestPrepareOutput(), true);
641 ASSERT_EQ(TestCreateVblanks(), true);
643 for (int v = 0; v < vblank_count; v++) {
644 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
645 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
648 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
651 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
652 ASSERT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
654 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
655 ASSERT_NE(output, NULL);
656 ASSERT_EQ(ret, TDM_ERROR_NONE);
658 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
659 ASSERT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
661 ASSERT_EQ(fps, mode->vrefresh);
665 TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps)
667 TDM_UT_SKIP_FLAG(has_outputs);
669 ASSERT_EQ(TestCreateVblanks(), true);
671 for (int v = 0; v < vblank_count; v++) {
672 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
674 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
675 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
678 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE);
679 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
682 /* should return TDM_ERROR_NONE because tdm_vblank_set_fixed_fps would be
683 * called by other who call tdm_vblank_set_fps. If returns error, other
684 * can't handle error.
686 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
687 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
692 /* tdm_vblank_ignore_global_fps() */
693 TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
695 ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
698 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
700 TDM_UT_SKIP_FLAG(has_outputs);
702 ASSERT_EQ(TestCreateVblanks(), true);
704 for (int v = 0; v < vblank_count; v++)
705 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
708 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
710 TDM_UT_SKIP_FLAG(has_outputs);
712 ASSERT_EQ(TestCreateVblanks(), true);
714 for (int v = 0; v < vblank_count; v++) {
715 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
716 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
720 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset)
722 TDM_UT_SKIP_FLAG(has_outputs);
724 ASSERT_EQ(TestCreateVblanks(), true);
726 for (int v = 0; v < vblank_count; v++)
727 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
730 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
732 TDM_UT_SKIP_FLAG(has_outputs);
734 ASSERT_EQ(TestCreateVblanks(), true);
736 for (int v = 0; v < vblank_count; v++) {
737 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
738 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
742 /* tdm_vblank_set_offset() */
743 TEST_P(TDMVblank, VblankSetOffset)
745 TDM_UT_SKIP_FLAG(has_outputs);
747 ASSERT_EQ(TestCreateVblanks(), true);
749 for (int v = 0; v < vblank_count; v++)
750 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
753 TEST_P(TDMVblank, VblankSetOffsetNullObject)
755 ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
758 TEST_P(TDMVblank, VblankSetOffsetTwice)
760 TDM_UT_SKIP_FLAG(has_outputs);
762 ASSERT_EQ(TestCreateVblanks(), true);
764 for (int v = 0; v < vblank_count; v++) {
765 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
766 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
770 /* tdm_vblank_get_offset() */
771 TEST_P(TDMVblank, VblankGetOffset)
773 TDM_UT_SKIP_FLAG(has_outputs);
775 ASSERT_EQ(TestCreateVblanks(), true);
777 for (int v = 0; v < vblank_count; v++) {
778 int offset = TDM_UT_INVALID_VALUE;
779 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
780 ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
781 ASSERT_EQ(offset, 10);
785 TEST_P(TDMVblank, VblankGetOffsetNullObject)
787 int offset = TDM_UT_INVALID_VALUE;
788 ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER);
789 ASSERT_EQ(offset, TDM_UT_INVALID_VALUE);
792 TEST_P(TDMVblank, VblankGetOffsetNullOther)
794 TDM_UT_SKIP_FLAG(has_outputs);
796 ASSERT_EQ(TestCreateVblanks(), true);
798 ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
801 TEST_P(TDMVblank, VblankGetOffsetNoSet)
803 TDM_UT_SKIP_FLAG(has_outputs);
805 ASSERT_EQ(TestCreateVblanks(), true);
807 for (int v = 0; v < vblank_count; v++) {
808 int offset = TDM_UT_INVALID_VALUE;
809 ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
810 ASSERT_EQ(offset, 0);
814 /* tdm_vblank_set_enable_fake() */
815 TEST_P(TDMVblank, VblankSetEnableFake)
817 TDM_UT_SKIP_FLAG(has_outputs);
819 ASSERT_EQ(TestCreateVblanks(), true);
821 for (int v = 0; v < vblank_count; v++)
822 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
825 TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
827 ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
830 TEST_P(TDMVblank, VblankSetEnableFakeTwice)
832 TDM_UT_SKIP_FLAG(has_outputs);
834 ASSERT_EQ(TestCreateVblanks(), true);
836 for (int v = 0; v < vblank_count; v++) {
837 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
838 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
842 /* tdm_vblank_get_enable_fake() */
843 TEST_P(TDMVblank, VblankGetEnableFake)
845 TDM_UT_SKIP_FLAG(has_outputs);
847 ASSERT_EQ(TestCreateVblanks(), true);
849 for (int v = 0; v < vblank_count; v++) {
850 unsigned int enable_fake;
851 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
852 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
853 ASSERT_EQ(enable_fake, 1);
855 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE);
856 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
857 ASSERT_EQ(enable_fake, 0);
861 TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
863 unsigned int enable_fake = (unsigned int)TDM_UT_INVALID_VALUE;
864 ASSERT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER);
865 ASSERT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE);
868 TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
870 TDM_UT_SKIP_FLAG(has_outputs);
872 ASSERT_EQ(TestCreateVblanks(), true);
874 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
877 TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
879 TDM_UT_SKIP_FLAG(has_outputs);
881 ASSERT_EQ(TestCreateVblanks(), true);
883 for (int v = 0; v < vblank_count; v++) {
884 unsigned int enable_fake;
885 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
886 ASSERT_EQ(enable_fake, 0);
891 _tc_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
892 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
894 unsigned int *cur_seq = (unsigned int *)user_data;
896 *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1);
899 TEST_P(TDMVblank, VblankWait)
901 TDM_UT_SKIP_FLAG(has_outputs);
903 ASSERT_EQ(TestPrepareOutput(), true);
904 ASSERT_EQ(TestCreateVblanks(), true);
906 for (int v = 0; v < vblank_count; v++) {
907 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
908 double start, end, interval;
910 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
913 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
914 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
915 interval = 1.0 / (double)fps;
917 for (int t = 0; t < 10; t++) {
918 unsigned int cur_seq = 0;
920 start = tdm_helper_get_time();
921 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
923 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
924 end = tdm_helper_get_time();
926 /* "+ interval" consider the delay of socket communication between kernel and platform */
927 ASSERT_LT((end - start), (interval + interval));
932 TEST_P(TDMVblank, VblankWaitFewTime)
934 TDM_UT_SKIP_FLAG(has_outputs);
936 ASSERT_EQ(TestPrepareOutput(), true);
937 ASSERT_EQ(TestCreateVblanks(), true);
939 for (int v = 0; v < vblank_count; v++) {
940 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
941 double start, end, interval;
943 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
946 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
947 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
948 interval = 1.0 / (double)fps;
950 for (int t = 0; t < 10; t++) {
951 unsigned int cur_seq, seq1, seq2;
953 cur_seq = seq1 = seq2 = 0;
954 start = tdm_helper_get_time();
955 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
956 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
957 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
959 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
960 end = tdm_helper_get_time();
965 /* "+ interval" consider the delay of socket communication between kernel and platform */
966 ASSERT_LT((end - start), (interval + interval));
971 TEST_P(TDMVblank, VblankWaitInterval0)
973 TDM_UT_SKIP_FLAG(has_outputs);
975 ASSERT_EQ(TestPrepareOutput(), true);
976 ASSERT_EQ(TestCreateVblanks(), true);
978 ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
981 TEST_P(TDMVblank, VblankWaitInterval)
983 TDM_UT_SKIP_FLAG(has_outputs);
985 ASSERT_EQ(TestPrepareOutput(), true);
986 ASSERT_EQ(TestCreateVblanks(), true);
988 for (int v = 0; v < vblank_count; v++) {
989 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
990 double start, end, interval;
992 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
995 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
996 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
997 interval = 1.0 / (double)fps;
1000 for (int t = 1; t < 10; t++) {
1001 unsigned int cur_seq = 0;
1003 start = tdm_helper_get_time();
1004 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1005 while (cur_seq == 0)
1006 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1007 end = tdm_helper_get_time();
1009 /* "+ interval" consider the delay of socket communication between kernel and platform */
1010 ASSERT_GT((end - start), interval * (t - 1));
1011 ASSERT_LT((end - start), interval * t + interval);
1016 TEST_P(TDMVblank, VblankWaitSeq)
1018 TDM_UT_SKIP_FLAG(has_outputs);
1020 ASSERT_EQ(TestPrepareOutput(), true);
1021 ASSERT_EQ(TestCreateVblanks(), true);
1023 for (int v = 0; v < vblank_count; v++) {
1024 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1025 double start, end, interval;
1027 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1030 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1031 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1032 interval = 1.0 / (double)fps;
1034 for (int t = 0; t < 10; t++) {
1035 unsigned int cur_seq = 0, temp = 0;
1037 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1038 while (cur_seq == 0)
1039 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1041 start = tdm_helper_get_time();
1042 ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1044 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1045 end = tdm_helper_get_time();
1047 /* "+ interval" consider the delay of socket communication between kernel and platform */
1048 ASSERT_LT((end - start), (interval + interval));
1053 TEST_P(TDMVblank, VblankWaitSeqInterval)
1055 TDM_UT_SKIP_FLAG(has_outputs);
1057 ASSERT_EQ(TestPrepareOutput(), true);
1058 ASSERT_EQ(TestCreateVblanks(), true);
1060 for (int v = 0; v < vblank_count; v++) {
1061 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1062 double start, end, interval;
1064 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1067 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1068 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1069 interval = 1.0 / (double)fps;
1072 for (int t = 1; t < 10; t++) {
1073 unsigned int cur_seq = 0, temp = 0;
1075 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1076 while (cur_seq == 0)
1077 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1079 start = tdm_helper_get_time();
1080 ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1082 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1083 end = tdm_helper_get_time();
1085 /* "+ interval" consider the delay of socket communication between kernel and platform */
1086 ASSERT_GT((end - start), (interval * (t - 1)));
1087 ASSERT_LT((end - start), (interval * t + interval));
1092 TEST_P(TDMVblank, VblankWaitNullObject)
1094 TDM_UT_SKIP_FLAG(has_outputs);
1096 unsigned int cur_seq = 0;
1098 ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1101 TEST_P(TDMVblank, VblankWaitNullOther)
1103 TDM_UT_SKIP_FLAG(has_outputs);
1105 ASSERT_EQ(TestCreateVblanks(), true);
1107 ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1110 TEST_P(TDMVblank, VblankWaitDpmsOff)
1112 TDM_UT_SKIP_FLAG(has_outputs);
1114 ASSERT_EQ(TestPrepareOutput(), true);
1115 ASSERT_EQ(TestCreateVblanks(), true);
1117 for (int v = 0; v < vblank_count; v++) {
1119 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1120 ASSERT_EQ(ret, TDM_ERROR_NONE);
1122 if (!tc_tdm_output_is_connected(output))
1125 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1127 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
1131 TEST_P(TDMVblank, VblankWaitBeforeDpmsOff)
1133 TDM_UT_SKIP_FLAG(has_outputs);
1135 ASSERT_EQ(TestPrepareOutput(), true);
1136 ASSERT_EQ(TestCreateVblanks(), true);
1138 for (int v = 0; v < vblank_count; v++) {
1139 unsigned int temp = 0;
1141 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1142 ASSERT_EQ(ret, TDM_ERROR_NONE);
1144 if (!tc_tdm_output_is_connected(output))
1147 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1149 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1152 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1156 TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
1158 TDM_UT_SKIP_FLAG(has_outputs);
1160 ASSERT_EQ(TestPrepareOutput(), true);
1161 ASSERT_EQ(TestCreateVblanks(), true);
1163 for (int v = 0; v < vblank_count; v++) {
1165 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1166 ASSERT_EQ(ret, TDM_ERROR_NONE);
1168 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1171 if (!tc_tdm_output_is_connected(output))
1174 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1176 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
1178 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1182 TEST_P(TDMVblank, VblankWaitDisconnectedOutput)
1184 TDM_UT_SKIP_FLAG(has_outputs);
1186 ASSERT_EQ(TestPrepareOutput(), true);
1187 ASSERT_EQ(TestCreateVblanks(), true);
1189 for (int v = 0; v < vblank_count; v++) {
1191 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1192 ASSERT_EQ(ret, TDM_ERROR_NONE);
1194 if (tc_tdm_output_is_connected(output))
1197 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
1201 TEST_P(TDMVblank, VblankWaitSetOffset)
1203 TDM_UT_SKIP_FLAG(has_outputs);
1205 ASSERT_EQ(TestPrepareOutput(), true);
1206 ASSERT_EQ(TestCreateVblanks(), true);
1208 for (int v = 0; v < vblank_count; v++) {
1209 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1210 double start, end, interval;
1212 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1215 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
1217 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1218 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1219 interval = 1.0 / (double)fps;
1221 for (int t = 0; t < 3; t++) {
1222 unsigned int cur_seq = 0;
1224 start = tdm_helper_get_time();
1225 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1226 while (cur_seq == 0)
1227 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1228 end = tdm_helper_get_time();
1230 /* "+ interval" consider the delay of socket communication between kernel and platform */
1231 ASSERT_GT((end - start), (0.1));
1232 ASSERT_LT((end - start), (interval + interval + 0.1));
1237 TEST_P(TDMVblank, VblankWaitSetFps)
1239 TDM_UT_SKIP_FLAG(has_outputs);
1241 ASSERT_EQ(TestPrepareOutput(), true);
1242 ASSERT_EQ(TestCreateVblanks(), true);
1244 for (int v = 0; v < vblank_count; v++) {
1245 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1246 double start, end, interval, vrefresh_interval;
1248 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1251 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1252 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1253 vrefresh_interval = 1.0 / (double)fps;
1256 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1257 interval = 1.0 / (double)fps;
1259 for (int t = 0; t < 3; t++) {
1260 unsigned int cur_seq = 0;
1262 start = tdm_helper_get_time();
1263 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1264 while (cur_seq == 0)
1265 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1266 end = tdm_helper_get_time();
1268 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1269 ASSERT_GT((end - start), (interval - vrefresh_interval));
1270 ASSERT_LT((end - start), (interval + vrefresh_interval));
1275 TEST_P(TDMVblank, VblankWaitSetFixedFps)
1277 TDM_UT_SKIP_FLAG(has_outputs);
1279 ASSERT_EQ(TestPrepareOutput(), true);
1280 ASSERT_EQ(TestCreateVblanks(), true);
1282 for (int v = 0; v < vblank_count; v++) {
1283 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1284 double start, end, interval;
1286 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1289 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1290 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1291 interval = 1.0 / (double)fps;
1293 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
1295 /* this fps will be ignored because it has fixed fps value */
1297 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1299 for (int t = 0; t < 3; t++) {
1300 unsigned int cur_seq = 0;
1302 start = tdm_helper_get_time();
1303 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1304 while (cur_seq == 0)
1305 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1306 end = tdm_helper_get_time();
1308 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1309 ASSERT_LT((end - start), (interval + interval));
1314 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1316 TDM_UT_SKIP_FLAG(has_outputs);
1318 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1319 double vrefresh_interval;
1320 unsigned int cur_seq[3];
1321 unsigned int global_fps = 5;
1322 double start, end, interval;
1324 ASSERT_EQ(TestPrepareOutput(), true);
1325 ASSERT_EQ(TestCreateVblanks3(), true);
1326 ASSERT_EQ(vblank_count, 3);
1328 if (!tc_tdm_vblank_is_avaiable(vblanks[0]))
1331 ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1332 ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1333 vrefresh_interval = 1.0 / (double)fps;
1335 for (int v = 0; v < 3; v++) {
1336 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
1337 interval = 1.0 / (double)(10 * (v + 1));
1340 /* enable test. global fps doesn't effect server's vblanks */
1341 tdm_vblank_enable_global_fps(1, global_fps);
1343 for (int v = 0; v < 3; v++) {
1345 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1348 start = tdm_helper_get_time();
1349 while (cur_seq[2] == 0)
1350 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1351 end = tdm_helper_get_time();
1353 /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
1354 ASSERT_GT((end - start), (interval - vrefresh_interval));
1355 ASSERT_LT((end - start), (interval + vrefresh_interval));
1357 ASSERT_EQ(cur_seq[1], 0);
1358 ASSERT_EQ(cur_seq[0], 0);
1360 while (cur_seq[1] == 0)
1361 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1362 ASSERT_EQ(cur_seq[0], 0);
1364 while (cur_seq[0] == 0)
1365 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1367 /* disable test. global fps doesn't effect server's vblanks */
1368 tdm_vblank_enable_global_fps(0, 0);
1370 for (int v = 0; v < 3; v++) {
1372 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1375 while (cur_seq[2] == 0)
1376 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1377 ASSERT_EQ(cur_seq[1], 0);
1378 ASSERT_EQ(cur_seq[0], 0);
1380 while (cur_seq[1] == 0)
1381 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1382 ASSERT_EQ(cur_seq[0], 0);
1385 TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
1387 TDM_UT_SKIP_FLAG(has_outputs);
1389 ASSERT_EQ(TestPrepareOutput(), true);
1390 ASSERT_EQ(TestCreateVblanks(), true);
1392 for (int v = 0; v < vblank_count; v++) {
1394 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1395 ASSERT_EQ(ret, TDM_ERROR_NONE);
1397 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1400 if (tc_tdm_output_is_connected(output))
1403 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
1405 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1409 TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff)
1411 /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */
1414 TEST_P(TDMVblank, VblankWaitTimeout)
1416 TDM_UT_SKIP_FLAG(has_outputs);
1418 ASSERT_EQ(TestPrepareOutput(), true);
1419 ASSERT_EQ(TestCreateVblanks(), true);
1421 if (vblank_count > 0) {
1422 tdm_vblank *vblank = vblanks[0];
1423 unsigned int cur_seq = 0;
1425 ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1427 while (cur_seq == 0)
1428 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1432 #ifdef TDM_UT_TEST_WITH_PARAMS
1433 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1435 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1437 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1439 Values(TDM_DEFAULT_MODULE));