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 **************************************************************************/
33 static void _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data);
34 static void _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data);
36 class TDMVblank : public TDMOutput
50 bool TestCreateVblanks(void);
51 bool TestCreateVblanks3(void);
52 void TestDestroyVblanks(void);
54 bool TestPrepareOutput(void);
57 TDMVblank::TDMVblank()
65 void TDMVblank::SetUp(void)
70 void TDMVblank::TearDown(void)
72 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
73 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
74 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, this);
75 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, NULL);
79 tdm_vblank_enable_global_fps(0, 0);
81 TDMOutput::TearDown();
84 bool TDMVblank::TestCreateVblanks(void)
86 TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
88 vblanks = (tdm_vblank**)calloc(output_count, sizeof(tdm_vblank*));
89 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
91 vblank_count = output_count;
94 for (int v = 0; v < vblank_count; v++) {
96 vblanks[v] = tdm_vblank_create(dpy, outputs[v], &ret);
97 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
98 TDM_UT_GOTO_IF_FAIL(vblanks[v] != NULL, failed);
103 TestDestroyVblanks();
108 bool TDMVblank::TestCreateVblanks3(void)
110 TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
116 for (int o = 0; o < output_count; o++) {
117 if (!ut_tdm_output_is_connected(outputs[o]))
123 vblanks = (tdm_vblank**)calloc(vblank_count, sizeof(tdm_vblank*));
124 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
126 for (int v = 0; v < vblank_count; v++) {
127 vblanks[v] = tdm_vblank_create(dpy, outputs[o], &ret);
128 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
129 TDM_UT_GOTO_IF_FAIL(vblanks[v] != NULL, failed);
137 TestDestroyVblanks();
142 void TDMVblank::TestDestroyVblanks(void)
145 for (int v = 0; v < vblank_count; v++)
146 tdm_vblank_destroy(vblanks[v]);
154 bool TDMVblank::TestPrepareOutput(void)
156 for (int o = 0; o < output_count; o++) {
157 if (!ut_tdm_output_is_connected(outputs[o]))
160 TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true);
166 bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank)
169 tdm_output *output = tdm_vblank_get_output(vblank, &ret);
170 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
171 TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
173 /* only check if connected */
174 return ut_tdm_output_is_connected(output);
177 /* tdm_vblank_set_client_vblank_fps */
178 TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
180 /* tested in ut_tdm_client.c */
183 TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
185 ASSERT_EQ(tdm_vblank_set_client_vblank_fps(0, NULL, 60), TDM_ERROR_INVALID_PARAMETER);
186 ASSERT_EQ(tdm_vblank_set_client_vblank_fps(123, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
189 /* tdm_vblank_set_client_vblank_fps */
190 TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
192 /* tested in ut_tdm_client.c */
195 TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
197 ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 0), TDM_ERROR_INVALID_PARAMETER);
198 ASSERT_EQ(tdm_vblank_set_client_ignore_global_fps(0, NULL, 1), TDM_ERROR_INVALID_PARAMETER);
201 /* tdm_vblank_create() */
202 TEST_P(TDMVblank, VblankCreateDestroy)
204 TDM_UT_SKIP_FLAG(has_outputs);
206 for (int o = 0; o < output_count; o++) {
208 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
209 ASSERT_EQ(ret, TDM_ERROR_NONE);
210 ASSERT_NE(vblank, NULL);
212 tdm_vblank_destroy(vblank);
216 TEST_P(TDMVblank, VblankCreateNullDpy)
218 TDM_UT_SKIP_FLAG(has_outputs);
222 tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret);
223 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
224 ASSERT_EQ(vblank, NULL);
227 TEST_P(TDMVblank, VblankCreateNullOutput)
231 tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret);
232 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
233 ASSERT_EQ(vblank, NULL);
236 TEST_P(TDMVblank, VblankCreateNullOther)
238 TDM_UT_SKIP_FLAG(has_outputs);
240 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
241 ASSERT_NE(vblank, NULL);
243 tdm_vblank_destroy(vblank);
246 /* tdm_vblank_destroy() */
247 TEST_P(TDMVblank, VblankDestroyNullObject)
249 tdm_vblank_destroy(NULL);
253 _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
255 TDMVblank *test_vblank = (TDMVblank*)user_data;
257 test_vblank->done = true;
260 /* tdm_vblank_add_create_handler */
261 TEST_P(TDMVblank, VblankAddCreateHandler)
263 TDM_UT_SKIP_FLAG(has_outputs);
265 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
267 for (int o = 0; o < output_count; o++) {
272 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
273 ASSERT_EQ(ret, TDM_ERROR_NONE);
274 ASSERT_NE(vblank, NULL);
275 ASSERT_EQ(done, true);
277 tdm_vblank_destroy(vblank);
281 TEST_P(TDMVblank, VblankAddCreateHandlerTwice)
283 TDM_UT_SKIP_FLAG(has_outputs);
285 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE);
286 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST);
289 TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
291 TDM_UT_SKIP_FLAG(has_outputs);
293 ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
296 TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
298 TDM_UT_SKIP_FLAG(has_outputs);
300 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
303 /* tdm_vblank_remove_create_handler */
304 TEST_P(TDMVblank, VblankRemoveCreateHandler)
306 TDM_UT_SKIP_FLAG(has_outputs);
308 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
309 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
311 for (int o = 0; o < output_count; o++) {
316 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
317 ASSERT_EQ(ret, TDM_ERROR_NONE);
318 ASSERT_NE(vblank, NULL);
319 ASSERT_EQ(done, false);
321 tdm_vblank_destroy(vblank);
325 TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
327 TDM_UT_SKIP_FLAG(has_outputs);
329 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
331 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
332 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
333 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this);
335 for (int o = 0; o < output_count; o++) {
340 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
341 ASSERT_EQ(ret, TDM_ERROR_NONE);
342 ASSERT_NE(vblank, NULL);
343 ASSERT_EQ(done, false);
345 tdm_vblank_destroy(vblank);
349 TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
351 TDM_UT_SKIP_FLAG(has_outputs);
353 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
355 tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
357 for (int o = 0; o < output_count; o++) {
362 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
363 ASSERT_EQ(ret, TDM_ERROR_NONE);
364 ASSERT_NE(vblank, NULL);
365 ASSERT_EQ(done, true);
367 tdm_vblank_destroy(vblank);
372 _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
374 TDMVblank *test_vblank = (TDMVblank*)user_data;
375 test_vblank->done = true;
376 tdm_vblank_remove_create_handler(test_vblank->dpy, _ut_tdm_vblank_create_cb2, user_data);
379 TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
381 TDM_UT_SKIP_FLAG(has_outputs);
383 ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
385 for (int o = 0; o < output_count; o++) {
390 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
391 ASSERT_EQ(ret, TDM_ERROR_NONE);
392 ASSERT_NE(vblank, NULL);
394 ASSERT_EQ(done, true);
396 ASSERT_EQ(done, false);
398 tdm_vblank_destroy(vblank);
402 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullObject)
404 TDM_UT_SKIP_FLAG(has_outputs);
406 tdm_vblank_remove_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL);
409 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther)
411 TDM_UT_SKIP_FLAG(has_outputs);
413 tdm_vblank_remove_create_handler(dpy, NULL, NULL);
416 /* tdm_vblank_get_output() */
417 TEST_P(TDMVblank, VblankGetOutput)
419 TDM_UT_SKIP_FLAG(has_outputs);
421 ASSERT_EQ(TestCreateVblanks(), true);
423 for (int v = 0; v < vblank_count; v++) {
425 ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
426 ASSERT_EQ(ret, TDM_ERROR_NONE);
430 TEST_P(TDMVblank, VblankGetOutputNullObject)
433 ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
434 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
437 TEST_P(TDMVblank, VblankGetOutputNullOther)
439 TDM_UT_SKIP_FLAG(has_outputs);
441 ASSERT_EQ(TestCreateVblanks(), true);
443 ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
446 /* tdm_vblank_get_client_pid() */
447 TEST_P(TDMVblank, VblankGetClientPid)
449 TDM_UT_SKIP_FLAG(has_outputs);
451 ASSERT_EQ(TestCreateVblanks(), true);
453 for (int v = 0; v < vblank_count; v++) {
454 pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
455 ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[v], &pid), TDM_ERROR_NONE);
456 /* client pid should be 0 in case vblank is created in server side */
461 TEST_P(TDMVblank, VblankGetClientPidNullObject)
463 pid_t pid = (pid_t)TDM_UT_INVALID_VALUE;
464 ASSERT_EQ(tdm_vblank_get_client_pid(NULL, &pid), TDM_ERROR_INVALID_PARAMETER);
465 ASSERT_EQ(pid, (pid_t)TDM_UT_INVALID_VALUE);
468 TEST_P(TDMVblank, VblankGetClientPidNullOther)
470 TDM_UT_SKIP_FLAG(has_outputs);
472 ASSERT_EQ(TestCreateVblanks(), true);
474 ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
477 /* tdm_vblank_set_name() */
478 TEST_P(TDMVblank, VblankSetName)
480 TDM_UT_SKIP_FLAG(has_outputs);
482 ASSERT_EQ(TestCreateVblanks(), true);
484 for (int v = 0; v < vblank_count; v++)
485 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
488 TEST_P(TDMVblank, VblankSetNameNullObject)
490 ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
493 TEST_P(TDMVblank, VblankSetNameNullOther)
495 TDM_UT_SKIP_FLAG(has_outputs);
497 ASSERT_EQ(TestCreateVblanks(), true);
499 for (int v = 0; v < vblank_count; v++)
500 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
503 /* tdm_vblank_get_name() */
504 TEST_P(TDMVblank, VblankGetName)
506 TDM_UT_SKIP_FLAG(has_outputs);
508 ASSERT_EQ(TestCreateVblanks(), true);
510 for (int v = 0; v < vblank_count; v++) {
511 const char *name = (const char *)TDM_UT_INVALID_VALUE;
512 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
513 ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
514 ASSERT_STREQ(name, TDM_UT_VBLANK_NAME);
518 TEST_P(TDMVblank, VblankGetNameNullObject)
520 const char *name = (const char *)TDM_UT_INVALID_VALUE;
521 ASSERT_EQ(tdm_vblank_get_name(NULL, &name), TDM_ERROR_INVALID_PARAMETER);
522 ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
525 TEST_P(TDMVblank, VblankGetNameNullOther)
527 TDM_UT_SKIP_FLAG(has_outputs);
529 ASSERT_EQ(TestCreateVblanks(), true);
531 ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
534 TEST_P(TDMVblank, VblankGetNameNoSet)
536 TDM_UT_SKIP_FLAG(has_outputs);
538 ASSERT_EQ(TestCreateVblanks(), true);
540 for (int v = 0; v < vblank_count; v++) {
541 const char *name = (const char *)TDM_UT_INVALID_VALUE;
542 ASSERT_EQ(tdm_vblank_get_name(vblanks[v], &name), TDM_ERROR_NONE);
543 ASSERT_STREQ(name, TDM_VBLANK_DEFAULT_NAME);
547 /* tdm_vblank_set_fps() */
548 TEST_P(TDMVblank, VblankSetFps)
550 TDM_UT_SKIP_FLAG(has_outputs);
552 ASSERT_EQ(TestCreateVblanks(), true);
554 for (int v = 0; v < vblank_count; v++)
555 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
558 TEST_P(TDMVblank, VblankSetFpsNullObject)
560 ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
563 TEST_P(TDMVblank, VblankSetFpsTwice)
565 TDM_UT_SKIP_FLAG(has_outputs);
567 ASSERT_EQ(TestCreateVblanks(), true);
569 for (int v = 0; v < vblank_count; v++) {
570 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
571 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
575 /* tdm_vblank_set_fixed_fps() */
576 TEST_P(TDMVblank, VblankSetFixedFps)
578 TDM_UT_SKIP_FLAG(has_outputs);
580 ASSERT_EQ(TestCreateVblanks(), true);
582 for (int v = 0; v < vblank_count; v++)
583 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
586 TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
588 ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
591 TEST_P(TDMVblank, VblankSetFixedFpsTwice)
593 TDM_UT_SKIP_FLAG(has_outputs);
595 ASSERT_EQ(TestCreateVblanks(), true);
597 for (int v = 0; v < vblank_count; v++) {
598 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
599 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
603 /* tdm_vblank_get_fps() */
604 TEST_P(TDMVblank, VblankGetFps)
606 TDM_UT_SKIP_FLAG(has_outputs);
608 ASSERT_EQ(TestCreateVblanks(), true);
610 for (int v = 0; v < vblank_count; v++) {
611 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
612 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
613 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
618 TEST_P(TDMVblank, VblankGetFpsNullObject)
620 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
621 ASSERT_EQ(tdm_vblank_get_fps(NULL, &fps), TDM_ERROR_INVALID_PARAMETER);
622 ASSERT_EQ(fps, (unsigned int)TDM_UT_INVALID_VALUE);
625 TEST_P(TDMVblank, VblankGetFpsNullOther)
627 TDM_UT_SKIP_FLAG(has_outputs);
629 ASSERT_EQ(TestCreateVblanks(), true);
631 ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
634 TEST_P(TDMVblank, VblankGetFpsNoSet)
636 TDM_UT_SKIP_FLAG(has_outputs);
638 ASSERT_EQ(TestPrepareOutput(), true);
639 ASSERT_EQ(TestCreateVblanks(), true);
641 for (int v = 0; v < vblank_count; v++) {
642 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
643 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
646 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
649 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
650 ASSERT_TRUE(fps != 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
652 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
653 ASSERT_NE(output, NULL);
654 ASSERT_EQ(ret, TDM_ERROR_NONE);
656 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
657 ASSERT_TRUE(mode != NULL && mode != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
659 ASSERT_EQ(fps, mode->vrefresh);
663 TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps)
665 TDM_UT_SKIP_FLAG(has_outputs);
667 ASSERT_EQ(TestCreateVblanks(), true);
669 for (int v = 0; v < vblank_count; v++) {
670 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
672 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
673 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
676 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10), TDM_ERROR_NONE);
677 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
680 /* should return TDM_ERROR_NONE because tdm_vblank_set_fixed_fps would be
681 * called by other who call tdm_vblank_set_fps. If returns error, other
682 * can't handle error.
684 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
685 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
690 /* tdm_vblank_ignore_global_fps() */
691 TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
693 ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
696 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
698 TDM_UT_SKIP_FLAG(has_outputs);
700 ASSERT_EQ(TestCreateVblanks(), true);
702 for (int v = 0; v < vblank_count; v++)
703 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
706 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
708 TDM_UT_SKIP_FLAG(has_outputs);
710 ASSERT_EQ(TestCreateVblanks(), true);
712 for (int v = 0; v < vblank_count; v++) {
713 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
714 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
718 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset)
720 TDM_UT_SKIP_FLAG(has_outputs);
722 ASSERT_EQ(TestCreateVblanks(), true);
724 for (int v = 0; v < vblank_count; v++)
725 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
728 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
730 TDM_UT_SKIP_FLAG(has_outputs);
732 ASSERT_EQ(TestCreateVblanks(), true);
734 for (int v = 0; v < vblank_count; v++) {
735 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
736 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
740 /* tdm_vblank_set_offset() */
741 TEST_P(TDMVblank, VblankSetOffset)
743 TDM_UT_SKIP_FLAG(has_outputs);
745 ASSERT_EQ(TestCreateVblanks(), true);
747 for (int v = 0; v < vblank_count; v++)
748 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
751 TEST_P(TDMVblank, VblankSetOffsetNullObject)
753 ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
756 TEST_P(TDMVblank, VblankSetOffsetTwice)
758 TDM_UT_SKIP_FLAG(has_outputs);
760 ASSERT_EQ(TestCreateVblanks(), true);
762 for (int v = 0; v < vblank_count; v++) {
763 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
764 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
768 /* tdm_vblank_get_offset() */
769 TEST_P(TDMVblank, VblankGetOffset)
771 TDM_UT_SKIP_FLAG(has_outputs);
773 ASSERT_EQ(TestCreateVblanks(), true);
775 for (int v = 0; v < vblank_count; v++) {
776 int offset = TDM_UT_INVALID_VALUE;
777 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
778 ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
779 ASSERT_EQ(offset, 10);
783 TEST_P(TDMVblank, VblankGetOffsetNullObject)
785 int offset = TDM_UT_INVALID_VALUE;
786 ASSERT_EQ(tdm_vblank_get_offset(NULL, &offset), TDM_ERROR_INVALID_PARAMETER);
787 ASSERT_EQ(offset, TDM_UT_INVALID_VALUE);
790 TEST_P(TDMVblank, VblankGetOffsetNullOther)
792 TDM_UT_SKIP_FLAG(has_outputs);
794 ASSERT_EQ(TestCreateVblanks(), true);
796 ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
799 TEST_P(TDMVblank, VblankGetOffsetNoSet)
801 TDM_UT_SKIP_FLAG(has_outputs);
803 ASSERT_EQ(TestCreateVblanks(), true);
805 for (int v = 0; v < vblank_count; v++) {
806 int offset = TDM_UT_INVALID_VALUE;
807 ASSERT_EQ(tdm_vblank_get_offset(vblanks[v], &offset), TDM_ERROR_NONE);
808 ASSERT_EQ(offset, 0);
812 /* tdm_vblank_set_enable_fake() */
813 TEST_P(TDMVblank, VblankSetEnableFake)
815 TDM_UT_SKIP_FLAG(has_outputs);
817 ASSERT_EQ(TestCreateVblanks(), true);
819 for (int v = 0; v < vblank_count; v++)
820 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
823 TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
825 ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
828 TEST_P(TDMVblank, VblankSetEnableFakeTwice)
830 TDM_UT_SKIP_FLAG(has_outputs);
832 ASSERT_EQ(TestCreateVblanks(), true);
834 for (int v = 0; v < vblank_count; v++) {
835 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
836 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
840 /* tdm_vblank_get_enable_fake() */
841 TEST_P(TDMVblank, VblankGetEnableFake)
843 TDM_UT_SKIP_FLAG(has_outputs);
845 ASSERT_EQ(TestCreateVblanks(), true);
847 for (int v = 0; v < vblank_count; v++) {
848 unsigned int enable_fake;
849 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
850 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
851 ASSERT_EQ(enable_fake, 1);
853 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 0), TDM_ERROR_NONE);
854 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
855 ASSERT_EQ(enable_fake, 0);
859 TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
861 unsigned int enable_fake = (unsigned int)TDM_UT_INVALID_VALUE;
862 ASSERT_EQ(tdm_vblank_get_enable_fake(NULL, &enable_fake), TDM_ERROR_INVALID_PARAMETER);
863 ASSERT_EQ(enable_fake, (unsigned int)TDM_UT_INVALID_VALUE);
866 TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
868 TDM_UT_SKIP_FLAG(has_outputs);
870 ASSERT_EQ(TestCreateVblanks(), true);
872 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
875 TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
877 TDM_UT_SKIP_FLAG(has_outputs);
879 ASSERT_EQ(TestCreateVblanks(), true);
881 for (int v = 0; v < vblank_count; v++) {
882 unsigned int enable_fake;
883 ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[v], &enable_fake), TDM_ERROR_NONE);
884 ASSERT_EQ(enable_fake, 0);
889 _ut_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
890 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
892 unsigned int *cur_seq = (unsigned int *)user_data;
894 *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1);
897 TEST_P(TDMVblank, VblankWait)
899 TDM_UT_SKIP_FLAG(has_outputs);
901 ASSERT_EQ(TestPrepareOutput(), true);
902 ASSERT_EQ(TestCreateVblanks(), true);
904 for (int v = 0; v < vblank_count; v++) {
905 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
906 double start, end, interval;
908 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
911 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
912 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
913 interval = 1.0 / (double)fps;
915 for (int t = 0; t < 10; t++) {
916 unsigned int cur_seq = 0;
918 start = tdm_helper_get_time();
919 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
921 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
922 end = tdm_helper_get_time();
924 /* "+ interval" consider the delay of socket communication between kernel and platform */
925 ASSERT_LT((end - start), (interval + interval));
930 TEST_P(TDMVblank, VblankWaitFewTime)
932 TDM_UT_SKIP_FLAG(has_outputs);
934 ASSERT_EQ(TestPrepareOutput(), true);
935 ASSERT_EQ(TestCreateVblanks(), true);
937 for (int v = 0; v < vblank_count; v++) {
938 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
939 double start, end, interval;
941 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
944 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
945 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
946 interval = 1.0 / (double)fps;
948 for (int t = 0; t < 10; t++) {
949 unsigned int cur_seq, seq1, seq2;
951 cur_seq = seq1 = seq2 = 0;
952 start = tdm_helper_get_time();
953 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
954 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1), TDM_ERROR_NONE);
955 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2), TDM_ERROR_NONE);
957 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
958 end = tdm_helper_get_time();
963 /* "+ interval" consider the delay of socket communication between kernel and platform */
964 ASSERT_LT((end - start), (interval + interval));
969 TEST_P(TDMVblank, VblankWaitInterval0)
971 TDM_UT_SKIP_FLAG(has_outputs);
973 ASSERT_EQ(TestPrepareOutput(), true);
974 ASSERT_EQ(TestCreateVblanks(), true);
976 ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
979 TEST_P(TDMVblank, VblankWaitInterval)
981 TDM_UT_SKIP_FLAG(has_outputs);
983 ASSERT_EQ(TestPrepareOutput(), true);
984 ASSERT_EQ(TestCreateVblanks(), true);
986 for (int v = 0; v < vblank_count; v++) {
987 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
988 double start, end, interval;
990 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
993 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
994 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
995 interval = 1.0 / (double)fps;
998 for (int t = 1; t < 10; t++) {
999 unsigned int cur_seq = 0;
1001 start = tdm_helper_get_time();
1002 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1003 while (cur_seq == 0)
1004 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1005 end = tdm_helper_get_time();
1007 /* "+ interval" consider the delay of socket communication between kernel and platform */
1008 ASSERT_GT((end - start), interval * (t - 1));
1009 ASSERT_LT((end - start), interval * t + interval);
1014 TEST_P(TDMVblank, VblankWaitSeq)
1016 TDM_UT_SKIP_FLAG(has_outputs);
1018 ASSERT_EQ(TestPrepareOutput(), true);
1019 ASSERT_EQ(TestCreateVblanks(), true);
1021 for (int v = 0; v < vblank_count; v++) {
1022 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1023 double start, end, interval;
1025 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1028 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1029 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1030 interval = 1.0 / (double)fps;
1032 for (int t = 0; t < 10; t++) {
1033 unsigned int cur_seq = 0, temp = 0;
1035 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1036 while (cur_seq == 0)
1037 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1039 start = tdm_helper_get_time();
1040 ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1042 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1043 end = tdm_helper_get_time();
1045 /* "+ interval" consider the delay of socket communication between kernel and platform */
1046 ASSERT_LT((end - start), (interval + interval));
1051 TEST_P(TDMVblank, VblankWaitSeqInterval)
1053 TDM_UT_SKIP_FLAG(has_outputs);
1055 ASSERT_EQ(TestPrepareOutput(), true);
1056 ASSERT_EQ(TestCreateVblanks(), true);
1058 for (int v = 0; v < vblank_count; v++) {
1059 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1060 double start, end, interval;
1062 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1065 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1066 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1067 interval = 1.0 / (double)fps;
1070 for (int t = 1; t < 10; t++) {
1071 unsigned int cur_seq = 0, temp = 0;
1073 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1074 while (cur_seq == 0)
1075 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1077 start = tdm_helper_get_time();
1078 ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1080 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1081 end = tdm_helper_get_time();
1083 /* "+ interval" consider the delay of socket communication between kernel and platform */
1084 ASSERT_GT((end - start), (interval * (t - 1)));
1085 ASSERT_LT((end - start), (interval * t + interval));
1090 TEST_P(TDMVblank, VblankWaitNullObject)
1092 TDM_UT_SKIP_FLAG(has_outputs);
1094 unsigned int cur_seq = 0;
1096 ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1099 TEST_P(TDMVblank, VblankWaitNullOther)
1101 TDM_UT_SKIP_FLAG(has_outputs);
1103 ASSERT_EQ(TestCreateVblanks(), true);
1105 ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1108 TEST_P(TDMVblank, VblankWaitDpmsOff)
1110 TDM_UT_SKIP_FLAG(has_outputs);
1112 ASSERT_EQ(TestPrepareOutput(), true);
1113 ASSERT_EQ(TestCreateVblanks(), true);
1115 for (int v = 0; v < vblank_count; v++) {
1117 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1118 ASSERT_EQ(ret, TDM_ERROR_NONE);
1120 if (!ut_tdm_output_is_connected(output))
1123 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1125 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
1129 TEST_P(TDMVblank, VblankWaitBeforeDpmsOff)
1131 TDM_UT_SKIP_FLAG(has_outputs);
1133 ASSERT_EQ(TestPrepareOutput(), true);
1134 ASSERT_EQ(TestCreateVblanks(), true);
1136 for (int v = 0; v < vblank_count; v++) {
1137 unsigned int temp = 0;
1139 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1140 ASSERT_EQ(ret, TDM_ERROR_NONE);
1142 if (!ut_tdm_output_is_connected(output))
1145 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1147 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1150 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1154 TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
1156 TDM_UT_SKIP_FLAG(has_outputs);
1158 ASSERT_EQ(TestPrepareOutput(), true);
1159 ASSERT_EQ(TestCreateVblanks(), true);
1161 for (int v = 0; v < vblank_count; v++) {
1163 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1164 ASSERT_EQ(ret, TDM_ERROR_NONE);
1166 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1169 if (!ut_tdm_output_is_connected(output))
1172 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1174 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
1176 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1180 TEST_P(TDMVblank, VblankWaitDisconnectedOutput)
1182 TDM_UT_SKIP_FLAG(has_outputs);
1184 ASSERT_EQ(TestPrepareOutput(), true);
1185 ASSERT_EQ(TestCreateVblanks(), true);
1187 for (int v = 0; v < vblank_count; v++) {
1189 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1190 ASSERT_EQ(ret, TDM_ERROR_NONE);
1192 if (ut_tdm_output_is_connected(output))
1195 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
1199 TEST_P(TDMVblank, VblankWaitSetOffset)
1201 TDM_UT_SKIP_FLAG(has_outputs);
1203 ASSERT_EQ(TestPrepareOutput(), true);
1204 ASSERT_EQ(TestCreateVblanks(), true);
1206 for (int v = 0; v < vblank_count; v++) {
1207 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1208 double start, end, interval;
1210 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1213 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
1215 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1216 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1217 interval = 1.0 / (double)fps;
1219 for (int t = 0; t < 3; t++) {
1220 unsigned int cur_seq = 0;
1222 start = tdm_helper_get_time();
1223 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1224 while (cur_seq == 0)
1225 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1226 end = tdm_helper_get_time();
1228 /* "+ interval" consider the delay of socket communication between kernel and platform */
1229 ASSERT_GT((end - start), (0.1));
1230 ASSERT_LT((end - start), (interval + interval + 0.1));
1235 TEST_P(TDMVblank, VblankWaitSetFps)
1237 TDM_UT_SKIP_FLAG(has_outputs);
1239 ASSERT_EQ(TestPrepareOutput(), true);
1240 ASSERT_EQ(TestCreateVblanks(), true);
1242 for (int v = 0; v < vblank_count; v++) {
1243 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1244 double start, end, interval, vrefresh_interval;
1246 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1249 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1250 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1251 vrefresh_interval = 1.0 / (double)fps;
1254 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1255 interval = 1.0 / (double)fps;
1257 for (int t = 0; t < 3; t++) {
1258 unsigned int cur_seq = 0;
1260 start = tdm_helper_get_time();
1261 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1262 while (cur_seq == 0)
1263 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1264 end = tdm_helper_get_time();
1266 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1267 ASSERT_GT((end - start), (interval - vrefresh_interval));
1268 ASSERT_LT((end - start), (interval + vrefresh_interval));
1273 TEST_P(TDMVblank, VblankWaitSetFixedFps)
1275 TDM_UT_SKIP_FLAG(has_outputs);
1277 ASSERT_EQ(TestPrepareOutput(), true);
1278 ASSERT_EQ(TestCreateVblanks(), true);
1280 for (int v = 0; v < vblank_count; v++) {
1281 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1282 double start, end, interval;
1284 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1287 ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE);
1288 ASSERT_TRUE(fps > 0 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1289 interval = 1.0 / (double)fps;
1291 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
1293 /* this fps will be ignored because it has fixed fps value */
1295 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1297 for (int t = 0; t < 3; t++) {
1298 unsigned int cur_seq = 0;
1300 start = tdm_helper_get_time();
1301 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1302 while (cur_seq == 0)
1303 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1304 end = tdm_helper_get_time();
1306 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1307 ASSERT_LT((end - start), (interval + interval));
1312 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1314 TDM_UT_SKIP_FLAG(has_outputs);
1316 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1317 double vrefresh_interval;
1318 unsigned int cur_seq[3];
1319 unsigned int global_fps = 5;
1320 double start, end, interval;
1322 ASSERT_EQ(TestPrepareOutput(), true);
1323 ASSERT_EQ(TestCreateVblanks3(), true);
1324 ASSERT_EQ(vblank_count, 3);
1326 if (!ut_tdm_vblank_is_avaiable(vblanks[0]))
1329 ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1330 ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1331 vrefresh_interval = 1.0 / (double)fps;
1333 for (int v = 0; v < 3; v++) {
1334 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
1335 interval = 1.0 / (double)(10 * (v + 1));
1338 /* enable test. global fps doesn't effect server's vblanks */
1339 tdm_vblank_enable_global_fps(1, global_fps);
1341 for (int v = 0; v < 3; v++) {
1343 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1346 start = tdm_helper_get_time();
1347 while (cur_seq[2] == 0)
1348 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1349 end = tdm_helper_get_time();
1351 /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
1352 ASSERT_GT((end - start), (interval - vrefresh_interval));
1353 ASSERT_LT((end - start), (interval + vrefresh_interval));
1355 ASSERT_EQ(cur_seq[1], 0);
1356 ASSERT_EQ(cur_seq[0], 0);
1358 while (cur_seq[1] == 0)
1359 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1360 ASSERT_EQ(cur_seq[0], 0);
1362 while (cur_seq[0] == 0)
1363 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1365 /* disable test. global fps doesn't effect server's vblanks */
1366 tdm_vblank_enable_global_fps(0, 0);
1368 for (int v = 0; v < 3; v++) {
1370 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1373 while (cur_seq[2] == 0)
1374 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1375 ASSERT_EQ(cur_seq[1], 0);
1376 ASSERT_EQ(cur_seq[0], 0);
1378 while (cur_seq[1] == 0)
1379 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1380 ASSERT_EQ(cur_seq[0], 0);
1383 TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
1385 TDM_UT_SKIP_FLAG(has_outputs);
1387 ASSERT_EQ(TestPrepareOutput(), true);
1388 ASSERT_EQ(TestCreateVblanks(), true);
1390 for (int v = 0; v < vblank_count; v++) {
1392 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1393 ASSERT_EQ(ret, TDM_ERROR_NONE);
1395 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1398 if (ut_tdm_output_is_connected(output))
1401 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
1403 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1407 TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff)
1409 /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */
1412 #ifdef TDM_UT_TEST_WITH_PARAMS
1413 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1415 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1417 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1419 Values(TDM_DEFAULT_MODULE));