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