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 "gtest/gtest.h"
  32 #include "tdm.h"
  33 #include "tbm_bufmgr.h"
  34 #include "ut_common.h"
  35 #include <sys/epoll.h>
  36 #include <sys/timerfd.h>
  37 #include <pthread.h>
  38
  39 class TDMVblankWithoutCreating: public ::testing::Test {
  40 protected:
  41         tbm_bufmgr bufmgr = NULL;
  42         tdm_display *dpy = NULL;
  43         int output_count = 0;
  44         bool has_output = 0;
  45         tdm_output *connected_output = NULL;
  46         const tdm_output_mode *preferred_mode = NULL;
  47         tdm_output *disconnected_output = NULL;
  48         tdm_output *default_output = NULL;
  49
  50         void SetUp(void) {
  51                 tdm_output *output;
  52                 tdm_output_conn_status status;
  53                 tdm_error error = TDM_ERROR_NONE;
  54
  55                 setenv("TDM_DLOG", "1", 1);
  56                 setenv("XDG_RUNTIME_DIR", ".", 1);
  57                 setenv("TBM_DLOG", "1", 1);
  58                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  59
  60                 bufmgr = tbm_bufmgr_init(-1);
  61                 ASSERT_FALSE(bufmgr == NULL);
  62
  63                 dpy = tdm_display_init(&error);
  64                 ASSERT_TRUE(error == TDM_ERROR_NONE);
  65                 ASSERT_FALSE(dpy == NULL);
  66
  67                 error = tdm_display_get_output_count(dpy, &output_count);
  68                 ASSERT_TRUE(error == TDM_ERROR_NONE);
  69                 if (output_count > 0)
  70                         has_output = true;
  71                 else
  72                         has_output = false;
  73
  74                 for(int i = 0; i < output_count; i++) {
  75                         output = tdm_display_get_output(dpy, i, &error);
  76                         ASSERT_TRUE(error == TDM_ERROR_NONE);
  77                         ASSERT_FALSE(dpy == NULL);
  78
  79                         error = tdm_output_get_conn_status(output, &status);
  80                         ASSERT_TRUE(error == TDM_ERROR_NONE);
  81
  82                         if (status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
  83                                 connected_output = output;
  84                         else
  85                                 disconnected_output = output;
  86                 }
  87
  88                 default_output = disconnected_output;
  89
  90                 if (connected_output) {
  91                         int output_modes_cnt = 0;
  92                         const tdm_output_mode* output_modes;
  93
  94                         error = tdm_output_get_available_modes(connected_output, &output_modes, &output_modes_cnt);
  95                         ASSERT_TRUE(error == TDM_ERROR_NONE);
  96                         if (output_modes_cnt <= 0) {
  97                                 connected_output = NULL;
  98                                 return;
  99                         }
 100
 101                         for(int i = 0; i < output_modes_cnt; i++) {
 102                                 if(output_modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) {
 103                                         preferred_mode = &output_modes[i];
 104
 105                                         default_output = connected_output;
 106
 107                                         return;
 108                                 }
 109                         }
 110                 }
 111
 112                 connected_output = NULL;
 113         }
 114         void TearDown(void)
 115         {
 116                 if (connected_output)
 117                         tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
 118                 if (bufmgr)
 119                         tbm_bufmgr_deinit(bufmgr);
 120                 if (dpy)
 121                         tdm_display_deinit(dpy);
 122
 123                 bufmgr = NULL;
 124                 dpy = NULL;
 125         }
 126 };
 127
 128 class TDMVblank: public TDMVblankWithoutCreating {
 129 protected:
 130         tdm_vblank *con_output_vblank = NULL;
 131         tdm_vblank *discon_output_vblank = NULL;
 132         tdm_output *default_vblank = NULL;
 133         int setModeAndDpms = 0;
 134         tbm_surface_h buffer = NULL;
 135         tdm_layer *layer = NULL;
 136
 137         void SetUp(void)
 138         {
 139                 tdm_error error;
 140
 141                 TDMVblankWithoutCreating::SetUp();
 142
 143                 if (connected_output && setModeAndDpms) {
 144                         int primary_index;
 145                         tdm_info_layer info = {0};
 146
 147                         error = tdm_output_set_mode(connected_output, preferred_mode);
 148                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 149
 150                         error = tdm_output_get_primary_index(connected_output, &primary_index);
 151                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 152
 153                         layer = tdm_output_get_layer(connected_output, primary_index, &error);
 154                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 155                         ASSERT_TRUE(layer != NULL);
 156
 157                         info.src_config.size.h = preferred_mode->hdisplay;
 158                         info.src_config.size.v = preferred_mode->vdisplay;
 159                         info.src_config.pos.x = 0;
 160                         info.src_config.pos.y = 0;
 161                         info.src_config.pos.w = preferred_mode->hdisplay;
 162                         info.src_config.pos.h = preferred_mode->vdisplay;
 163                         info.src_config.format = TBM_FORMAT_ARGB8888;
 164                         info.dst_pos.x = 0;
 165                         info.dst_pos.y = 0;
 166                         info.dst_pos.w = preferred_mode->hdisplay;
 167                         info.dst_pos.h = preferred_mode->vdisplay;
 168                         info.transform = TDM_TRANSFORM_NORMAL;
 169
 170                         error = tdm_layer_set_info(layer, &info);
 171                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 172
 173                         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_ON);
 174                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 175
 176                         buffer = tbm_surface_internal_create_with_flags(preferred_mode->hdisplay,
 177                                                                                                                         preferred_mode->vdisplay,
 178                                                                                                                         TBM_FORMAT_ARGB8888,
 179                                                                                                                         TBM_BO_SCANOUT);
 180                         ASSERT_TRUE(buffer != NULL);
 181
 182                         error = tdm_layer_set_buffer(layer, buffer);
 183                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 184
 185                         error = tdm_output_commit(connected_output, 0, NULL, NULL);
 186                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 187                         /* TODO: use a commit handler instead of an usleep to wait when
 188                          * commit will be applied */
 189                         usleep(20000);
 190                 }
 191
 192                 if (disconnected_output) {
 193                         discon_output_vblank = tdm_vblank_create(dpy, disconnected_output, &error);
 194                         EXPECT_TRUE(discon_output_vblank != NULL);
 195                         EXPECT_TRUE(error == TDM_ERROR_NONE);
 196                         default_vblank = discon_output_vblank;
 197                 }
 198
 199                 if (connected_output) {
 200                         con_output_vblank = tdm_vblank_create(dpy, connected_output, &error);
 201                         EXPECT_TRUE(con_output_vblank != NULL);
 202                         EXPECT_TRUE(error == TDM_ERROR_NONE);
 203                         default_vblank = con_output_vblank;
 204                 }
 205
 206                 ASSERT_TRUE(default_vblank != NULL);
 207         }
 208
 209         void TearDown(void)
 210         {
 211                 if (buffer) {
 212                         tdm_layer_unset_buffer(layer);
 213                         tdm_output_commit(connected_output, 0, NULL, NULL);
 214                         tbm_surface_destroy(buffer);
 215                 }
 216
 217                 TDMVblankWithoutCreating::TearDown();
 218         }
 219 };
 220
 221 class TDMVblankWait : public TDMVblank {
 222 public:
 223         static int utVblankHandlerIsCalled;
 224         static void UtVblankHandler(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 225                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 226          {
 227                 int *data = (int *)user_data;
 228
 229                 if (data)
 230                         *data = 1;
 231
 232                 utVblankHandlerIsCalled = 1;
 233         }
 234         int utWaitVblankThreadHndlResult = -1;
 235         friend void *UtWaitVblankThreadHndl(void *ptr);
 236         int utWaitVblankSeqThreadHndlResult = -1;
 237         friend void *UtWaitVblankSeqThreadHndl(void *ptr);
 238
 239 private:
 240         int epFd = -1;
 241         int timerFd = -1;
 242         int tdmFd = -1;
 243         static const int timeLimitSec = 1;
 244
 245 protected:
 246         void SetUp(void)
 247          {
 248                 struct epoll_event ep;
 249
 250                 utVblankHandlerIsCalled = 0;
 251
 252                 setModeAndDpms = 1;
 253                 TDMVblank::SetUp();
 254
 255                 epFd = epoll_create1(0);
 256                 ASSERT_TRUE(epFd != -1);
 257
 258                 timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
 259                 ASSERT_TRUE(timerFd != -1);
 260
 261                 memset(&ep, 0, sizeof ep);
 262                 ep.events |= EPOLLIN;
 263                 ep.data.fd = timerFd;
 264                 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
 265
 266                 ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
 267
 268                 memset(&ep, 0, sizeof ep);
 269                 ep.events |= EPOLLIN;
 270                 ep.data.fd = tdmFd;
 271                 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
 272         }
 273
 274         void UtHandleVblankEvent()
 275         {
 276                 struct itimerspec its;
 277                 int count;
 278                 struct epoll_event ep_event[2];
 279
 280                 if (utVblankHandlerIsCalled)
 281                         return;
 282
 283                 its.it_interval.tv_sec = 0;
 284                 its.it_interval.tv_nsec = 0;
 285                 its.it_value.tv_sec = timeLimitSec;
 286                 its.it_value.tv_nsec = 0;
 287
 288                 ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
 289
 290                 while (1) {
 291                         count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
 292                         ASSERT_TRUE(count >= 0);
 293
 294                         for (int i = 0; i < count; i++) {
 295                                 if (ep_event[i].data.fd == timerFd) {
 296                                         return;
 297                                 } else {
 298                                         ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
 299                                         if (utVblankHandlerIsCalled)
 300                                                 return;
 301                                 }
 302                         }
 303                 }
 304         }
 305 };
 306
 307 class TDMVblankWaitThread : public TDMVblankWait {
 308 protected:
 309         void SetUp(void)
 310         {
 311                 setenv("TDM_THREAD", "1", 1);
 312                 TDMVblankWait::SetUp();
 313         }
 314 };
 315
 316 int TDMVblankWait::utVblankHandlerIsCalled = 0;
 317
 318 /* tdm_vblank_enable_global_fps() */
 319
 320 TEST_F(TDMVblankWithoutCreating, VblankEnableGlobalFpFailFpsNull)
 321 {
 322         tdm_error error = TDM_ERROR_BAD_MODULE;
 323
 324         SKIP_FLAG(has_output);
 325         ASSERT_EXIT({error = tdm_vblank_enable_global_fps(1, 0);
 326                                 if (error == TDM_ERROR_NONE)
 327                                         exit(1);
 328                                         exit(0);},
 329                                 ::testing::ExitedWithCode(0), "");
 330 }
 331
 332 TEST_F(TDMVblankWithoutCreating, VblankEnableGlobalFpsSuccessEnable)
 333 {
 334         tdm_error error = TDM_ERROR_BAD_MODULE;
 335
 336         SKIP_FLAG(has_output);
 337         ASSERT_EXIT({error = tdm_vblank_enable_global_fps(1, 60);
 338                                 if (error != TDM_ERROR_NONE)
 339                                         exit(1);
 340                                         exit(0);},
 341                                 ::testing::ExitedWithCode(0), "");
 342 }
 343
 344 TEST_F(TDMVblankWithoutCreating, VblankEnableGlobalFpsSuccessDisable)
 345 {
 346         tdm_error error = TDM_ERROR_BAD_MODULE;
 347
 348         SKIP_FLAG(has_output);
 349         ASSERT_EXIT({error = tdm_vblank_enable_global_fps(0, 0);
 350                                 if (error != TDM_ERROR_NONE)
 351                                         exit(1);
 352                                         exit(0);},
 353                                 ::testing::ExitedWithCode(0), "");
 354 }
 355
 356 /* tdm_vblank_create() */
 357
 358 TEST_F(TDMVblankWithoutCreating, VblankCreateFailNullAll)
 359 {
 360         tdm_vblank *ret_vblank;
 361
 362         SKIP_FLAG(has_output);
 363
 364         ret_vblank = tdm_vblank_create(NULL, NULL, NULL);
 365         ASSERT_TRUE(ret_vblank == NULL);
 366 }
 367
 368 TEST_F(TDMVblankWithoutCreating, VblankCreateFailNullDpy)
 369 {
 370         tdm_vblank *ret_vblank;
 371         tdm_error error;
 372
 373         SKIP_FLAG(has_output);
 374
 375         ret_vblank = tdm_vblank_create(NULL, default_output, &error);
 376         ASSERT_TRUE(ret_vblank == NULL);
 377         ASSERT_TRUE(error == TDM_ERROR_INVALID_PARAMETER);
 378 }
 379
 380 TEST_F(TDMVblankWithoutCreating, VblankCreateFailNullOutput)
 381 {
 382         tdm_vblank *ret_vblank;
 383         tdm_error error;
 384
 385         SKIP_FLAG(has_output);
 386
 387         ret_vblank = tdm_vblank_create(dpy, NULL, &error);
 388         ASSERT_TRUE(ret_vblank == NULL);
 389         ASSERT_TRUE(error == TDM_ERROR_INVALID_PARAMETER);
 390 }
 391
 392 TEST_F(TDMVblankWithoutCreating, VblankCreateFailWrongDpy)
 393 {
 394         tdm_vblank *ret_vblank = NULL;
 395         tdm_error error;
 396
 397         SKIP_FLAG(has_output);
 398
 399         ASSERT_EXIT({ret_vblank = tdm_vblank_create((tdm_display *)0xFFFFFFFF, default_output, &error);
 400                                 if (ret_vblank || error == TDM_ERROR_NONE)
 401                                         exit(1);
 402                                 else
 403                                         exit(0);},
 404                                 ::testing::ExitedWithCode(0), "");
 405 }
 406
 407 TEST_F(TDMVblankWithoutCreating, VblankCreateFailWrongOutput)
 408 {
 409         tdm_vblank *ret_vblank = NULL;
 410         tdm_error error;
 411
 412         SKIP_FLAG(has_output);
 413
 414         ASSERT_EXIT({ret_vblank = tdm_vblank_create(dpy, (tdm_output *)0xFFFFFFFF, &error);
 415                                 if (ret_vblank || error == TDM_ERROR_NONE)
 416                                         exit(1);
 417                                 else
 418                                         exit(0);},
 419                                 ::testing::ExitedWithCode(0), "");
 420 }
 421
 422 TEST_F(TDMVblankWithoutCreating, VblankCreateSuccessForConnectedOutput)
 423 {
 424         tdm_vblank *ret_vblank;
 425         tdm_error error;
 426
 427         SKIP_FLAG(has_output);
 428
 429         if (!connected_output)
 430                 return;
 431
 432         ret_vblank = tdm_vblank_create(dpy, connected_output, &error);
 433         ASSERT_TRUE(ret_vblank != NULL);
 434         ASSERT_TRUE(error == TDM_ERROR_NONE);
 435 }
 436
 437 TEST_F(TDMVblankWithoutCreating, VblankCreateSuccessForDisconnectedOutput)
 438 {
 439         tdm_vblank *ret_vblank;
 440         tdm_error error;
 441
 442         SKIP_FLAG(has_output);
 443
 444         if (!disconnected_output)
 445                 return;
 446
 447         ret_vblank = tdm_vblank_create(dpy, disconnected_output, &error);
 448         ASSERT_TRUE(ret_vblank != NULL);
 449         ASSERT_TRUE(error == TDM_ERROR_NONE);
 450 }
 451
 452 /* tdm_vblank_destroy() */
 453
 454 TEST_F(TDMVblank, VblankDestroyWrongVblankPtr)
 455 {
 456         SKIP_FLAG(has_output);
 457
 458         ASSERT_EXIT({tdm_vblank_destroy((tdm_vblank *)0xFFFFFFFF);},
 459                                 ::testing::ExitedWithCode(0), "");
 460 }
 461
 462 TEST_F(TDMVblank, VblankDestroySuccess)
 463 {
 464         tdm_error error;
 465         SKIP_FLAG(has_output);
 466
 467         tdm_vblank_destroy(con_output_vblank);
 468
 469         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 470         ASSERT_TRUE(error != TDM_ERROR_NONE);
 471 }
 472
 473 /* tdm_vblank_set_name() */
 474
 475 TEST_F(TDMVblank, VblankSetNameFailNullAll)
 476 {
 477         tdm_error error;
 478         SKIP_FLAG(has_output);
 479
 480         error = tdm_vblank_set_name(NULL, NULL);
 481         ASSERT_TRUE(error != TDM_ERROR_NONE);
 482 }
 483
 484 TEST_F(TDMVblank, VblankSetNameFailWrongVblankPtr)
 485 {
 486         tdm_error error = TDM_ERROR_BAD_MODULE;
 487
 488         SKIP_FLAG(has_output);
 489
 490         ASSERT_EXIT({error = tdm_vblank_set_name((tdm_vblank *)0xFFFFFFFF, "ut_vblank");
 491                                 if (error == TDM_ERROR_NONE)
 492                                         exit(1);
 493                                 else
 494                                         exit(0);},
 495                                 ::testing::ExitedWithCode(0), "");
 496 }
 497
 498 TEST_F(TDMVblank, VblankSetNameSuccess)
 499 {
 500         tdm_error error;
 501         SKIP_FLAG(has_output);
 502
 503         error = tdm_vblank_set_name(default_vblank, "ut_vblank");
 504         ASSERT_TRUE(error == TDM_ERROR_NONE);
 505 }
 506
 507 TEST_F(TDMVblank, VblankSetNameSuccessNullName)
 508 {
 509         tdm_error error;
 510         SKIP_FLAG(has_output);
 511
 512         error = tdm_vblank_set_name(default_vblank, NULL);
 513         ASSERT_TRUE(error == TDM_ERROR_NONE);
 514 }
 515
 516 /* tdm_vblank_get_name() */
 517
 518 TEST_F(TDMVblank, VblankGetNameFailNullAll)
 519 {
 520         tdm_error error;
 521         SKIP_FLAG(has_output);
 522
 523         error = tdm_vblank_get_name(NULL, NULL);
 524         ASSERT_TRUE(error != TDM_ERROR_NONE);
 525 }
 526
 527 TEST_F(TDMVblank, VblankGetNameFailNullVblank)
 528 {
 529         tdm_error error;
 530         const char *ret_name;
 531         SKIP_FLAG(has_output);
 532
 533         error = tdm_vblank_get_name(NULL, &ret_name);
 534         ASSERT_TRUE(error != TDM_ERROR_NONE);
 535 }
 536
 537 TEST_F(TDMVblank, VblankGetNameFailWrongVblankPtr)
 538 {
 539         tdm_error error = TDM_ERROR_BAD_MODULE;
 540         const char *ret_name;
 541
 542         SKIP_FLAG(has_output);
 543
 544         ASSERT_EXIT({error = tdm_vblank_get_name((tdm_vblank *)0xFFFFFFFF, &ret_name);
 545                                 if (error == TDM_ERROR_NONE)
 546                                         exit(1);
 547                                 else
 548                                         exit(0);},
 549                                 ::testing::ExitedWithCode(0), "");
 550 }
 551
 552 TEST_F(TDMVblank, VblankGetNameFailNullName)
 553 {
 554         tdm_error error;
 555         SKIP_FLAG(has_output);
 556
 557         error = tdm_vblank_get_name(default_vblank, NULL);
 558         ASSERT_TRUE(error != TDM_ERROR_NONE);
 559 }
 560
 561 TEST_F(TDMVblank, VblankGetNameSuccessWhithoutSetName)
 562 {
 563         tdm_error error;
 564         const char *ret_name;
 565         SKIP_FLAG(has_output);
 566
 567         error = tdm_vblank_get_name(default_vblank, &ret_name);
 568         ASSERT_TRUE(error == TDM_ERROR_NONE);
 569 }
 570
 571 TEST_F(TDMVblank, VblankGetNameSuccess)
 572 {
 573         tdm_error error;
 574         const char *ret_name;
 575         SKIP_FLAG(has_output);
 576         const char *set_name = "ut_vblank";
 577
 578         error = tdm_vblank_set_name(default_vblank, set_name);
 579         ASSERT_TRUE(error == TDM_ERROR_NONE);
 580
 581         error = tdm_vblank_get_name(default_vblank, &ret_name);
 582         ASSERT_TRUE(error == TDM_ERROR_NONE);
 583
 584         ASSERT_STREQ(set_name, ret_name);
 585 }
 586
 587 /* tdm_vblank_set_fps() */
 588
 589 TEST_F(TDMVblank, VblankSetFpsFailNullVblank)
 590 {
 591         tdm_error error;
 592         SKIP_FLAG(has_output);
 593
 594         error = tdm_vblank_set_fps(NULL, 10);
 595         ASSERT_TRUE(error != TDM_ERROR_NONE);
 596 }
 597
 598 TEST_F(TDMVblank, VblankSetFpsFailFpsNull)
 599 {
 600         tdm_error error;
 601         SKIP_FLAG(has_output);
 602
 603         error = tdm_vblank_set_fps(default_vblank, 0);
 604         ASSERT_TRUE(error != TDM_ERROR_NONE);
 605 }
 606
 607 TEST_F(TDMVblank, VblankSetFpsFailWrongVblankPtr)
 608 {
 609         tdm_error error = TDM_ERROR_BAD_MODULE;
 610
 611         SKIP_FLAG(has_output);
 612
 613         ASSERT_EXIT({error = tdm_vblank_set_fps((tdm_vblank *)0xFFFFFFFF, 60);
 614                                 if (error == TDM_ERROR_NONE)
 615                                         exit(1);
 616                                 else
 617                                         exit(0);},
 618                                 ::testing::ExitedWithCode(0), "");
 619 }
 620
 621 TEST_F(TDMVblank, VblankSetFpsSuccess)
 622 {
 623         tdm_error error;
 624         SKIP_FLAG(has_output);
 625
 626         error = tdm_vblank_set_fps(default_vblank, 60);
 627         ASSERT_TRUE(error == TDM_ERROR_NONE);
 628 }
 629
 630 TEST_F(TDMVblank, VblankSetFpsSuccessSetTwice)
 631 {
 632         tdm_error error;
 633         SKIP_FLAG(has_output);
 634
 635         error = tdm_vblank_set_fps(default_vblank, 60);
 636         ASSERT_TRUE(error == TDM_ERROR_NONE);
 637
 638         error = tdm_vblank_set_fps(default_vblank, 60);
 639         ASSERT_TRUE(error == TDM_ERROR_NONE);
 640 }
 641
 642 /* tdm_vblank_get_fps() */
 643
 644 TEST_F(TDMVblank, VblankGetFpsFailNullAll)
 645 {
 646         tdm_error error;
 647         SKIP_FLAG(has_output);
 648
 649         error = tdm_vblank_get_fps(NULL, NULL);
 650         ASSERT_TRUE(error != TDM_ERROR_NONE);
 651 }
 652
 653 TEST_F(TDMVblank, VblankGetFpsFailNullVblank)
 654 {
 655         tdm_error error;
 656         unsigned int ret_fps;
 657         SKIP_FLAG(has_output);
 658
 659         error = tdm_vblank_get_fps(NULL, &ret_fps);
 660         ASSERT_TRUE(error != TDM_ERROR_NONE);
 661 }
 662
 663 TEST_F(TDMVblank, VblankGetFpsFailNullFps)
 664 {
 665         tdm_error error;
 666         SKIP_FLAG(has_output);
 667
 668         error = tdm_vblank_get_fps(default_vblank, NULL);
 669         ASSERT_TRUE(error != TDM_ERROR_NONE);
 670 }
 671
 672 TEST_F(TDMVblank, VblankGetFpsFailWrongVblankPtr)
 673 {
 674         tdm_error error = TDM_ERROR_BAD_MODULE;
 675         unsigned int ret_fps;
 676
 677         SKIP_FLAG(has_output);
 678
 679         ASSERT_EXIT({error = tdm_vblank_get_fps((tdm_vblank *)0xFFFFFFFF, &ret_fps);
 680                                 if (error == TDM_ERROR_NONE)
 681                                         exit(1);
 682                                 else
 683                                         exit(0);},
 684                                 ::testing::ExitedWithCode(0), "");
 685 }
 686
 687 TEST_F(TDMVblank, VblankGetNameSuccessWhithoutSetFps)
 688 {
 689         tdm_error error;
 690         unsigned int ret_fps;
 691         SKIP_FLAG(has_output);
 692
 693         error = tdm_vblank_get_fps(default_vblank, &ret_fps);
 694         ASSERT_TRUE(error == TDM_ERROR_NONE);
 695 }
 696
 697 TEST_F(TDMVblank, VblankGetFpsSuccess)
 698 {
 699         tdm_error error;
 700         unsigned int ret_fps = 10;
 701         SKIP_FLAG(has_output);
 702         unsigned int set_fps = 50;
 703
 704         error = tdm_vblank_set_fps(default_vblank, set_fps);
 705         ASSERT_TRUE(error == TDM_ERROR_NONE);
 706
 707         error = tdm_vblank_get_fps(default_vblank, &ret_fps);
 708         ASSERT_TRUE(error == TDM_ERROR_NONE);
 709
 710         ASSERT_TRUE(set_fps == ret_fps);
 711 }
 712
 713 /* tdm_vblank_ignore_global_fps() */
 714
 715 TEST_F(TDMVblank, VblankIgnoreGlobalFpsFailNullVblank)
 716 {
 717         tdm_error error;
 718         SKIP_FLAG(has_output);
 719
 720         error = tdm_vblank_ignore_global_fps(NULL, 1);
 721         ASSERT_TRUE(error != TDM_ERROR_NONE);
 722 }
 723
 724 TEST_F(TDMVblank, VblankIgnoreGlobalFpsFailWrongVblankPtr)
 725 {
 726         tdm_error error = TDM_ERROR_BAD_MODULE;
 727
 728         SKIP_FLAG(has_output);
 729
 730         ASSERT_EXIT({error = tdm_vblank_ignore_global_fps((tdm_vblank *)0xFFFFFFFF, 1);
 731                                 if (error == TDM_ERROR_NONE)
 732                                         exit(1);
 733                                 else
 734                                         exit(0);},
 735                                 ::testing::ExitedWithCode(0), "");
 736 }
 737
 738 TEST_F(TDMVblank, VblankIgnoreGlobalFpsSuccessUnset)
 739 {
 740         tdm_error error;
 741         SKIP_FLAG(has_output);
 742
 743         error = tdm_vblank_ignore_global_fps(default_vblank, 0);
 744         ASSERT_TRUE(error == TDM_ERROR_NONE);
 745 }
 746
 747 TEST_F(TDMVblank, VblankIgnoreGlobalFpsSuccessUnsetTwice)
 748 {
 749         tdm_error error;
 750         SKIP_FLAG(has_output);
 751
 752         error = tdm_vblank_ignore_global_fps(default_vblank, 0);
 753         ASSERT_TRUE(error == TDM_ERROR_NONE);
 754
 755         error = tdm_vblank_ignore_global_fps(default_vblank, 0);
 756         ASSERT_TRUE(error == TDM_ERROR_NONE);
 757 }
 758
 759 TEST_F(TDMVblank, VblankIgnoreGlobalFpsSuccessSet)
 760 {
 761         tdm_error error;
 762         SKIP_FLAG(has_output);
 763
 764         error = tdm_vblank_ignore_global_fps(default_vblank, 1);
 765         ASSERT_TRUE(error == TDM_ERROR_NONE);
 766 }
 767
 768 TEST_F(TDMVblank, VblankIgnoreGlobalFpsSuccessSetTwice)
 769 {
 770         tdm_error error;
 771         SKIP_FLAG(has_output);
 772
 773         error = tdm_vblank_ignore_global_fps(default_vblank, 1);
 774         ASSERT_TRUE(error == TDM_ERROR_NONE);
 775
 776         error = tdm_vblank_ignore_global_fps(default_vblank, 1);
 777         ASSERT_TRUE(error == TDM_ERROR_NONE);
 778 }
 779
 780 /* tdm_vblank_set_offset() */
 781
 782 TEST_F(TDMVblank, VblankSetOffsetFailNullVblank)
 783 {
 784         tdm_error error;
 785         SKIP_FLAG(has_output);
 786
 787         error = tdm_vblank_set_offset(NULL, 10);
 788         ASSERT_TRUE(error != TDM_ERROR_NONE);
 789 }
 790
 791 TEST_F(TDMVblank, VblankSetOffsetFailFailWrongVblankPtr)
 792 {
 793         tdm_error error = TDM_ERROR_BAD_MODULE;
 794
 795         SKIP_FLAG(has_output);
 796
 797         ASSERT_EXIT({error = tdm_vblank_set_offset((tdm_vblank *)0xFFFFFFFF, 10);
 798                                 if (error == TDM_ERROR_NONE)
 799                                         exit(1);
 800                                 else
 801                                         exit(0);},
 802                                 ::testing::ExitedWithCode(0), "");
 803 }
 804
 805 TEST_F(TDMVblank, VblankSetOffsetSuccess)
 806 {
 807         tdm_error error;
 808         SKIP_FLAG(has_output);
 809
 810         error = tdm_vblank_set_offset(default_vblank, 50);
 811         ASSERT_TRUE(error == TDM_ERROR_NONE);
 812 }
 813
 814 TEST_F(TDMVblank, VblankSetOffsetSuccessSuccessSetTwice)
 815 {
 816         tdm_error error;
 817         SKIP_FLAG(has_output);
 818
 819         error = tdm_vblank_set_offset(default_vblank, 50);
 820         ASSERT_TRUE(error == TDM_ERROR_NONE);
 821
 822         error = tdm_vblank_set_offset(default_vblank, 50);
 823         ASSERT_TRUE(error == TDM_ERROR_NONE);
 824 }
 825
 826 /* tdm_vblank_get_offset() */
 827
 828 TEST_F(TDMVblank, VblankGetOffsetFailNullAll)
 829 {
 830         tdm_error error;
 831         SKIP_FLAG(has_output);
 832
 833         error = tdm_vblank_get_offset(NULL, NULL);
 834         ASSERT_TRUE(error != TDM_ERROR_NONE);
 835 }
 836
 837 TEST_F(TDMVblank, VblankGetOffsetFailNullVblank)
 838 {
 839         tdm_error error;
 840         int offset;
 841         SKIP_FLAG(has_output);
 842
 843         error = tdm_vblank_get_offset(NULL, &offset);
 844         ASSERT_TRUE(error != TDM_ERROR_NONE);
 845 }
 846
 847 TEST_F(TDMVblank, VblankGetOffsetFailNullOffset)
 848 {
 849         tdm_error error;
 850         SKIP_FLAG(has_output);
 851
 852         error = tdm_vblank_get_offset(default_vblank, NULL);
 853         ASSERT_TRUE(error != TDM_ERROR_NONE);
 854 }
 855
 856 TEST_F(TDMVblank, VblankGetOffsetFailWrongVblankPtr)
 857 {
 858         tdm_error error = TDM_ERROR_BAD_MODULE;
 859         int offset;
 860         SKIP_FLAG(has_output);
 861
 862         ASSERT_EXIT({error = tdm_vblank_get_offset((tdm_vblank *)0xFFFFFFFF, &offset);
 863                                 if (error == TDM_ERROR_NONE)
 864                                         exit(1);
 865                                 else
 866                                         exit(0);},
 867                                 ::testing::ExitedWithCode(0), "");
 868 }
 869
 870 TEST_F(TDMVblank, VblankGetOffsetFailWrongOffsetPtr)
 871 {
 872         tdm_error error = TDM_ERROR_BAD_MODULE;
 873         SKIP_FLAG(has_output);
 874
 875         ASSERT_EXIT({error = tdm_vblank_get_offset(default_vblank, (int *)0xFFFFFFFF);
 876                                 if (error == TDM_ERROR_NONE)
 877                                         exit(1);
 878                                 else
 879                                         exit(0);},
 880                                 ::testing::ExitedWithCode(0), "");
 881 }
 882
 883 TEST_F(TDMVblank, VblankGetOffsetSuccesWithoutSet)
 884 {
 885         tdm_error error;
 886         int offset;
 887
 888         SKIP_FLAG(has_output);
 889
 890         error = tdm_vblank_get_offset(default_vblank, &offset);
 891         ASSERT_TRUE(error == TDM_ERROR_NONE);
 892 }
 893
 894 TEST_F(TDMVblank, VblankGetOffsetSucces)
 895 {
 896         tdm_error error;
 897         int set_offset = 567;
 898         int ret_offset;
 899
 900         SKIP_FLAG(has_output);
 901
 902         error = tdm_vblank_set_offset(default_vblank, set_offset);
 903         ASSERT_TRUE(error != TDM_ERROR_NONE);
 904
 905         error = tdm_vblank_get_offset(default_vblank, &ret_offset);
 906         ASSERT_TRUE(error != TDM_ERROR_NONE);
 907
 908         ASSERT_TRUE(set_offset == ret_offset);
 909 }
 910
 911 /* tdm_vblank_set_enable_fake() */
 912
 913 TEST_F(TDMVblank, VblankSetEnableFakeFailNullVblank)
 914 {
 915         tdm_error error;
 916         SKIP_FLAG(has_output);
 917
 918         error = tdm_vblank_set_enable_fake(NULL, 1);
 919         ASSERT_TRUE(error != TDM_ERROR_NONE);
 920 }
 921
 922 TEST_F(TDMVblank, VblankSetEnableFakeFailFailWrongVblankPtr)
 923 {
 924         tdm_error error = TDM_ERROR_BAD_MODULE;
 925
 926         SKIP_FLAG(has_output);
 927
 928         ASSERT_EXIT({error = tdm_vblank_set_enable_fake((tdm_vblank *)0xFFFFFFFF, 1);
 929                                 if (error == TDM_ERROR_NONE)
 930                                         exit(1);
 931                                 else
 932                                         exit(0);},
 933                                 ::testing::ExitedWithCode(0), "");
 934 }
 935
 936 TEST_F(TDMVblank, VblankSetEnableFakeSuccessSet)
 937 {
 938         tdm_error error;
 939         SKIP_FLAG(has_output);
 940
 941         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 942         ASSERT_TRUE(error == TDM_ERROR_NONE);
 943 }
 944
 945 TEST_F(TDMVblank, VblankSetEnableFakeSuccessSetTwice)
 946 {
 947         tdm_error error;
 948         SKIP_FLAG(has_output);
 949
 950         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 951         ASSERT_TRUE(error == TDM_ERROR_NONE);
 952
 953         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 954         ASSERT_TRUE(error == TDM_ERROR_NONE);
 955 }
 956
 957 /* tdm_vblank_get_enable_fake() */
 958
 959 TEST_F(TDMVblank, VblankGetEnableFakeFailNullAll)
 960 {
 961         tdm_error error;
 962         SKIP_FLAG(has_output);
 963
 964         error = tdm_vblank_get_enable_fake(NULL, NULL);
 965         ASSERT_TRUE(error != TDM_ERROR_NONE);
 966 }
 967
 968 TEST_F(TDMVblank, VblankGetEnableFakeFailNullVblank)
 969 {
 970         tdm_error error;
 971         unsigned int enable_fake;
 972         SKIP_FLAG(has_output);
 973
 974         error = tdm_vblank_get_enable_fake(NULL, &enable_fake);
 975         ASSERT_TRUE(error != TDM_ERROR_NONE);
 976 }
 977
 978 TEST_F(TDMVblank, VblankGetEnableFakeFailNullEnableFake)
 979 {
 980         tdm_error error;
 981         SKIP_FLAG(has_output);
 982
 983         error = tdm_vblank_get_enable_fake(default_vblank, NULL);
 984         ASSERT_TRUE(error != TDM_ERROR_NONE);
 985 }
 986
 987 TEST_F(TDMVblank, VblankGetEnableFakeFailWrongVblankPtr)
 988 {
 989         tdm_error error = TDM_ERROR_BAD_MODULE;
 990         unsigned int enable_fake;
 991         SKIP_FLAG(has_output);
 992
 993         ASSERT_EXIT({error = tdm_vblank_get_enable_fake((tdm_vblank *)0xFFFFFFFF, &enable_fake);
 994                                 if (error == TDM_ERROR_NONE)
 995                                         exit(1);
 996                                 else
 997                                         exit(0);},
 998                                 ::testing::ExitedWithCode(0), "");
 999 }
1000
1001 TEST_F(TDMVblank, DISABLED_VblankGetEnableFakeFailWrongOffsetPtr)
1002 {
1003         tdm_error error = TDM_ERROR_BAD_MODULE;
1004         SKIP_FLAG(has_output);
1005
1006         ASSERT_EXIT({error = tdm_vblank_get_enable_fake(default_vblank, (unsigned int *)0xFFFFFFFF);
1007                                 if (error == TDM_ERROR_NONE)
1008                                         exit(1);
1009                                 else
1010                                         exit(0);},
1011                                 ::testing::ExitedWithCode(0), "");
1012 }
1013
1014 TEST_F(TDMVblank, VblankGetEnableFakeSuccessWithoutSet)
1015 {
1016         tdm_error error;
1017         unsigned int enable_fake;
1018
1019         SKIP_FLAG(has_output);
1020
1021         error = tdm_vblank_get_enable_fake(default_vblank, &enable_fake);
1022         ASSERT_TRUE(error == TDM_ERROR_NONE);
1023 }
1024
1025 TEST_F(TDMVblank, VblankGetEnableFakeSuccess)
1026 {
1027         tdm_error error;
1028         unsigned int set_enable_fake = 1;
1029         unsigned int ret_enable_fake;
1030
1031         SKIP_FLAG(has_output);
1032
1033         error = tdm_vblank_set_enable_fake(default_vblank, set_enable_fake);
1034         ASSERT_TRUE(error == TDM_ERROR_NONE);
1035
1036         error = tdm_vblank_get_enable_fake(default_vblank, &ret_enable_fake);
1037         ASSERT_TRUE(error == TDM_ERROR_NONE);
1038
1039         ASSERT_TRUE(set_enable_fake == ret_enable_fake);
1040 }
1041
1042 /* tdm_vblank_set_client_vblank_fps() */
1043
1044 /* TODO: need to create the tdm client */
1045 TEST_F(TDMVblank, VblankSetClientVblankFpsFailNullAll)
1046 {
1047         tdm_error error;
1048
1049         SKIP_FLAG(has_output);
1050
1051         error = tdm_vblank_set_client_vblank_fps(0, 0, 0);
1052         ASSERT_TRUE(error != TDM_ERROR_NONE);
1053 }
1054
1055 /* TODO: need to create the tdm client */
1056 TEST_F(TDMVblank, VblankSetClientVblankFpsFailNullPid)
1057 {
1058         tdm_error error;
1059
1060         SKIP_FLAG(has_output);
1061
1062         error = tdm_vblank_set_client_vblank_fps(0, 0, 0);
1063         ASSERT_TRUE(error != TDM_ERROR_NONE);
1064 }
1065
1066 /* tdm_vblank_wait() */
1067
1068 TEST_F(TDMVblank, VblankWaitFailNullAll)
1069 {
1070         tdm_error error;
1071
1072         SKIP_FLAG(has_output);
1073
1074         error = tdm_vblank_wait(NULL, 0, 0, 0, NULL, NULL);
1075         ASSERT_TRUE(error != TDM_ERROR_NONE);
1076 }
1077
1078 TEST_F(TDMVblankWait, VblankWaitFailNullVblank)
1079 {
1080         tdm_error error;
1081
1082         SKIP_FLAG(has_output);
1083
1084         error = tdm_vblank_wait(NULL, 0, 0, 1, UtVblankHandler, NULL);
1085         ASSERT_TRUE(error != TDM_ERROR_NONE);
1086 }
1087
1088 TEST_F(TDMVblankWait, VblankWaitFailNullFunc)
1089 {
1090         tdm_error error;
1091
1092         SKIP_FLAG(has_output);
1093
1094         error = tdm_vblank_wait(default_vblank, 0, 0, 1, NULL, NULL);
1095         ASSERT_TRUE(error != TDM_ERROR_NONE);
1096 }
1097
1098 TEST_F(TDMVblankWait, VblankWaitFailWrongVblankPtr)
1099 {
1100         tdm_error error = TDM_ERROR_BAD_MODULE;
1101         SKIP_FLAG(has_output);
1102
1103         ASSERT_EXIT({error = tdm_vblank_wait((tdm_vblank *)0xFFFFFFFF, 0, 0, 1, UtVblankHandler, NULL);;
1104                                 if (error == TDM_ERROR_NONE)
1105                                         exit(1);
1106                                 else
1107                                         exit(0);},
1108                                 ::testing::ExitedWithCode(0), "");
1109 }
1110
1111 void *UtWaitVblankThreadHndl(void *ptr)
1112 {
1113         tdm_error error;
1114         TDMVblankWait *vblankWait = (TDMVblankWait *)ptr;
1115
1116         error = tdm_vblank_wait(vblankWait->default_vblank, 0, 0, 1, TDMVblankWait::UtVblankHandler, NULL);
1117         if (error != TDM_ERROR_NONE)
1118                 vblankWait->utWaitVblankThreadHndlResult = 0;
1119         else
1120                 vblankWait->utWaitVblankThreadHndlResult = 0;
1121 }
1122
1123 TEST_F(TDMVblankWait, VblankWaitFailInOtherThread)
1124 {
1125         pthread_t thread;
1126
1127         SKIP_FLAG(has_output);
1128
1129         ASSERT_FALSE(pthread_create(&thread, NULL, UtWaitVblankThreadHndl, this));
1130
1131         ASSERT_FALSE(pthread_join(thread, NULL));
1132
1133         ASSERT_FALSE(utWaitVblankThreadHndlResult);
1134 }
1135
1136 TEST_F(TDMVblankWait, VblankWaitFailDisconnectedOutput)
1137 {
1138         tdm_error error;
1139
1140         SKIP_FLAG(has_output);
1141
1142         if (!discon_output_vblank)
1143                 return;
1144
1145         error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1146         ASSERT_TRUE(error != TDM_ERROR_NONE);
1147 }
1148
1149 TEST_F(TDMVblankWait, VblankWaitFailDpmsOff)
1150 {
1151         tdm_error error;
1152
1153         SKIP_FLAG(has_output);
1154
1155         if (!con_output_vblank)
1156                 return;
1157
1158         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1159         ASSERT_TRUE(error == TDM_ERROR_NONE);
1160
1161         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1162         ASSERT_TRUE(error != TDM_ERROR_NONE);
1163 }
1164
1165 TEST_F(TDMVblankWait, VblankWaitSuccessFpsNonMultipleVrefresh)
1166 {
1167         tdm_error error;
1168         int data = 0;
1169
1170         SKIP_FLAG(has_output);
1171
1172         if (!con_output_vblank)
1173                 return;
1174
1175         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1176         ASSERT_TRUE(error == TDM_ERROR_NONE);
1177
1178         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1179         ASSERT_TRUE(error == TDM_ERROR_NONE);
1180
1181         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1182         ASSERT_TRUE(error == TDM_ERROR_NONE);
1183
1184         UtHandleVblankEvent();
1185
1186         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1187         ASSERT_TRUE(data == 1);
1188 }
1189
1190 TEST_F(TDMVblankWait, VblankWaitSuccessFpsNonMultipleVrefreshRepeatedly)
1191 {
1192         tdm_error error;
1193         int data = 0;
1194
1195         SKIP_FLAG(has_output);
1196
1197         if (!con_output_vblank)
1198                 return;
1199
1200         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1201         ASSERT_TRUE(error == TDM_ERROR_NONE);
1202
1203         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1204         ASSERT_TRUE(error == TDM_ERROR_NONE);
1205
1206         for (int i = 0; i < 10; ++i) {
1207                 utVblankHandlerIsCalled = 0;
1208                 data = 0;
1209
1210                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1211                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1212
1213                 UtHandleVblankEvent();
1214
1215                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1216                 ASSERT_TRUE(data == 1);
1217         }
1218 }
1219
1220 TEST_F(TDMVblankWait, VblankWaitSuccessDisconnectedOutput)
1221 {
1222         tdm_error error;
1223         int data = 0;
1224
1225         SKIP_FLAG(has_output);
1226
1227         if (!discon_output_vblank)
1228                 return;
1229
1230         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1231         ASSERT_TRUE(error == TDM_ERROR_NONE);
1232
1233         error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1234         ASSERT_TRUE(error == TDM_ERROR_NONE);
1235
1236         UtHandleVblankEvent();
1237
1238         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1239         ASSERT_TRUE(data == 1);
1240 }
1241
1242 TEST_F(TDMVblankWait, VblankWaitSuccessDisconnectedOutputRepeatedly)
1243 {
1244         tdm_error error;
1245         int data = 0;
1246
1247         SKIP_FLAG(has_output);
1248
1249         if (!discon_output_vblank)
1250                 return;
1251
1252         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1253         ASSERT_TRUE(error == TDM_ERROR_NONE);
1254
1255         for (int i = 0; i < 10; ++i) {
1256                 utVblankHandlerIsCalled = 0;
1257                 data = 0;
1258
1259                 error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1260                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1261
1262                 UtHandleVblankEvent();
1263
1264                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1265                 ASSERT_TRUE(data == 1);
1266         }
1267 }
1268
1269 TEST_F(TDMVblankWait, VblankWaitSuccessHW)
1270 {
1271         tdm_error error;
1272         int data = 0;
1273
1274         SKIP_FLAG(has_output);
1275
1276         if (!con_output_vblank)
1277                 return;
1278
1279         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1280         ASSERT_TRUE(error == TDM_ERROR_NONE);
1281
1282         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1283         ASSERT_TRUE(error == TDM_ERROR_NONE);
1284
1285         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1286         ASSERT_TRUE(error == TDM_ERROR_NONE);
1287
1288         error = tdm_vblank_set_offset(con_output_vblank, 0);
1289         ASSERT_TRUE(error == TDM_ERROR_NONE);
1290
1291         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1292         ASSERT_TRUE(error == TDM_ERROR_NONE);
1293
1294         UtHandleVblankEvent();
1295
1296         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1297         ASSERT_TRUE(data == 1);
1298 }
1299
1300 TEST_F(TDMVblankWait, VblankWaitSuccessDestroy)
1301 {
1302         tdm_error error;
1303         int data = 0;
1304
1305         SKIP_FLAG(has_output);
1306
1307         if (!con_output_vblank)
1308                 return;
1309
1310         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1311         ASSERT_TRUE(error == TDM_ERROR_NONE);
1312
1313         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1314         ASSERT_TRUE(error == TDM_ERROR_NONE);
1315
1316         error = tdm_vblank_set_offset(con_output_vblank, 0);
1317         ASSERT_TRUE(error == TDM_ERROR_NONE);
1318
1319         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1320         ASSERT_TRUE(error == TDM_ERROR_NONE);
1321
1322         tdm_vblank_destroy(con_output_vblank);
1323
1324         ASSERT_TRUE(utVblankHandlerIsCalled == 0);
1325         ASSERT_TRUE(data == 0);
1326 }
1327
1328 TEST_F(TDMVblankWait, VblankWaitSuccessChangeDpms)
1329 {
1330         tdm_error error;
1331         int data = 0;
1332
1333         SKIP_FLAG(has_output);
1334
1335         if (!con_output_vblank)
1336                 return;
1337
1338         error = tdm_vblank_set_enable_fake(con_output_vblank, 0);
1339         ASSERT_TRUE(error == TDM_ERROR_NONE);
1340
1341         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1342         ASSERT_TRUE(error == TDM_ERROR_NONE);
1343
1344         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1345         ASSERT_TRUE(error == TDM_ERROR_NONE);
1346
1347         error = tdm_vblank_set_offset(con_output_vblank, 0);
1348         ASSERT_TRUE(error == TDM_ERROR_NONE);
1349
1350         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1351         ASSERT_TRUE(error == TDM_ERROR_NONE);
1352
1353         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1354         ASSERT_TRUE(error == TDM_ERROR_NONE);
1355
1356         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1357         ASSERT_TRUE(data == 1);
1358 }
1359
1360 TEST_F(TDMVblankWait, VblankWaitSuccessChangeDpmsWithEnableFake)
1361 {
1362         tdm_error error;
1363         int data = 0;
1364
1365         SKIP_FLAG(has_output);
1366
1367         if (!con_output_vblank)
1368                 return;
1369
1370         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1371         ASSERT_TRUE(error == TDM_ERROR_NONE);
1372
1373         error = tdm_vblank_set_enable_fake(con_output_vblank, 1);
1374         ASSERT_TRUE(error == TDM_ERROR_NONE);
1375
1376         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1377         ASSERT_TRUE(error == TDM_ERROR_NONE);
1378
1379         error = tdm_vblank_set_offset(con_output_vblank, 0);
1380         ASSERT_TRUE(error == TDM_ERROR_NONE);
1381
1382         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1383         ASSERT_TRUE(error == TDM_ERROR_NONE);
1384
1385         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1386         ASSERT_TRUE(error == TDM_ERROR_NONE);
1387
1388         UtHandleVblankEvent();
1389
1390         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1391         ASSERT_TRUE(data == 1);
1392 }
1393
1394 TEST_F(TDMVblankWait, VblankWaitSuccessHWRepeatedly)
1395 {
1396         tdm_error error;
1397         int data;
1398
1399         SKIP_FLAG(has_output);
1400
1401         if (!con_output_vblank)
1402                 return;
1403
1404         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1405         ASSERT_TRUE(error == TDM_ERROR_NONE);
1406
1407         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1408         ASSERT_TRUE(error == TDM_ERROR_NONE);
1409
1410         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1411         ASSERT_TRUE(error == TDM_ERROR_NONE);
1412
1413         error = tdm_vblank_set_offset(con_output_vblank, 0);
1414         ASSERT_TRUE(error == TDM_ERROR_NONE);
1415
1416         for (int i = 0; i < 10; ++i) {
1417                 utVblankHandlerIsCalled = 0;
1418                 data = 0;
1419
1420                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1421                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1422
1423                 UtHandleVblankEvent();
1424
1425                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1426                 ASSERT_TRUE(data == 1);
1427         }
1428 }
1429
1430 TEST_F(TDMVblankWait, VblankWaitSuccessOffsenGreaterThanZero)
1431 {
1432         tdm_error error;
1433         int data = 0;
1434
1435         SKIP_FLAG(has_output);
1436
1437         if (!con_output_vblank)
1438                 return;
1439
1440         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1441         ASSERT_TRUE(error == TDM_ERROR_NONE);
1442
1443         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1444         ASSERT_TRUE(error == TDM_ERROR_NONE);
1445
1446         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1447         ASSERT_TRUE(error == TDM_ERROR_NONE);
1448
1449         error = tdm_vblank_set_offset(con_output_vblank, 10);
1450         ASSERT_TRUE(error == TDM_ERROR_NONE);
1451
1452         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1453         ASSERT_TRUE(error == TDM_ERROR_NONE);
1454
1455         UtHandleVblankEvent();
1456
1457         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1458         ASSERT_TRUE(data == 1);
1459 }
1460
1461 TEST_F(TDMVblankWait, VblankWaitSuccessOffsenGreaterThanZeroRepeatedly)
1462 {
1463         tdm_error error;
1464         int data = 0;
1465
1466         SKIP_FLAG(has_output);
1467
1468         if (!con_output_vblank)
1469                 return;
1470
1471         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1472         ASSERT_TRUE(error == TDM_ERROR_NONE);
1473
1474         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1475         ASSERT_TRUE(error == TDM_ERROR_NONE);
1476
1477         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1478         ASSERT_TRUE(error == TDM_ERROR_NONE);
1479
1480         error = tdm_vblank_set_offset(con_output_vblank, 10);
1481         ASSERT_TRUE(error == TDM_ERROR_NONE);
1482
1483         for (int i = 0; i < 10; ++i) {
1484                 utVblankHandlerIsCalled = 0;
1485                 data = 0;
1486
1487                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1488                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1489
1490                 UtHandleVblankEvent();
1491
1492                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1493                 ASSERT_TRUE(data == 1);
1494         }
1495 }
1496
1497 TEST_F(TDMVblankWaitThread, VblankWaitSuccessFpsNonMultipleVrefresh)
1498 {
1499         tdm_error error;
1500         int data;
1501
1502         SKIP_FLAG(has_output);
1503
1504         if (!con_output_vblank)
1505                 return;
1506
1507         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1508         ASSERT_TRUE(error == TDM_ERROR_NONE);
1509
1510         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1511         ASSERT_TRUE(error == TDM_ERROR_NONE);
1512
1513         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1514         ASSERT_TRUE(error == TDM_ERROR_NONE);
1515
1516         UtHandleVblankEvent();
1517
1518         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1519         ASSERT_TRUE(data == 1);
1520 }
1521
1522 TEST_F(TDMVblankWaitThread, VblankWaitSuccessFpsNonMultipleVrefreshRepeatedly)
1523 {
1524         tdm_error error;
1525         int data;
1526
1527         SKIP_FLAG(has_output);
1528
1529         if (!con_output_vblank)
1530                 return;
1531
1532         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1533         ASSERT_TRUE(error == TDM_ERROR_NONE);
1534
1535         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1536         ASSERT_TRUE(error == TDM_ERROR_NONE);
1537
1538         for (int i = 0; i < 10; ++i) {
1539                 utVblankHandlerIsCalled = 0;
1540                 data = 0;
1541
1542                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1543                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1544
1545                 UtHandleVblankEvent();
1546
1547                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1548                 ASSERT_TRUE(data == 1);
1549         }
1550 }
1551
1552 TEST_F(TDMVblankWaitThread, VblankWaitSuccessDisconnectedOutput)
1553 {
1554         tdm_error error;
1555         int data;
1556
1557         SKIP_FLAG(has_output);
1558
1559         if (!discon_output_vblank)
1560                 return;
1561
1562         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1563         ASSERT_TRUE(error == TDM_ERROR_NONE);
1564
1565         error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1566         ASSERT_TRUE(error == TDM_ERROR_NONE);
1567
1568         UtHandleVblankEvent();
1569
1570         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1571         ASSERT_TRUE(data == 1);
1572 }
1573
1574 TEST_F(TDMVblankWaitThread, VblankWaitSuccessDisconnectedOutputRepeatedly)
1575 {
1576         tdm_error error;
1577         int data;
1578
1579         SKIP_FLAG(has_output);
1580
1581         if (!discon_output_vblank)
1582                 return;
1583
1584         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1585         ASSERT_TRUE(error == TDM_ERROR_NONE);
1586
1587         for (int i = 0; i < 10; ++i) {
1588                 utVblankHandlerIsCalled = 0;
1589                 data = 0;
1590
1591                 error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1592                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1593
1594                 UtHandleVblankEvent();
1595
1596                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1597                 ASSERT_TRUE(data == 1);
1598         }
1599 }
1600
1601 TEST_F(TDMVblankWaitThread, VblankWaitSuccessHW)
1602 {
1603         tdm_error error;
1604         int data = 0;
1605
1606         SKIP_FLAG(has_output);
1607
1608         if (!con_output_vblank)
1609                 return;
1610
1611         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1612         ASSERT_TRUE(error == TDM_ERROR_NONE);
1613
1614         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1615         ASSERT_TRUE(error == TDM_ERROR_NONE);
1616
1617         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1618         ASSERT_TRUE(error == TDM_ERROR_NONE);
1619
1620         error = tdm_vblank_set_offset(con_output_vblank, 0);
1621         ASSERT_TRUE(error == TDM_ERROR_NONE);
1622
1623         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1624         ASSERT_TRUE(error == TDM_ERROR_NONE);
1625
1626         UtHandleVblankEvent();
1627
1628         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1629         ASSERT_TRUE(data == 1);
1630 }
1631
1632 TEST_F(TDMVblankWaitThread, VblankWaitSuccessHWRepeatedly)
1633 {
1634         tdm_error error;
1635         int data;
1636
1637         SKIP_FLAG(has_output);
1638
1639         if (!con_output_vblank)
1640                 return;
1641
1642         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1643         ASSERT_TRUE(error == TDM_ERROR_NONE);
1644
1645         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1646         ASSERT_TRUE(error == TDM_ERROR_NONE);
1647
1648         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1649         ASSERT_TRUE(error == TDM_ERROR_NONE);
1650
1651         error = tdm_vblank_set_offset(con_output_vblank, 0);
1652         ASSERT_TRUE(error == TDM_ERROR_NONE);
1653
1654         for (int i = 0; i < 10; ++i) {
1655                 utVblankHandlerIsCalled = 0;
1656                 data = 0;
1657
1658                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1659                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1660
1661                 UtHandleVblankEvent();
1662
1663                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1664                 ASSERT_TRUE(data == 1);
1665         }
1666 }
1667
1668 TEST_F(TDMVblankWaitThread, VblankWaitSuccessOffsenGreaterThanZero)
1669 {
1670         tdm_error error;
1671         int data = 0;
1672
1673         SKIP_FLAG(has_output);
1674
1675         if (!con_output_vblank)
1676                 return;
1677
1678         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1679         ASSERT_TRUE(error == TDM_ERROR_NONE);
1680
1681         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1682         ASSERT_TRUE(error == TDM_ERROR_NONE);
1683
1684         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1685         ASSERT_TRUE(error == TDM_ERROR_NONE);
1686
1687         error = tdm_vblank_set_offset(con_output_vblank, 10);
1688         ASSERT_TRUE(error == TDM_ERROR_NONE);
1689
1690         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1691         ASSERT_TRUE(error == TDM_ERROR_NONE);
1692
1693         UtHandleVblankEvent();
1694
1695         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1696         ASSERT_TRUE(data == 1);
1697 }
1698
1699 TEST_F(TDMVblankWaitThread, VblankWaitSuccessOffsenGreaterThanZeroRepeatedly)
1700 {
1701         tdm_error error;
1702         int data;
1703
1704         SKIP_FLAG(has_output);
1705
1706         if (!con_output_vblank)
1707                 return;
1708
1709         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1710         ASSERT_TRUE(error == TDM_ERROR_NONE);
1711
1712         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1713         ASSERT_TRUE(error == TDM_ERROR_NONE);
1714
1715         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1716         ASSERT_TRUE(error == TDM_ERROR_NONE);
1717
1718         error = tdm_vblank_set_offset(con_output_vblank, 10);
1719         ASSERT_TRUE(error == TDM_ERROR_NONE);
1720
1721         for (int i = 0; i < 10; ++i) {
1722                 utVblankHandlerIsCalled = 0;
1723                 data = 0;
1724
1725                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1726                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1727
1728                 UtHandleVblankEvent();
1729
1730                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1731                 ASSERT_TRUE(data == 1);
1732         }
1733 }
1734
1735 /* tdm_vblank_wait_seq() */
1736
1737 TEST_F(TDMVblank, VblankWaitSeqFailNullAll)
1738 {
1739         tdm_error error;
1740
1741         SKIP_FLAG(has_output);
1742
1743         error = tdm_vblank_wait_seq(NULL, 0, 0, 0, NULL, NULL);
1744         ASSERT_TRUE(error != TDM_ERROR_NONE);
1745 }
1746
1747 TEST_F(TDMVblankWait, VblankWaitSeqFailNullVblank)
1748 {
1749         tdm_error error;
1750
1751         SKIP_FLAG(has_output);
1752
1753         error = tdm_vblank_wait_seq(NULL, 0, 0, 1, UtVblankHandler, NULL);
1754         ASSERT_TRUE(error != TDM_ERROR_NONE);
1755 }
1756
1757 TEST_F(TDMVblankWait, VblankWaitSeqFailWrongVblankPtr)
1758 {
1759         tdm_error error = TDM_ERROR_BAD_MODULE;
1760         SKIP_FLAG(has_output);
1761
1762         ASSERT_EXIT({error = tdm_vblank_wait_seq((tdm_vblank *)0xFFFFFFFF, 0, 0, 1, UtVblankHandler, NULL);;
1763                                 if (error == TDM_ERROR_NONE)
1764                                         exit(1);
1765                                 else
1766                                         exit(0);},
1767                                 ::testing::ExitedWithCode(0), "");
1768 }
1769
1770 TEST_F(TDMVblankWait, VblankWaitSeqFailNullFunc)
1771 {
1772         tdm_error error;
1773
1774         SKIP_FLAG(has_output);
1775
1776         error = tdm_vblank_wait_seq(NULL, 0, 0, 1, UtVblankHandler, NULL);
1777         ASSERT_TRUE(error != TDM_ERROR_NONE);
1778 }
1779
1780 void *UtWaitVblankSeqThreadHndl(void *ptr)
1781 {
1782         tdm_error error;
1783         TDMVblankWait *vblankWait = (TDMVblankWait *)ptr;
1784
1785         error = tdm_vblank_wait_seq(vblankWait->default_vblank, 0, 0, 1, TDMVblankWait::UtVblankHandler, NULL);
1786         if (error != TDM_ERROR_NONE)
1787                 vblankWait->utWaitVblankSeqThreadHndlResult = 0;
1788         else
1789                 vblankWait->utWaitVblankSeqThreadHndlResult = 0;
1790 }
1791
1792 TEST_F(TDMVblankWait, VblankWaitSeqFailInOtherThread)
1793 {
1794         pthread_t thread;
1795
1796         SKIP_FLAG(has_output);
1797
1798         ASSERT_FALSE(pthread_create(&thread, NULL, UtWaitVblankSeqThreadHndl, this));
1799
1800         ASSERT_FALSE(pthread_join(thread, NULL));
1801
1802         ASSERT_FALSE(utWaitVblankSeqThreadHndlResult);
1803 }
1804
1805 TEST_F(TDMVblankWait, VblankWaitSeqFailDisconnectedOutput)
1806 {
1807         tdm_error error;
1808
1809         SKIP_FLAG(has_output);
1810
1811         if (!discon_output_vblank)
1812                 return;
1813
1814         error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1815         ASSERT_TRUE(error != TDM_ERROR_NONE);
1816 }
1817
1818 TEST_F(TDMVblankWait, VblankWaitSeqFailDpmsOff)
1819 {
1820         tdm_error error;
1821
1822         SKIP_FLAG(has_output);
1823
1824         if (!con_output_vblank)
1825                 return;
1826
1827         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1828         ASSERT_TRUE(error == TDM_ERROR_NONE);
1829
1830         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1831         ASSERT_TRUE(error != TDM_ERROR_NONE);
1832 }
1833
1834 TEST_F(TDMVblankWait, VblankWaitSeqSuccessFpsNonMultipleVrefresh)
1835 {
1836         tdm_error error;
1837         int data = 0;
1838
1839         SKIP_FLAG(has_output);
1840
1841         if (!con_output_vblank)
1842                 return;
1843
1844         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1845         ASSERT_TRUE(error == TDM_ERROR_NONE);
1846
1847         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1848         ASSERT_TRUE(error == TDM_ERROR_NONE);
1849
1850         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1851         ASSERT_TRUE(error == TDM_ERROR_NONE);
1852
1853         UtHandleVblankEvent();
1854
1855         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1856         ASSERT_TRUE(data == 1);
1857 }
1858
1859 TEST_F(TDMVblankWait, VblankWaitSeqSuccessFpsNonMultipleVrefreshRepeatedly)
1860 {
1861         tdm_error error;
1862         int data;
1863
1864         SKIP_FLAG(has_output);
1865
1866         if (!con_output_vblank)
1867                 return;
1868
1869         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1870         ASSERT_TRUE(error == TDM_ERROR_NONE);
1871
1872         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1873         ASSERT_TRUE(error == TDM_ERROR_NONE);
1874
1875         for (int i = 1; i < 10; ++i) {
1876                 utVblankHandlerIsCalled = 0;
1877                 data = 0;
1878
1879                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
1880                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1881
1882                 UtHandleVblankEvent();
1883
1884                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1885                 ASSERT_TRUE(data == 1);
1886         }
1887 }
1888
1889 TEST_F(TDMVblankWait, VblankWaitSeqSuccessDisconnectedOutput)
1890 {
1891         tdm_error error;
1892         int data;
1893
1894         SKIP_FLAG(has_output);
1895
1896         if (!discon_output_vblank)
1897                 return;
1898
1899         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1900         ASSERT_TRUE(error == TDM_ERROR_NONE);
1901
1902         error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1903         ASSERT_TRUE(error == TDM_ERROR_NONE);
1904
1905         UtHandleVblankEvent();
1906
1907         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1908         ASSERT_TRUE(data == 1);
1909 }
1910
1911 TEST_F(TDMVblankWait, VblankWaitSeqSuccessDisconnectedOutputRepeatedly)
1912 {
1913         tdm_error error;
1914         int data;
1915
1916         SKIP_FLAG(has_output);
1917
1918         if (!discon_output_vblank)
1919                 return;
1920
1921         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1922         ASSERT_TRUE(error == TDM_ERROR_NONE);
1923
1924         for (int i = 1; i < 10; ++i) {
1925                 utVblankHandlerIsCalled = 0;
1926                 data = 0;
1927
1928                 error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, i, UtVblankHandler, &data);
1929                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1930
1931                 UtHandleVblankEvent();
1932
1933                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1934                 ASSERT_TRUE(data == 1);
1935         }
1936 }
1937
1938 TEST_F(TDMVblankWait, VblankWaitSeqSuccessHW)
1939 {
1940         tdm_error error;
1941         int data;
1942
1943         SKIP_FLAG(has_output);
1944
1945         if (!con_output_vblank)
1946                 return;
1947
1948         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1949         ASSERT_TRUE(error == TDM_ERROR_NONE);
1950
1951         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1952         ASSERT_TRUE(error == TDM_ERROR_NONE);
1953
1954         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1955         ASSERT_TRUE(error == TDM_ERROR_NONE);
1956
1957         error = tdm_vblank_set_offset(con_output_vblank, 0);
1958         ASSERT_TRUE(error == TDM_ERROR_NONE);
1959
1960         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1961         ASSERT_TRUE(error == TDM_ERROR_NONE);
1962
1963         UtHandleVblankEvent();
1964
1965         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1966         ASSERT_TRUE(data == 1);
1967 }
1968
1969 TEST_F(TDMVblankWait, VblankWaitSeqSuccessHWRepeatedly)
1970 {
1971         tdm_error error;
1972         int data;
1973
1974         SKIP_FLAG(has_output);
1975
1976         if (!con_output_vblank)
1977                 return;
1978
1979         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1980         ASSERT_TRUE(error == TDM_ERROR_NONE);
1981
1982         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1983         ASSERT_TRUE(error == TDM_ERROR_NONE);
1984
1985         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1986         ASSERT_TRUE(error == TDM_ERROR_NONE);
1987
1988         error = tdm_vblank_set_offset(con_output_vblank, 0);
1989         ASSERT_TRUE(error == TDM_ERROR_NONE);
1990
1991         for (int i = 1; i < 10; ++i) {
1992                 utVblankHandlerIsCalled = 0;
1993                 data = 0;
1994
1995                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
1996                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1997
1998                 UtHandleVblankEvent();
1999
2000                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2001                 ASSERT_TRUE(data == 1);
2002         }
2003 }
2004
2005 TEST_F(TDMVblankWait, VblankWaitSeqSuccessOffsenGreaterThanZero)
2006 {
2007         tdm_error error;
2008         int data = 0;
2009
2010         SKIP_FLAG(has_output);
2011
2012         if (!con_output_vblank)
2013                 return;
2014
2015         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2016         ASSERT_TRUE(error == TDM_ERROR_NONE);
2017
2018         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
2019         ASSERT_TRUE(error == TDM_ERROR_NONE);
2020
2021         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2022         ASSERT_TRUE(error == TDM_ERROR_NONE);
2023
2024         error = tdm_vblank_set_offset(con_output_vblank, 10);
2025         ASSERT_TRUE(error == TDM_ERROR_NONE);
2026
2027         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
2028         ASSERT_TRUE(error == TDM_ERROR_NONE);
2029
2030         UtHandleVblankEvent();
2031
2032         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2033         ASSERT_TRUE(data == 1);
2034 }
2035
2036 TEST_F(TDMVblankWait, VblankWaitSeqSuccessOffsenGreaterThanZeroRepeatedly)
2037 {
2038         tdm_error error;
2039         int data;
2040
2041         SKIP_FLAG(has_output);
2042
2043         if (!con_output_vblank)
2044                 return;
2045
2046         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2047         ASSERT_TRUE(error == TDM_ERROR_NONE);
2048
2049         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
2050         ASSERT_TRUE(error == TDM_ERROR_NONE);
2051
2052         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2053         ASSERT_TRUE(error == TDM_ERROR_NONE);
2054
2055         error = tdm_vblank_set_offset(con_output_vblank, 10);
2056         ASSERT_TRUE(error == TDM_ERROR_NONE);
2057
2058         for (int i = 1; i < 10; ++i) {
2059                 utVblankHandlerIsCalled = 0;
2060
2061                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2062                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2063
2064                 UtHandleVblankEvent();
2065
2066                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2067                 ASSERT_TRUE(data == 1);
2068         }
2069 }
2070
2071 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithSameSeq)
2072 {
2073         tdm_error error;
2074         int data = 0;
2075
2076         SKIP_FLAG(has_output);
2077
2078         if (!con_output_vblank)
2079                 return;
2080
2081         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2082         ASSERT_TRUE(error == TDM_ERROR_NONE);
2083
2084         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2085         ASSERT_TRUE(error == TDM_ERROR_NONE);
2086
2087         error = tdm_vblank_set_offset(con_output_vblank, 0);
2088         ASSERT_TRUE(error == TDM_ERROR_NONE);
2089
2090         for (int i = 1; i < 10; ++i) {
2091                 utVblankHandlerIsCalled = 0;
2092                 data = 0;
2093
2094                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 2, UtVblankHandler, &data);
2095                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2096
2097                 UtHandleVblankEvent();
2098
2099                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2100                 ASSERT_TRUE(data == 1);
2101         }
2102 }
2103
2104 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithBigFps)
2105 {
2106         tdm_error error;
2107         int data = 0;
2108
2109         SKIP_FLAG(has_output);
2110
2111         if (!con_output_vblank)
2112                 return;
2113
2114         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2115         ASSERT_TRUE(error == TDM_ERROR_NONE);
2116
2117         error = tdm_vblank_set_fps(con_output_vblank, 5000);
2118         ASSERT_TRUE(error == TDM_ERROR_NONE);
2119
2120         for (int i = 1; i < 10; ++i) {
2121                 utVblankHandlerIsCalled = 0;
2122                 data = 0;
2123
2124                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2125                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2126
2127                 if (i < 4)
2128                         continue;
2129
2130                 UtHandleVblankEvent();
2131
2132                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2133                 ASSERT_TRUE(data == 1);
2134         }
2135 }
2136
2137 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithDelay)
2138 {
2139         tdm_error error;
2140         int data = 0;
2141
2142         SKIP_FLAG(has_output);
2143
2144         if (!con_output_vblank)
2145                 return;
2146
2147         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2148         ASSERT_TRUE(error == TDM_ERROR_NONE);
2149
2150         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2151         ASSERT_TRUE(error == TDM_ERROR_NONE);
2152
2153         for (int i = 1; i < 10; ++i) {
2154                 utVblankHandlerIsCalled = 0;
2155                 data = 0;
2156
2157                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2158                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2159
2160                 usleep(100000);
2161
2162                 UtHandleVblankEvent();
2163
2164                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2165                 ASSERT_TRUE(data == 1);
2166         }
2167 }