utests/src/ut_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 "ut_tdm.h"
  32
  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);
  35
  36 class TDMVblank : public TDMOutput
  37 {
  38 public:
  39         bool has_vblanks;
  40
  41         tdm_vblank **vblanks;
  42         int vblank_count;
  43
  44         bool done;
  45
  46         TDMVblank();
  47         void SetUp(void);
  48         void TearDown(void);
  49
  50         bool TestCreateVblanks(void);
  51         bool TestCreateVblanks3(void);
  52         void TestDestroyVblanks(void);
  53
  54         bool TestPrepareOutput(void);
  55 };
  56
  57 TDMVblank::TDMVblank()
  58 {
  59         has_vblanks = false;
  60         vblanks = NULL;
  61         vblank_count = 0;
  62         done = false;
  63 }
  64
  65 void TDMVblank::SetUp(void)
  66 {
  67         TDMOutput::SetUp();
  68 }
  69
  70 void TDMVblank::TearDown(void)
  71 {
  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);
  76
  77         TestDestroyVblanks();
  78
  79         tdm_vblank_enable_global_fps(0, 0);
  80
  81         TDMOutput::TearDown();
  82 }
  83
  84 bool TDMVblank::TestCreateVblanks(void)
  85 {
  86         TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
  87
  88         vblanks = (tdm_vblank**)calloc(output_count, sizeof(tdm_vblank*));
  89         TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
  90
  91         vblank_count = output_count;
  92         has_vblanks = true;
  93
  94         for (int v = 0; v < vblank_count; v++) {
  95                 tdm_error ret;
  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);
  99         }
 100
 101         return true;
 102 failed:
 103         TestDestroyVblanks();
 104         has_vblanks = false;
 105         return false;
 106 }
 107
 108 bool TDMVblank::TestCreateVblanks3(void)
 109 {
 110         TDM_UT_GOTO_IF_FAIL(output_count > 0, failed);
 111
 112         tdm_error ret;
 113
 114         vblank_count = 0;
 115
 116         for (int o = 0; o < output_count; o++) {
 117                 if (!ut_tdm_output_is_connected(outputs[o]))
 118                         continue;
 119
 120                 vblank_count = 3;
 121                 has_vblanks = true;
 122
 123                 vblanks = (tdm_vblank**)calloc(vblank_count, sizeof(tdm_vblank*));
 124                 TDM_UT_GOTO_IF_FAIL(vblanks != NULL, failed);
 125
 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);
 130                 }
 131
 132                 break;
 133         }
 134
 135         return true;
 136 failed:
 137         TestDestroyVblanks();
 138         has_vblanks = false;
 139         return false;
 140 }
 141
 142 void TDMVblank::TestDestroyVblanks(void)
 143 {
 144         if (vblanks) {
 145                 for (int v = 0; v < vblank_count; v++)
 146                         tdm_vblank_destroy(vblanks[v]);
 147                 free(vblanks);
 148                 vblanks = NULL;
 149         }
 150         vblank_count = 0;
 151
 152 }
 153
 154 bool TDMVblank::TestPrepareOutput(void)
 155 {
 156         for (int o = 0; o < output_count; o++) {
 157                 if (!ut_tdm_output_is_connected(outputs[o]))
 158                         continue;
 159
 160                 TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true);
 161         }
 162
 163         return true;
 164 }
 165
 166 bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank)
 167 {
 168         tdm_error ret;
 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);
 172
 173         /* only check if connected */
 174         return ut_tdm_output_is_connected(output);
 175 }
 176
 177 /* tdm_vblank_set_client_vblank_fps */
 178 TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps)
 179 {
 180         /* tested in ut_tdm_client.c */
 181 }
 182
 183 TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject)
 184 {
 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);
 187 }
 188
 189 /* tdm_vblank_set_client_vblank_fps */
 190 TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps)
 191 {
 192         /* tested in ut_tdm_client.c */
 193 }
 194
 195 TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject)
 196 {
 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);
 199 }
 200
 201 /* tdm_vblank_create() */
 202 TEST_P(TDMVblank, VblankCreateDestroy)
 203 {
 204         TDM_UT_SKIP_FLAG(has_outputs);
 205
 206         for (int o = 0; o < output_count; o++) {
 207                 tdm_error ret;
 208                 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
 209                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 210                 ASSERT_NE(vblank, NULL);
 211
 212                 tdm_vblank_destroy(vblank);
 213         }
 214 }
 215
 216 TEST_P(TDMVblank, VblankCreateNullDpy)
 217 {
 218         TDM_UT_SKIP_FLAG(has_outputs);
 219
 220         tdm_error ret;
 221
 222         tdm_vblank *vblank = tdm_vblank_create(NULL, outputs[0], &ret);
 223         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 224         ASSERT_EQ(vblank, NULL);
 225 }
 226
 227 TEST_P(TDMVblank, VblankCreateNullOutput)
 228 {
 229         tdm_error ret;
 230
 231         tdm_vblank *vblank = tdm_vblank_create(dpy, NULL, &ret);
 232         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 233         ASSERT_EQ(vblank, NULL);
 234 }
 235
 236 TEST_P(TDMVblank, VblankCreateNullOther)
 237 {
 238         TDM_UT_SKIP_FLAG(has_outputs);
 239
 240         tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[0], NULL);
 241         ASSERT_NE(vblank, NULL);
 242
 243         tdm_vblank_destroy(vblank);
 244 }
 245
 246 /* tdm_vblank_destroy() */
 247 TEST_P(TDMVblank, VblankDestroyNullObject)
 248 {
 249         tdm_vblank_destroy(NULL);
 250 }
 251
 252 static void
 253 _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data)
 254 {
 255         TDMVblank *test_vblank = (TDMVblank*)user_data;
 256         if (test_vblank)
 257                 test_vblank->done = true;
 258 }
 259
 260 /* tdm_vblank_add_create_handler */
 261 TEST_P(TDMVblank, VblankAddCreateHandler)
 262 {
 263         TDM_UT_SKIP_FLAG(has_outputs);
 264
 265         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 266
 267         for (int o = 0; o < output_count; o++) {
 268                 tdm_error ret;
 269
 270                 done = false;
 271
 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);
 276
 277                 tdm_vblank_destroy(vblank);
 278         }
 279 }
 280
 281 TEST_P(TDMVblank, VblankAddCreateHandlerTwice)
 282 {
 283         TDM_UT_SKIP_FLAG(has_outputs);
 284
 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);
 287 }
 288
 289 TEST_P(TDMVblank, VblankAddCreateHandlerNullObject)
 290 {
 291         TDM_UT_SKIP_FLAG(has_outputs);
 292
 293         ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 294 }
 295
 296 TEST_P(TDMVblank, VblankAddCreateHandlerNullOther)
 297 {
 298         TDM_UT_SKIP_FLAG(has_outputs);
 299
 300         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 301 }
 302
 303 /* tdm_vblank_remove_create_handler */
 304 TEST_P(TDMVblank, VblankRemoveCreateHandler)
 305 {
 306         TDM_UT_SKIP_FLAG(has_outputs);
 307
 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);
 310
 311         for (int o = 0; o < output_count; o++) {
 312                 tdm_error ret;
 313
 314                 done = false;
 315
 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);
 320
 321                 tdm_vblank_destroy(vblank);
 322         }
 323 }
 324
 325 TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes)
 326 {
 327         TDM_UT_SKIP_FLAG(has_outputs);
 328
 329         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 330
 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);
 334
 335         for (int o = 0; o < output_count; o++) {
 336                 tdm_error ret;
 337
 338                 done = false;
 339
 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);
 344
 345                 tdm_vblank_destroy(vblank);
 346         }
 347 }
 348
 349 TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData)
 350 {
 351         TDM_UT_SKIP_FLAG(has_outputs);
 352
 353         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE);
 354
 355         tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL);
 356
 357         for (int o = 0; o < output_count; o++) {
 358                 tdm_error ret;
 359
 360                 done = false;
 361
 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);
 366
 367                 tdm_vblank_destroy(vblank);
 368         }
 369 }
 370
 371 static void
 372 _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data)
 373 {
 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);
 377 }
 378
 379 TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler)
 380 {
 381         TDM_UT_SKIP_FLAG(has_outputs);
 382
 383         ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE);
 384
 385         for (int o = 0; o < output_count; o++) {
 386                 tdm_error ret;
 387
 388                 done = false;
 389
 390                 tdm_vblank *vblank = tdm_vblank_create(dpy, outputs[o], &ret);
 391                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 392                 ASSERT_NE(vblank, NULL);
 393                 if (o == 0)
 394                         ASSERT_EQ(done, true);
 395                 else
 396                         ASSERT_EQ(done, false);
 397
 398                 tdm_vblank_destroy(vblank);
 399         }
 400 }
 401
 402 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullObject)
 403 {
 404         TDM_UT_SKIP_FLAG(has_outputs);
 405
 406         tdm_vblank_remove_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL);
 407 }
 408
 409 TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther)
 410 {
 411         TDM_UT_SKIP_FLAG(has_outputs);
 412
 413         tdm_vblank_remove_create_handler(dpy, NULL, NULL);
 414 }
 415
 416 /* tdm_vblank_get_output() */
 417 TEST_P(TDMVblank, VblankGetOutput)
 418 {
 419         TDM_UT_SKIP_FLAG(has_outputs);
 420
 421         ASSERT_EQ(TestCreateVblanks(), true);
 422
 423         for (int v = 0; v < vblank_count; v++) {
 424                 tdm_error ret;
 425                 ASSERT_NE(tdm_vblank_get_output(vblanks[v], &ret), NULL);
 426                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 427         }
 428 }
 429
 430 TEST_P(TDMVblank, VblankGetOutputNullObject)
 431 {
 432         tdm_error ret;
 433         ASSERT_EQ(tdm_vblank_get_output(NULL, &ret), NULL);
 434         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 435 }
 436
 437 TEST_P(TDMVblank, VblankGetOutputNullOther)
 438 {
 439         TDM_UT_SKIP_FLAG(has_outputs);
 440
 441         ASSERT_EQ(TestCreateVblanks(), true);
 442
 443         ASSERT_NE(tdm_vblank_get_output(vblanks[0], NULL), NULL);
 444 }
 445
 446 /* tdm_vblank_get_client_pid() */
 447 TEST_P(TDMVblank, VblankGetClientPid)
 448 {
 449         TDM_UT_SKIP_FLAG(has_outputs);
 450
 451         ASSERT_EQ(TestCreateVblanks(), true);
 452
 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 */
 457                 ASSERT_EQ(pid, 0);
 458         }
 459 }
 460
 461 TEST_P(TDMVblank, VblankGetClientPidNullObject)
 462 {
 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);
 466 }
 467
 468 TEST_P(TDMVblank, VblankGetClientPidNullOther)
 469 {
 470         TDM_UT_SKIP_FLAG(has_outputs);
 471
 472         ASSERT_EQ(TestCreateVblanks(), true);
 473
 474         ASSERT_EQ(tdm_vblank_get_client_pid(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 475 }
 476
 477 /* tdm_vblank_set_name() */
 478 TEST_P(TDMVblank, VblankSetName)
 479 {
 480         TDM_UT_SKIP_FLAG(has_outputs);
 481
 482         ASSERT_EQ(TestCreateVblanks(), true);
 483
 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);
 486 }
 487
 488 TEST_P(TDMVblank, VblankSetNameNullObject)
 489 {
 490         ASSERT_EQ(tdm_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 491 }
 492
 493 TEST_P(TDMVblank, VblankSetNameNullOther)
 494 {
 495         TDM_UT_SKIP_FLAG(has_outputs);
 496
 497         ASSERT_EQ(TestCreateVblanks(), true);
 498
 499         for (int v = 0; v < vblank_count; v++)
 500                 ASSERT_EQ(tdm_vblank_set_name(vblanks[v], NULL), TDM_ERROR_NONE);
 501 }
 502
 503 /* tdm_vblank_get_name() */
 504 TEST_P(TDMVblank, VblankGetName)
 505 {
 506         TDM_UT_SKIP_FLAG(has_outputs);
 507
 508         ASSERT_EQ(TestCreateVblanks(), true);
 509
 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);
 515         }
 516 }
 517
 518 TEST_P(TDMVblank, VblankGetNameNullObject)
 519 {
 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);
 523 }
 524
 525 TEST_P(TDMVblank, VblankGetNameNullOther)
 526 {
 527         TDM_UT_SKIP_FLAG(has_outputs);
 528
 529         ASSERT_EQ(TestCreateVblanks(), true);
 530
 531         ASSERT_EQ(tdm_vblank_get_name(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 532 }
 533
 534 TEST_P(TDMVblank, VblankGetNameNoSet)
 535 {
 536         TDM_UT_SKIP_FLAG(has_outputs);
 537
 538         ASSERT_EQ(TestCreateVblanks(), true);
 539
 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);
 544         }
 545 }
 546
 547 /* tdm_vblank_set_fps() */
 548 TEST_P(TDMVblank, VblankSetFps)
 549 {
 550         TDM_UT_SKIP_FLAG(has_outputs);
 551
 552         ASSERT_EQ(TestCreateVblanks(), true);
 553
 554         for (int v = 0; v < vblank_count; v++)
 555                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], 60), TDM_ERROR_NONE);
 556 }
 557
 558 TEST_P(TDMVblank, VblankSetFpsNullObject)
 559 {
 560         ASSERT_EQ(tdm_vblank_set_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 561 }
 562
 563 TEST_P(TDMVblank, VblankSetFpsTwice)
 564 {
 565         TDM_UT_SKIP_FLAG(has_outputs);
 566
 567         ASSERT_EQ(TestCreateVblanks(), true);
 568
 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);
 572         }
 573 }
 574
 575 /* tdm_vblank_set_fixed_fps() */
 576 TEST_P(TDMVblank, VblankSetFixedFps)
 577 {
 578         TDM_UT_SKIP_FLAG(has_outputs);
 579
 580         ASSERT_EQ(TestCreateVblanks(), true);
 581
 582         for (int v = 0; v < vblank_count; v++)
 583                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 60), TDM_ERROR_NONE);
 584 }
 585
 586 TEST_P(TDMVblank, VblankSetFixedFpsNullObject)
 587 {
 588         ASSERT_EQ(tdm_vblank_set_fixed_fps(NULL, 60), TDM_ERROR_INVALID_PARAMETER);
 589 }
 590
 591 TEST_P(TDMVblank, VblankSetFixedFpsTwice)
 592 {
 593         TDM_UT_SKIP_FLAG(has_outputs);
 594
 595         ASSERT_EQ(TestCreateVblanks(), true);
 596
 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);
 600         }
 601 }
 602
 603 /* tdm_vblank_get_fps() */
 604 TEST_P(TDMVblank, VblankGetFps)
 605 {
 606         TDM_UT_SKIP_FLAG(has_outputs);
 607
 608         ASSERT_EQ(TestCreateVblanks(), true);
 609
 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);
 614                 ASSERT_EQ(fps, 60);
 615         }
 616 }
 617
 618 TEST_P(TDMVblank, VblankGetFpsNullObject)
 619 {
 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);
 623 }
 624
 625 TEST_P(TDMVblank, VblankGetFpsNullOther)
 626 {
 627         TDM_UT_SKIP_FLAG(has_outputs);
 628
 629         ASSERT_EQ(TestCreateVblanks(), true);
 630
 631         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 632 }
 633
 634 TEST_P(TDMVblank, VblankGetFpsNoSet)
 635 {
 636         TDM_UT_SKIP_FLAG(has_outputs);
 637
 638         ASSERT_EQ(TestPrepareOutput(), true);
 639         ASSERT_EQ(TestCreateVblanks(), true);
 640
 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;
 644                 tdm_error ret;
 645
 646                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
 647                         continue;
 648
 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);
 651
 652                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
 653                 ASSERT_NE(output, NULL);
 654                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 655
 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);
 658
 659                 ASSERT_EQ(fps, mode->vrefresh);
 660         }
 661 }
 662
 663 TEST_P(TDMVblank, VblankGetFpsAfterSetFixedFps)
 664 {
 665         TDM_UT_SKIP_FLAG(has_outputs);
 666
 667         ASSERT_EQ(TestCreateVblanks(), true);
 668
 669         for (int v = 0; v < vblank_count; v++) {
 670                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 671
 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);
 674                 ASSERT_EQ(fps, 60);
 675
 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);
 678                 ASSERT_EQ(fps, 10);
 679
 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.
 683                  */
 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);
 686                 ASSERT_EQ(fps, 10);
 687         }
 688 }
 689
 690 /* tdm_vblank_ignore_global_fps() */
 691 TEST_P(TDMVblank, VblankIgnoreGlobalFpsNullObject)
 692 {
 693         ASSERT_EQ(tdm_vblank_ignore_global_fps(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 694 }
 695
 696 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSet)
 697 {
 698         TDM_UT_SKIP_FLAG(has_outputs);
 699
 700         ASSERT_EQ(TestCreateVblanks(), true);
 701
 702         for (int v = 0; v < vblank_count; v++)
 703                 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 1), TDM_ERROR_NONE);
 704 }
 705
 706 TEST_P(TDMVblank, VblankIgnoreGlobalFpsSetTwice)
 707 {
 708         TDM_UT_SKIP_FLAG(has_outputs);
 709
 710         ASSERT_EQ(TestCreateVblanks(), true);
 711
 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);
 715         }
 716 }
 717
 718 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnset)
 719 {
 720         TDM_UT_SKIP_FLAG(has_outputs);
 721
 722         ASSERT_EQ(TestCreateVblanks(), true);
 723
 724         for (int v = 0; v < vblank_count; v++)
 725                 ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[v], 0), TDM_ERROR_NONE);
 726 }
 727
 728 TEST_P(TDMVblank, VblankIgnoreGlobalFpsUnsetTwice)
 729 {
 730         TDM_UT_SKIP_FLAG(has_outputs);
 731
 732         ASSERT_EQ(TestCreateVblanks(), true);
 733
 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);
 737         }
 738 }
 739
 740 /* tdm_vblank_set_offset() */
 741 TEST_P(TDMVblank, VblankSetOffset)
 742 {
 743         TDM_UT_SKIP_FLAG(has_outputs);
 744
 745         ASSERT_EQ(TestCreateVblanks(), true);
 746
 747         for (int v = 0; v < vblank_count; v++)
 748                 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 10), TDM_ERROR_NONE);
 749 }
 750
 751 TEST_P(TDMVblank, VblankSetOffsetNullObject)
 752 {
 753         ASSERT_EQ(tdm_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 754 }
 755
 756 TEST_P(TDMVblank, VblankSetOffsetTwice)
 757 {
 758         TDM_UT_SKIP_FLAG(has_outputs);
 759
 760         ASSERT_EQ(TestCreateVblanks(), true);
 761
 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);
 765         }
 766 }
 767
 768 /* tdm_vblank_get_offset() */
 769 TEST_P(TDMVblank, VblankGetOffset)
 770 {
 771         TDM_UT_SKIP_FLAG(has_outputs);
 772
 773         ASSERT_EQ(TestCreateVblanks(), true);
 774
 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);
 780         }
 781 }
 782
 783 TEST_P(TDMVblank, VblankGetOffsetNullObject)
 784 {
 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);
 788 }
 789
 790 TEST_P(TDMVblank, VblankGetOffsetNullOther)
 791 {
 792         TDM_UT_SKIP_FLAG(has_outputs);
 793
 794         ASSERT_EQ(TestCreateVblanks(), true);
 795
 796         ASSERT_EQ(tdm_vblank_get_offset(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 797 }
 798
 799 TEST_P(TDMVblank, VblankGetOffsetNoSet)
 800 {
 801         TDM_UT_SKIP_FLAG(has_outputs);
 802
 803         ASSERT_EQ(TestCreateVblanks(), true);
 804
 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);
 809         }
 810 }
 811
 812 /* tdm_vblank_set_enable_fake() */
 813 TEST_P(TDMVblank, VblankSetEnableFake)
 814 {
 815         TDM_UT_SKIP_FLAG(has_outputs);
 816
 817         ASSERT_EQ(TestCreateVblanks(), true);
 818
 819         for (int v = 0; v < vblank_count; v++)
 820                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
 821 }
 822
 823 TEST_P(TDMVblank, VblankSetEnableFakeNullObject)
 824 {
 825         ASSERT_EQ(tdm_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 826 }
 827
 828 TEST_P(TDMVblank, VblankSetEnableFakeTwice)
 829 {
 830         TDM_UT_SKIP_FLAG(has_outputs);
 831
 832         ASSERT_EQ(TestCreateVblanks(), true);
 833
 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);
 837         }
 838 }
 839
 840 /* tdm_vblank_get_enable_fake() */
 841 TEST_P(TDMVblank, VblankGetEnableFake)
 842 {
 843         TDM_UT_SKIP_FLAG(has_outputs);
 844
 845         ASSERT_EQ(TestCreateVblanks(), true);
 846
 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);
 852
 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);
 856         }
 857 }
 858
 859 TEST_P(TDMVblank, VblankGetEnableFakeNullObject)
 860 {
 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);
 864 }
 865
 866 TEST_P(TDMVblank, VblankGetEnableFakeNullOther)
 867 {
 868         TDM_UT_SKIP_FLAG(has_outputs);
 869
 870         ASSERT_EQ(TestCreateVblanks(), true);
 871
 872         ASSERT_EQ(tdm_vblank_get_enable_fake(vblanks[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 873 }
 874
 875 TEST_P(TDMVblank, VblankGetEnableFakeNoSet)
 876 {
 877         TDM_UT_SKIP_FLAG(has_outputs);
 878
 879         ASSERT_EQ(TestCreateVblanks(), true);
 880
 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);
 885         }
 886 }
 887
 888 static void
 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)
 891 {
 892         unsigned int *cur_seq = (unsigned int *)user_data;
 893         if (cur_seq)
 894                 *cur_seq = (error == TDM_ERROR_NONE) ? sequence : ((unsigned int)-1);
 895 }
 896
 897 TEST_P(TDMVblank, VblankWait)
 898 {
 899         TDM_UT_SKIP_FLAG(has_outputs);
 900
 901         ASSERT_EQ(TestPrepareOutput(), true);
 902         ASSERT_EQ(TestCreateVblanks(), true);
 903
 904         for (int v = 0; v < vblank_count; v++) {
 905                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 906                 double start, end, interval;
 907
 908                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
 909                         continue;
 910
 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;
 914
 915                 for (int t = 0; t < 10; t++) {
 916                         unsigned int cur_seq = 0;
 917
 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);
 920                         while (cur_seq == 0)
 921                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 922                         end = tdm_helper_get_time();
 923
 924                         /* "+ interval" consider the delay of socket communication between kernel and platform */
 925                         ASSERT_LT((end - start), (interval + interval));
 926                 }
 927         }
 928 }
 929
 930 TEST_P(TDMVblank, VblankWaitFewTime)
 931 {
 932         TDM_UT_SKIP_FLAG(has_outputs);
 933
 934         ASSERT_EQ(TestPrepareOutput(), true);
 935         ASSERT_EQ(TestCreateVblanks(), true);
 936
 937         for (int v = 0; v < vblank_count; v++) {
 938                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 939                 double start, end, interval;
 940
 941                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
 942                         continue;
 943
 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;
 947
 948                 for (int t = 0; t < 10; t++) {
 949                         unsigned int cur_seq, seq1, seq2;
 950
 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);
 956                         while (cur_seq == 0)
 957                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 958                         end = tdm_helper_get_time();
 959
 960                         ASSERT_NE(seq1, 0);
 961                         ASSERT_NE(seq2, 0);
 962
 963                         /* "+ interval" consider the delay of socket communication between kernel and platform */
 964                         ASSERT_LT((end - start), (interval + interval));
 965                 }
 966         }
 967 }
 968
 969 TEST_P(TDMVblank, VblankWaitInterval0)
 970 {
 971         TDM_UT_SKIP_FLAG(has_outputs);
 972
 973         ASSERT_EQ(TestPrepareOutput(), true);
 974         ASSERT_EQ(TestCreateVblanks(), true);
 975
 976         ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 977 }
 978
 979 TEST_P(TDMVblank, VblankWaitInterval)
 980 {
 981         TDM_UT_SKIP_FLAG(has_outputs);
 982
 983         ASSERT_EQ(TestPrepareOutput(), true);
 984         ASSERT_EQ(TestCreateVblanks(), true);
 985
 986         for (int v = 0; v < vblank_count; v++) {
 987                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
 988                 double start, end, interval;
 989
 990                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
 991                         continue;
 992
 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;
 996
 997                 /* start from 1 */
 998                 for (int t = 1; t < 10; t++) {
 999                         unsigned int cur_seq = 0;
1000
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();
1006
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);
1010                 }
1011         }
1012 }
1013
1014 TEST_P(TDMVblank, VblankWaitSeq)
1015 {
1016         TDM_UT_SKIP_FLAG(has_outputs);
1017
1018         ASSERT_EQ(TestPrepareOutput(), true);
1019         ASSERT_EQ(TestCreateVblanks(), true);
1020
1021         for (int v = 0; v < vblank_count; v++) {
1022                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1023                 double start, end, interval;
1024
1025                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1026                         continue;
1027
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;
1031
1032                 for (int t = 0; t < 10; t++) {
1033                         unsigned int cur_seq = 0, temp = 0;
1034
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);
1038
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);
1041                         while (temp == 0)
1042                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1043                         end = tdm_helper_get_time();
1044
1045                         /* "+ interval" consider the delay of socket communication between kernel and platform */
1046                         ASSERT_LT((end - start), (interval + interval));
1047                 }
1048         }
1049 }
1050
1051 TEST_P(TDMVblank, VblankWaitSeqInterval)
1052 {
1053         TDM_UT_SKIP_FLAG(has_outputs);
1054
1055         ASSERT_EQ(TestPrepareOutput(), true);
1056         ASSERT_EQ(TestCreateVblanks(), true);
1057
1058         for (int v = 0; v < vblank_count; v++) {
1059                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1060                 double start, end, interval;
1061
1062                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1063                         continue;
1064
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;
1068
1069                 /* start from 1 */
1070                 for (int t = 1; t < 10; t++) {
1071                         unsigned int cur_seq = 0, temp = 0;
1072
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);
1076
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);
1079                         while (temp == 0)
1080                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1081                         end = tdm_helper_get_time();
1082
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));
1086                 }
1087         }
1088 }
1089
1090 TEST_P(TDMVblank, VblankWaitNullObject)
1091 {
1092         TDM_UT_SKIP_FLAG(has_outputs);
1093
1094         unsigned int cur_seq = 0;
1095
1096         ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1097 }
1098
1099 TEST_P(TDMVblank, VblankWaitNullOther)
1100 {
1101         TDM_UT_SKIP_FLAG(has_outputs);
1102
1103         ASSERT_EQ(TestCreateVblanks(), true);
1104
1105         ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1106 }
1107
1108 TEST_P(TDMVblank, VblankWaitDpmsOff)
1109 {
1110         TDM_UT_SKIP_FLAG(has_outputs);
1111
1112         ASSERT_EQ(TestPrepareOutput(), true);
1113         ASSERT_EQ(TestCreateVblanks(), true);
1114
1115         for (int v = 0; v < vblank_count; v++) {
1116                 tdm_error ret;
1117                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1118                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1119
1120                 if (!ut_tdm_output_is_connected(output))
1121                         continue;
1122
1123                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1124
1125                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF);
1126         }
1127 }
1128
1129 TEST_P(TDMVblank, VblankWaitBeforeDpmsOff)
1130 {
1131         TDM_UT_SKIP_FLAG(has_outputs);
1132
1133         ASSERT_EQ(TestPrepareOutput(), true);
1134         ASSERT_EQ(TestCreateVblanks(), true);
1135
1136         for (int v = 0; v < vblank_count; v++) {
1137                 unsigned int temp = 0;
1138                 tdm_error ret;
1139                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1140                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1141
1142                 if (!ut_tdm_output_is_connected(output))
1143                         continue;
1144
1145                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE);
1146
1147                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1148
1149                 while (temp == 0)
1150                         ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1151         }
1152 }
1153
1154 TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff)
1155 {
1156         TDM_UT_SKIP_FLAG(has_outputs);
1157
1158         ASSERT_EQ(TestPrepareOutput(), true);
1159         ASSERT_EQ(TestCreateVblanks(), true);
1160
1161         for (int v = 0; v < vblank_count; v++) {
1162                 tdm_error ret;
1163                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1164                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1165
1166                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1167                         continue;
1168
1169                 if (!ut_tdm_output_is_connected(output))
1170                         continue;
1171
1172                 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1173
1174                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE);
1175
1176                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1177         }
1178 }
1179
1180 TEST_P(TDMVblank, VblankWaitDisconnectedOutput)
1181 {
1182         TDM_UT_SKIP_FLAG(has_outputs);
1183
1184         ASSERT_EQ(TestPrepareOutput(), true);
1185         ASSERT_EQ(TestCreateVblanks(), true);
1186
1187         for (int v = 0; v < vblank_count; v++) {
1188                 tdm_error ret;
1189                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1190                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1191
1192                 if (ut_tdm_output_is_connected(output))
1193                         continue;
1194
1195                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED);
1196         }
1197 }
1198
1199 TEST_P(TDMVblank, VblankWaitSetOffset)
1200 {
1201         TDM_UT_SKIP_FLAG(has_outputs);
1202
1203         ASSERT_EQ(TestPrepareOutput(), true);
1204         ASSERT_EQ(TestCreateVblanks(), true);
1205
1206         for (int v = 0; v < vblank_count; v++) {
1207                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1208                 double start, end, interval;
1209
1210                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1211                         continue;
1212
1213                 ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE);
1214
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;
1218
1219                 for (int t = 0; t < 3; t++) {
1220                         unsigned int cur_seq = 0;
1221
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();
1227
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));
1231                 }
1232         }
1233 }
1234
1235 TEST_P(TDMVblank, VblankWaitSetFps)
1236 {
1237         TDM_UT_SKIP_FLAG(has_outputs);
1238
1239         ASSERT_EQ(TestPrepareOutput(), true);
1240         ASSERT_EQ(TestCreateVblanks(), true);
1241
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;
1245
1246                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1247                         continue;
1248
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;
1252
1253                 fps /= 2;
1254                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1255                 interval = 1.0 / (double)fps;
1256
1257                 for (int t = 0; t < 3; t++) {
1258                         unsigned int cur_seq = 0;
1259
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();
1265
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));
1269                 }
1270         }
1271 }
1272
1273 TEST_P(TDMVblank, VblankWaitSetFixedFps)
1274 {
1275         TDM_UT_SKIP_FLAG(has_outputs);
1276
1277         ASSERT_EQ(TestPrepareOutput(), true);
1278         ASSERT_EQ(TestCreateVblanks(), true);
1279
1280         for (int v = 0; v < vblank_count; v++) {
1281                 unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1282                 double start, end, interval;
1283
1284                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1285                         continue;
1286
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;
1290
1291                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], fps), TDM_ERROR_NONE);
1292
1293                 /* this fps will be ignored because it has fixed fps value */
1294                 fps /= 2;
1295                 ASSERT_EQ(tdm_vblank_set_fps(vblanks[v], fps), TDM_ERROR_NONE);
1296
1297                 for (int t = 0; t < 3; t++) {
1298                         unsigned int cur_seq = 0;
1299
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();
1305
1306                         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1307                         ASSERT_LT((end - start), (interval + interval));
1308                 }
1309         }
1310 }
1311
1312 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1313 {
1314         TDM_UT_SKIP_FLAG(has_outputs);
1315
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;
1321
1322         ASSERT_EQ(TestPrepareOutput(), true);
1323         ASSERT_EQ(TestCreateVblanks3(), true);
1324         ASSERT_EQ(vblank_count, 3);
1325
1326         if (!ut_tdm_vblank_is_avaiable(vblanks[0]))
1327                 return;
1328
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;
1332
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));
1336         }
1337
1338         /* enable test. global fps doesn't effect server's vblanks */
1339         tdm_vblank_enable_global_fps(1, global_fps);
1340
1341         for (int v = 0; v < 3; v++) {
1342                 cur_seq[v] = 0;
1343                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1344         }
1345
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();
1350
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));
1354
1355         ASSERT_EQ(cur_seq[1], 0);
1356         ASSERT_EQ(cur_seq[0], 0);
1357
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);
1361
1362         while (cur_seq[0] == 0)
1363                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1364
1365         /* disable test. global fps doesn't effect server's vblanks */
1366         tdm_vblank_enable_global_fps(0, 0);
1367
1368         for (int v = 0; v < 3; v++) {
1369                 cur_seq[v] = 0;
1370                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1371         }
1372
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);
1377
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);
1381 }
1382
1383 TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected)
1384 {
1385         TDM_UT_SKIP_FLAG(has_outputs);
1386
1387         ASSERT_EQ(TestPrepareOutput(), true);
1388         ASSERT_EQ(TestCreateVblanks(), true);
1389
1390         for (int v = 0; v < vblank_count; v++) {
1391                 tdm_error ret;
1392                 tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret);
1393                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1394
1395                 if (!ut_tdm_vblank_is_avaiable(vblanks[v]))
1396                         continue;
1397
1398                 if (ut_tdm_output_is_connected(output))
1399                         continue;
1400
1401                 ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF);
1402
1403                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE);
1404         }
1405 }
1406
1407 TEST_P(TDMVblank, DISABLED_VblankWaitBeforeDpmsOff)
1408 {
1409         /* wait vblank -> dpms off -> then? (vblank handler is called? or not?) */
1410 }
1411
1412 #ifdef TDM_UT_TEST_WITH_PARAMS
1413 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1414                                                 TDMVblank,
1415                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1416 #else
1417 INSTANTIATE_TEST_CASE_P(TDMVblankParams,
1418                                                 TDMVblank,
1419                                                 Values(TDM_DEFAULT_MODULE));
1420 #endif