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