haltests/src/tc_tdm_vblank.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   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:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  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.
  28  *
  29 **************************************************************************/
  30
  31 #include "tc_tdm.h"
  32
  33 /* LCOV_EXCL_START */
  34
  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);
  37
  38 class TDMVblank : public TDMOutput
  39 {
  40 public:
  41         bool has_vblanks;
  42
  43         tdm_vblank **vblanks;
  44         int vblank_count;
  45
  46         bool done;
  47
  48         TDMVblank();
  49         void SetUp(void);
  50         void TearDown(void);
  51
  52         bool TestCreateVblanks(void);
  53         bool TestCreateVblanks3(void);
  54         void TestDestroyVblanks(void);
  55
  56         bool TestPrepareOutput(void);
  57 };
  58
  59 TDMVblank::TDMVblank()
  60 {
  61         has_vblanks = false;
  62         vblanks = NULL;
  63         vblank_count = 0;
  64         done = false;
  65 }
  66
  67 void TDMVblank::SetUp(void)
  68 {
  69         TDMOutput::SetUp();
  70 }
  71
  72 void TDMVblank::TearDown(void)
  73 {
  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);
  78
  79         TestDestroyVblanks();
  80
  81         tdm_vblank_enable_global_fps(0, 0);
  82
  83         TDMOutput::TearDown();
  84 }
  85
  86 bool TDMVblank::TestCreateVblanks(void)
  87 {
  88         TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
  89
  90         vblanks = (tdm_vblank**)calloc(output_count, sizeof(tdm_vblank*));
  91         TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
  92
  93         vblank_count = output_count;
  94         has_vblanks = true;
  95
  96         for (int v = 0; v < vblank_count; v++) {
  97                 tdm_error ret;
  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);
 101         }
 102
 103         return true;
 104 failed:
 105         TestDestroyVblanks();
 106         has_vblanks = false;
 107         return false;
 108 }
 109
 110 bool TDMVblank::TestCreateVblanks3(void)
 111 {
 112         TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
 113
 114         tdm_error ret;
 115
 116         vblank_count = 0;
 117
 118         for (int o = 0; o < output_count; o++) {
 119                 if (!tc_tdm_output_is_connected(outputs[o]))
 120                         continue;
 121
 122                 vblank_count = 3;
 123                 has_vblanks = true;
 124
 125                 vblanks = (tdm_vblank**)calloc(vblank_count, sizeof(tdm_vblank*));
 126                 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
 127
 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);
 132                 }
 133
 134                 break;
 135         }
 136
 137         return true;
 138 failed:
 139         TestDestroyVblanks();
 140         has_vblanks = false;
 141         return false;
 142 }
 143
 144 void TDMVblank::TestDestroyVblanks(void)
 145 {
 146         if (vblanks) {
 147                 for (int v = 0; v < vblank_count; v++)
 148                         tdm_vblank_destroy(vblanks[v]);
 149                 free(vblanks);
 150                 vblanks = NULL;
 151         }
 152         vblank_count = 0;
 153
 154 }
 155
 156 bool TDMVblank::TestPrepareOutput(void)
 157 {
 158         for (int o = 0; o < output_count; o++) {
 159                 if (!tc_tdm_output_is_connected(outputs[o]))
 160                         continue;
 161
 162                 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare(dpy, outputs[o], false) == true);
 163         }
 164
 165         return true;
 166 }
 167
 168 bool tc_tdm_vblank_is_avaiable(tdm_vblank *vblank)
 169 {
 170         tdm_error ret;
 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);
 174
 175         /* only check if connected */
 176         return tc_tdm_output_is_connected(output);
 177 }
 178
 179 /* tdm_vblank_set_client_vblank_fps */
 180 TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
 181 {
 182         /* tested in tc_tdm_client.c */
 183 }
 184
 185 TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
 186 {
 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);
 189 }
 190
 191 /* tdm_vblank_set_client_vblank_fps */
 192 TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
 193 {
 194         /* tested in tc_tdm_client.c */
 195 }
 196
 197 TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
 198 {
 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);
 201 }
 202
 203 /* tdm_vblank_create() */
 204 TEST_P(TDMVblank, VblankCreateDestroy)
 205 {
 206         TDM_UT_SKIP_FLAG(has_outputs);
 207
 208         for (int o = 0; o < output_count; o++) {
 209                 tdm_error ret;
 210                 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
 211                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 212                 ASSERT_NE(vblank, NULL);
 213
 214                 tdm_vblank_destroy(vblank);
 215         }
 216 }
 217
 218 TEST_P(TDMVblank, VblankCreateNullDpy)
 219 {
 220         TDM_UT_SKIP_FLAG(has_outputs);
 221
 222         tdm_error ret;
 223
 224         tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret);
 225         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 226         ASSERT_EQ(vblank, NULL);
 227 }
 228
 229 TEST_P(TDMVblank, VblankCreateNullOutput)
 230 {
 231         tdm_error ret;
 232
 233         tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret);
 234         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 235         ASSERT_EQ(vblank, NULL);
 236 }
 237
 238 TEST_P(TDMVblank, VblankCreateNullOther)
 239 {
 240         TDM_UT_SKIP_FLAG(has_outputs);
 241
 242         tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
 243         ASSERT_NE(vblank, NULL);
 244
 245         tdm_vblank_destroy(vblank);
 246 }
 247
 248 /* tdm_vblank_destroy() */
 249 TEST_P(TDMVblank, VblankDestroyNullObject)
 250 {
 251         tdm_vblank_destroy(NULL);
 252 }
 253
 254 static void
 255 _tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
 256 {
 257         TDMVblank *test_vblank = (TDMVblank*)user_data;
 258         if (test_vblank)
 259                 test_vblank->done = true;
 260 }
 261
 262 /* tdm_vblank_add_create_handler */
 263 TEST_P(TDMVblank, VblankAddCreateHandler)
 264 {
 265         TDM_UT_SKIP_FLAG(has_outputs);
 266
 267         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 268
 269         for (int o = 0; o < output_count; o++) {
 270                 tdm_error ret;
 271
 272                 done = false;
 273
 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);
 278
 279                 tdm_vblank_destroy(vblank);
 280         }
 281 }
 282
 283 TEST_P(TDMVblank, VblankAddCreateHandlerTwice)
 284 {
 285         TDM_UT_SKIP_FLAG(has_outputs);
 286
 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);
 289 }
 290
 291 TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
 292 {
 293         TDM_UT_SKIP_FLAG(has_outputs);
 294
 295         ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 296 }
 297
 298 TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
 299 {
 300         TDM_UT_SKIP_FLAG(has_outputs);
 301
 302         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 303 }
 304
 305 /* tdm_vblank_remove_create_handler */
 306 TEST_P(TDMVblank, VblankRemoveCreateHandler)
 307 {
 308         TDM_UT_SKIP_FLAG(has_outputs);
 309
 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);
 312
 313         for (int o = 0; o < output_count; o++) {
 314                 tdm_error ret;
 315
 316                 done = false;
 317
 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);
 322
 323                 tdm_vblank_destroy(vblank);
 324         }
 325 }
 326
 327 TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
 328 {
 329         TDM_UT_SKIP_FLAG(has_outputs);
 330
 331         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 332
 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);
 336
 337         for (int o = 0; o < output_count; o++) {
 338                 tdm_error ret;
 339
 340                 done = false;
 341
 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);
 346
 347                 tdm_vblank_destroy(vblank);
 348         }
 349 }
 350
 351 TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
 352 {
 353         TDM_UT_SKIP_FLAG(has_outputs);
 354
 355         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 356
 357         tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL);
 358
 359         for (int o = 0; o < output_count; o++) {
 360                 tdm_error ret;
 361
 362                 done = false;
 363
 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);
 368
 369                 tdm_vblank_destroy(vblank);
 370         }
 371 }
 372
 373 static void
 374 _tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
 375 {
 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);
 379 }
 380
 381 TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
 382 {
 383         TDM_UT_SKIP_FLAG(has_outputs);
 384
 385         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
 386
 387         for (int o = 0; o < output_count; o++) {
 388                 tdm_error ret;
 389
 390                 done = false;
 391
 392                 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
 393                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 394                 ASSERT_NE(vblank, NULL);
 395                 if (o == 0)
 396                         ASSERT_EQ(done, true);
 397                 else
 398                         ASSERT_EQ(done, false);
 399
 400                 tdm_vblank_destroy(vblank);
 401         }
 402 }
 403
 404 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullObject)
 405 {
 406         TDM_UT_SKIP_FLAG(has_outputs);
 407
 408         tdm_vblank_remove_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL);
 409 }
 410
 411 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther)
 412 {
 413         TDM_UT_SKIP_FLAG(has_outputs);
 414
 415         tdm_vblank_remove_create_handler(dpy, NULL, NULL);
 416 }
 417
 418 /* tdm_vblank_get_output() */
 419 TEST_P(TDMVblank, VblankGetOutput)
 420 {
 421         TDM_UT_SKIP_FLAG(has_outputs);
 422
 423         ASSERT_EQ(TestCreateVblanks(), true);
 424
 425         for (int v = 0; v < vblank_count; v++) {
 426                 tdm_error ret;
 427                 ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
 428                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 429         }
 430 }
 431
 432 TEST_P(TDMVblank, VblankGetOutputNullObject)
 433 {
 434         tdm_error ret;
 435         ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
 436         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 437 }
 438
 439 TEST_P(TDMVblank, VblankGetOutputNullOther)
 440 {
 441         TDM_UT_SKIP_FLAG(has_outputs);
 442
 443         ASSERT_EQ(TestCreateVblanks(), true);
 444
 445         ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
 446 }
 447
 448 /* tdm_vblank_get_client_pid() */
 449 TEST_P(TDMVblank, VblankGetClientPid)
 450 {
 451         TDM_UT_SKIP_FLAG(has_outputs);
 452
 453         ASSERT_EQ(TestCreateVblanks(), true);
 454
 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 */
 459                 ASSERT_EQ(pid, 0);
 460         }
 461 }
 462
 463 TEST_P(TDMVblank, VblankGetClientPidNullObject)
 464 {
 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);
 468 }
 469
 470 TEST_P(TDMVblank, VblankGetClientPidNullOther)
 471 {
 472         TDM_UT_SKIP_FLAG(has_outputs);
 473
 474         ASSERT_EQ(TestCreateVblanks(), true);
 475
 476         ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 477 }
 478
 479 /* tdm_vblank_set_name() */
 480 TEST_P(TDMVblank, VblankSetName)
 481 {
 482         TDM_UT_SKIP_FLAG(has_outputs);
 483
 484         ASSERT_EQ(TestCreateVblanks(), true);
 485
 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);
 488 }
 489
 490 TEST_P(TDMVblank, VblankSetNameNullObject)
 491 {
 492         ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 493 }
 494
 495 TEST_P(TDMVblank, VblankSetNameNullOther)
 496 {
 497         TDM_UT_SKIP_FLAG(has_outputs);
 498
 499         ASSERT_EQ(TestCreateVblanks(), true);
 500
 501         for (int v = 0; v < vblank_count; v++)
 502                 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
 503 }
 504
 505 /* tdm_vblank_get_name() */
 506 TEST_P(TDMVblank, VblankGetName)
 507 {
 508         TDM_UT_SKIP_FLAG(has_outputs);
 509
 510         ASSERT_EQ(TestCreateVblanks(), true);
 511
 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);
 517         }
 518 }
 519
 520 TEST_P(TDMVblank, VblankGetNameNullObject)
 521 {
 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);
 525 }
 526
 527 TEST_P(TDMVblank, VblankGetNameNullOther)
 528 {
 529         TDM_UT_SKIP_FLAG(has_outputs);
 530
 531         ASSERT_EQ(TestCreateVblanks(), true);
 532
 533         ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 534 }
 535
 536 TEST_P(TDMVblank, VblankGetNameNoSet)
 537 {
 538         TDM_UT_SKIP_FLAG(has_outputs);
 539
 540         ASSERT_EQ(TestCreateVblanks(), true);
 541
 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);
 546         }
 547 }
 548
 549 /* tdm_vblank_set_fps() */
 550 TEST_P(TDMVblank, VblankSetFps)
 551 {
 552         TDM_UT_SKIP_FLAG(has_outputs);
 553
 554         ASSERT_EQ(TestCreateVblanks(), true);
 555
 556         for (int v = 0; v < vblank_count; v++)
 557                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
 558 }
 559
 560 TEST_P(TDMVblank, VblankSetFpsNullObject)
 561 {
 562         ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 563 }
 564
 565 TEST_P(TDMVblank, VblankSetFpsTwice)
 566 {
 567         TDM_UT_SKIP_FLAG(has_outputs);
 568
 569         ASSERT_EQ(TestCreateVblanks(), true);
 570
 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);
 574         }
 575 }
 576
 577 /* tdm_vblank_set_fixed_fps() */
 578 TEST_P(TDMVblank, VblankSetFixedFps)
 579 {
 580         TDM_UT_SKIP_FLAG(has_outputs);
 581
 582         ASSERT_EQ(TestCreateVblanks(), true);
 583
 584         for (int v = 0; v < vblank_count; v++)
 585                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
 586 }
 587
 588 TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
 589 {
 590         ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 591 }
 592
 593 TEST_P(TDMVblank, VblankSetFixedFpsTwice)
 594 {
 595         TDM_UT_SKIP_FLAG(has_outputs);
 596
 597         ASSERT_EQ(TestCreateVblanks(), true);
 598
 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);
 602         }
 603 }
 604
 605 /* tdm_vblank_get_fps() */
 606 TEST_P(TDMVblank, VblankGetFps)
 607 {
 608         TDM_UT_SKIP_FLAG(has_outputs);
 609
 610         ASSERT_EQ(TestCreateVblanks(), true);
 611
 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);
 616                 ASSERT_EQ(fps, 60);
 617         }
 618 }
 619
 620 TEST_P(TDMVblank, VblankGetFpsNullObject)
 621 {
 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);
 625 }
 626
 627 TEST_P(TDMVblank, VblankGetFpsNullOther)
 628 {
 629         TDM_UT_SKIP_FLAG(has_outputs);
 630
 631         ASSERT_EQ(TestCreateVblanks(), true);
 632
 633         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 634 }
 635
 636 TEST_P(TDMVblank, VblankGetFpsNoSet)
 637 {
 638         TDM_UT_SKIP_FLAG(has_outputs);
 639
 640         ASSERT_EQ(TestPrepareOutput(), true);
 641         ASSERT_EQ(TestCreateVblanks(), true);
 642
 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;
 646                 tdm_error ret;
 647
 648                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
 649                         continue;
 650
 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);
 653
 654                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
 655                 ASSERT_NE(output, NULL);
 656                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 657
 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);
 660
 661                 ASSERT_EQ(fps, mode->vrefresh);
 662         }
 663 }
 664
 665 TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps)
 666 {
 667         TDM_UT_SKIP_FLAG(has_outputs);
 668
 669         ASSERT_EQ(TestCreateVblanks(), true);
 670
 671         for (int v = 0; v < vblank_count; v++) {
 672                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 673
 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);
 676                 ASSERT_EQ(fps, 60);
 677
 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);
 680                 ASSERT_EQ(fps, 10);
 681
 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.
 685                  */
 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);
 688                 ASSERT_EQ(fps, 10);
 689         }
 690 }
 691
 692 /* tdm_vblank_ignore_global_fps() */
 693 TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
 694 {
 695         ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 696 }
 697
 698 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
 699 {
 700         TDM_UT_SKIP_FLAG(has_outputs);
 701
 702         ASSERT_EQ(TestCreateVblanks(), true);
 703
 704         for (int v = 0; v < vblank_count; v++)
 705                 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
 706 }
 707
 708 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
 709 {
 710         TDM_UT_SKIP_FLAG(has_outputs);
 711
 712         ASSERT_EQ(TestCreateVblanks(), true);
 713
 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);
 717         }
 718 }
 719
 720 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset)
 721 {
 722         TDM_UT_SKIP_FLAG(has_outputs);
 723
 724         ASSERT_EQ(TestCreateVblanks(), true);
 725
 726         for (int v = 0; v < vblank_count; v++)
 727                 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
 728 }
 729
 730 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
 731 {
 732         TDM_UT_SKIP_FLAG(has_outputs);
 733
 734         ASSERT_EQ(TestCreateVblanks(), true);
 735
 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);
 739         }
 740 }
 741
 742 /* tdm_vblank_set_offset() */
 743 TEST_P(TDMVblank, VblankSetOffset)
 744 {
 745         TDM_UT_SKIP_FLAG(has_outputs);
 746
 747         ASSERT_EQ(TestCreateVblanks(), true);
 748
 749         for (int v = 0; v < vblank_count; v++)
 750                 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
 751 }
 752
 753 TEST_P(TDMVblank, VblankSetOffsetNullObject)
 754 {
 755         ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 756 }
 757
 758 TEST_P(TDMVblank, VblankSetOffsetTwice)
 759 {
 760         TDM_UT_SKIP_FLAG(has_outputs);
 761
 762         ASSERT_EQ(TestCreateVblanks(), true);
 763
 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);
 767         }
 768 }
 769
 770 /* tdm_vblank_get_offset() */
 771 TEST_P(TDMVblank, VblankGetOffset)
 772 {
 773         TDM_UT_SKIP_FLAG(has_outputs);
 774
 775         ASSERT_EQ(TestCreateVblanks(), true);
 776
 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);
 782         }
 783 }
 784
 785 TEST_P(TDMVblank, VblankGetOffsetNullObject)
 786 {
 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);
 790 }
 791
 792 TEST_P(TDMVblank, VblankGetOffsetNullOther)
 793 {
 794         TDM_UT_SKIP_FLAG(has_outputs);
 795
 796         ASSERT_EQ(TestCreateVblanks(), true);
 797
 798         ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 799 }
 800
 801 TEST_P(TDMVblank, VblankGetOffsetNoSet)
 802 {
 803         TDM_UT_SKIP_FLAG(has_outputs);
 804
 805         ASSERT_EQ(TestCreateVblanks(), true);
 806
 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);
 811         }
 812 }
 813
 814 /* tdm_vblank_set_enable_fake() */
 815 TEST_P(TDMVblank, VblankSetEnableFake)
 816 {
 817         TDM_UT_SKIP_FLAG(has_outputs);
 818
 819         ASSERT_EQ(TestCreateVblanks(), true);
 820
 821         for (int v = 0; v < vblank_count; v++)
 822                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
 823 }
 824
 825 TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
 826 {
 827         ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 828 }
 829
 830 TEST_P(TDMVblank, VblankSetEnableFakeTwice)
 831 {
 832         TDM_UT_SKIP_FLAG(has_outputs);
 833
 834         ASSERT_EQ(TestCreateVblanks(), true);
 835
 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);
 839         }
 840 }
 841
 842 /* tdm_vblank_get_enable_fake() */
 843 TEST_P(TDMVblank, VblankGetEnableFake)
 844 {
 845         TDM_UT_SKIP_FLAG(has_outputs);
 846
 847         ASSERT_EQ(TestCreateVblanks(), true);
 848
 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);
 854
 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);
 858         }
 859 }
 860
 861 TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
 862 {
 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);
 866 }
 867
 868 TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
 869 {
 870         TDM_UT_SKIP_FLAG(has_outputs);
 871
 872         ASSERT_EQ(TestCreateVblanks(), true);
 873
 874         ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 875 }
 876
 877 TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
 878 {
 879         TDM_UT_SKIP_FLAG(has_outputs);
 880
 881         ASSERT_EQ(TestCreateVblanks(), true);
 882
 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);
 887         }
 888 }
 889
 890 static void
 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)
 893 {
 894         unsigned int *cur_seq = (unsigned int *)user_data;
 895         if (cur_seq)
 896                 *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1);
 897 }
 898
 899 TEST_P(TDMVblank, VblankWait)
 900 {
 901         TDM_UT_SKIP_FLAG(has_outputs);
 902
 903         ASSERT_EQ(TestPrepareOutput(), true);
 904         ASSERT_EQ(TestCreateVblanks(), true);
 905
 906         for (int v = 0; v < vblank_count; v++) {
 907                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 908                 double start, end, interval;
 909
 910                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
 911                         continue;
 912
 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;
 916
 917                 for (int t = 0; t < 10; t++) {
 918                         unsigned int cur_seq = 0;
 919
 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);
 922                         while (cur_seq == 0)
 923                                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 924                         end = tdm_helper_get_time();
 925
 926                         /* "+ interval" consider the delay of socket communication between kernel and platform */
 927                         ASSERT_LT((end - start), (interval + interval));
 928                 }
 929         }
 930 }
 931
 932 TEST_P(TDMVblank, VblankWaitFewTime)
 933 {
 934         TDM_UT_SKIP_FLAG(has_outputs);
 935
 936         ASSERT_EQ(TestPrepareOutput(), true);
 937         ASSERT_EQ(TestCreateVblanks(), true);
 938
 939         for (int v = 0; v < vblank_count; v++) {
 940                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 941                 double start, end, interval;
 942
 943                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
 944                         continue;
 945
 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;
 949
 950                 for (int t = 0; t < 10; t++) {
 951                         unsigned int cur_seq, seq1, seq2;
 952
 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);
 958                         while (cur_seq == 0)
 959                                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 960                         end = tdm_helper_get_time();
 961
 962                         ASSERT_NE(seq1, 0);
 963                         ASSERT_NE(seq2, 0);
 964
 965                         /* "+ interval" consider the delay of socket communication between kernel and platform */
 966                         ASSERT_LT((end - start), (interval + interval));
 967                 }
 968         }
 969 }
 970
 971 TEST_P(TDMVblank, VblankWaitInterval0)
 972 {
 973         TDM_UT_SKIP_FLAG(has_outputs);
 974
 975         ASSERT_EQ(TestPrepareOutput(), true);
 976         ASSERT_EQ(TestCreateVblanks(), true);
 977
 978         ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 979 }
 980
 981 TEST_P(TDMVblank, VblankWaitInterval)
 982 {
 983         TDM_UT_SKIP_FLAG(has_outputs);
 984
 985         ASSERT_EQ(TestPrepareOutput(), true);
 986         ASSERT_EQ(TestCreateVblanks(), true);
 987
 988         for (int v = 0; v < vblank_count; v++) {
 989                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 990                 double start, end, interval;
 991
 992                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
 993                         continue;
 994
 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;
 998
 999                 /* start from 1 */
1000                 for (int t = 1; t < 10; t++) {
1001                         unsigned int cur_seq = 0;
1002
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();
1008
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);
1012                 }
1013         }
1014 }
1015
1016 TEST_P(TDMVblank, VblankWaitSeq)
1017 {
1018         TDM_UT_SKIP_FLAG(has_outputs);
1019
1020         ASSERT_EQ(TestPrepareOutput(), true);
1021         ASSERT_EQ(TestCreateVblanks(), true);
1022
1023         for (int v = 0; v < vblank_count; v++) {
1024                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1025                 double start, end, interval;
1026
1027                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1028                         continue;
1029
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;
1033
1034                 for (int t = 0; t < 10; t++) {
1035                         unsigned int cur_seq = 0, temp = 0;
1036
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);
1040
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);
1043                         while (temp == 0)
1044                                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1045                         end = tdm_helper_get_time();
1046
1047                         /* "+ interval" consider the delay of socket communication between kernel and platform */
1048                         ASSERT_LT((end - start), (interval + interval));
1049                 }
1050         }
1051 }
1052
1053 TEST_P(TDMVblank, VblankWaitSeqInterval)
1054 {
1055         TDM_UT_SKIP_FLAG(has_outputs);
1056
1057         ASSERT_EQ(TestPrepareOutput(), true);
1058         ASSERT_EQ(TestCreateVblanks(), true);
1059
1060         for (int v = 0; v < vblank_count; v++) {
1061                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1062                 double start, end, interval;
1063
1064                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1065                         continue;
1066
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;
1070
1071                 /* start from 1 */
1072                 for (int t = 1; t < 10; t++) {
1073                         unsigned int cur_seq = 0, temp = 0;
1074
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);
1078
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);
1081                         while (temp == 0)
1082                                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1083                         end = tdm_helper_get_time();
1084
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));
1088                 }
1089         }
1090 }
1091
1092 TEST_P(TDMVblank, VblankWaitNullObject)
1093 {
1094         TDM_UT_SKIP_FLAG(has_outputs);
1095
1096         unsigned int cur_seq = 0;
1097
1098         ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1099 }
1100
1101 TEST_P(TDMVblank, VblankWaitNullOther)
1102 {
1103         TDM_UT_SKIP_FLAG(has_outputs);
1104
1105         ASSERT_EQ(TestCreateVblanks(), true);
1106
1107         ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1108 }
1109
1110 TEST_P(TDMVblank, VblankWaitDpmsOff)
1111 {
1112         TDM_UT_SKIP_FLAG(has_outputs);
1113
1114         ASSERT_EQ(TestPrepareOutput(), true);
1115         ASSERT_EQ(TestCreateVblanks(), true);
1116
1117         for (int v = 0; v < vblank_count; v++) {
1118                 tdm_error ret;
1119                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1120                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1121
1122                 if (!tc_tdm_output_is_connected(output))
1123                         continue;
1124
1125                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1126
1127                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
1128         }
1129 }
1130
1131 TEST_P(TDMVblank, VblankWaitBeforeDpmsOff)
1132 {
1133         TDM_UT_SKIP_FLAG(has_outputs);
1134
1135         ASSERT_EQ(TestPrepareOutput(), true);
1136         ASSERT_EQ(TestCreateVblanks(), true);
1137
1138         for (int v = 0; v < vblank_count; v++) {
1139                 unsigned int temp = 0;
1140                 tdm_error ret;
1141                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1142                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1143
1144                 if (!tc_tdm_output_is_connected(output))
1145                         continue;
1146
1147                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1148
1149                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1150
1151                 while (temp == 0)
1152                         ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1153         }
1154 }
1155
1156 TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
1157 {
1158         TDM_UT_SKIP_FLAG(has_outputs);
1159
1160         ASSERT_EQ(TestPrepareOutput(), true);
1161         ASSERT_EQ(TestCreateVblanks(), true);
1162
1163         for (int v = 0; v < vblank_count; v++) {
1164                 tdm_error ret;
1165                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1166                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1167
1168                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1169                         continue;
1170
1171                 if (!tc_tdm_output_is_connected(output))
1172                         continue;
1173
1174                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1175
1176                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
1177
1178                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1179         }
1180 }
1181
1182 TEST_P(TDMVblank, VblankWaitDisconnectedOutput)
1183 {
1184         TDM_UT_SKIP_FLAG(has_outputs);
1185
1186         ASSERT_EQ(TestPrepareOutput(), true);
1187         ASSERT_EQ(TestCreateVblanks(), true);
1188
1189         for (int v = 0; v < vblank_count; v++) {
1190                 tdm_error ret;
1191                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1192                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1193
1194                 if (tc_tdm_output_is_connected(output))
1195                         continue;
1196
1197                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
1198         }
1199 }
1200
1201 TEST_P(TDMVblank, VblankWaitSetOffset)
1202 {
1203         TDM_UT_SKIP_FLAG(has_outputs);
1204
1205         ASSERT_EQ(TestPrepareOutput(), true);
1206         ASSERT_EQ(TestCreateVblanks(), true);
1207
1208         for (int v = 0; v < vblank_count; v++) {
1209                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1210                 double start, end, interval;
1211
1212                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1213                         continue;
1214
1215                 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
1216
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;
1220
1221                 for (int t = 0; t < 3; t++) {
1222                         unsigned int cur_seq = 0;
1223
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();
1229
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));
1233                 }
1234         }
1235 }
1236
1237 TEST_P(TDMVblank, VblankWaitSetFps)
1238 {
1239         TDM_UT_SKIP_FLAG(has_outputs);
1240
1241         ASSERT_EQ(TestPrepareOutput(), true);
1242         ASSERT_EQ(TestCreateVblanks(), true);
1243
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;
1247
1248                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1249                         continue;
1250
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;
1254
1255                 fps /= 2;
1256                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1257                 interval = 1.0 / (double)fps;
1258
1259                 for (int t = 0; t < 3; t++) {
1260                         unsigned int cur_seq = 0;
1261
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();
1267
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));
1271                 }
1272         }
1273 }
1274
1275 TEST_P(TDMVblank, VblankWaitSetFixedFps)
1276 {
1277         TDM_UT_SKIP_FLAG(has_outputs);
1278
1279         ASSERT_EQ(TestPrepareOutput(), true);
1280         ASSERT_EQ(TestCreateVblanks(), true);
1281
1282         for (int v = 0; v < vblank_count; v++) {
1283                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1284                 double start, end, interval;
1285
1286                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1287                         continue;
1288
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;
1292
1293                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
1294
1295                 /* this fps will be ignored because it has fixed fps value */
1296                 fps /= 2;
1297                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1298
1299                 for (int t = 0; t < 3; t++) {
1300                         unsigned int cur_seq = 0;
1301
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();
1307
1308                         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1309                         ASSERT_LT((end - start), (interval + interval));
1310                 }
1311         }
1312 }
1313
1314 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1315 {
1316         TDM_UT_SKIP_FLAG(has_outputs);
1317
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;
1323
1324         ASSERT_EQ(TestPrepareOutput(), true);
1325         ASSERT_EQ(TestCreateVblanks3(), true);
1326         ASSERT_EQ(vblank_count, 3);
1327
1328         if (!tc_tdm_vblank_is_avaiable(vblanks[0]))
1329                 return;
1330
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;
1334
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));
1338         }
1339
1340         /* enable test. global fps doesn't effect server's vblanks */
1341         tdm_vblank_enable_global_fps(1, global_fps);
1342
1343         for (int v = 0; v < 3; v++) {
1344                 cur_seq[v] = 0;
1345                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1346         }
1347
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();
1352
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));
1356
1357         ASSERT_EQ(cur_seq[1], 0);
1358         ASSERT_EQ(cur_seq[0], 0);
1359
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);
1363
1364         while (cur_seq[0] == 0)
1365                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1366
1367         /* disable test. global fps doesn't effect server's vblanks */
1368         tdm_vblank_enable_global_fps(0, 0);
1369
1370         for (int v = 0; v < 3; v++) {
1371                 cur_seq[v] = 0;
1372                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1373         }
1374
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);
1379
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);
1383 }
1384
1385 TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
1386 {
1387         TDM_UT_SKIP_FLAG(has_outputs);
1388
1389         ASSERT_EQ(TestPrepareOutput(), true);
1390         ASSERT_EQ(TestCreateVblanks(), true);
1391
1392         for (int v = 0; v < vblank_count; v++) {
1393                 tdm_error ret;
1394                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1395                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1396
1397                 if (!tc_tdm_vblank_is_avaiable(vblanks[v]))
1398                         continue;
1399
1400                 if (tc_tdm_output_is_connected(output))
1401                         continue;
1402
1403                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
1404
1405                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1406         }
1407 }
1408
1409 TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff)
1410 {
1411         /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */
1412 }
1413
1414 TEST_P(TDMVblank, VblankWaitTimeout)
1415 {
1416         TDM_UT_SKIP_FLAG(has_outputs);
1417
1418         ASSERT_EQ(TestPrepareOutput(), true);
1419         ASSERT_EQ(TestCreateVblanks(), true);
1420
1421         if (vblank_count > 0) {
1422                 tdm_vblank *vblank = vblanks[0];
1423                 unsigned int cur_seq = 0;
1424
1425                 ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE);
1426                 usleep(1200000);
1427                 while (cur_seq == 0)
1428                         ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1429         }
1430 }
1431
1432 #ifdef TDM_UT_TEST_WITH_PARAMS
1433 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1434                                                 TDMVblank,
1435                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1436 #else
1437 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1438                                                 TDMVblank,
1439                                                 Values(TDM_DEFAULT_MODULE));
1440 #endif
1441
1442 /* LCOV_EXCL_END */