utests/src/ut_tdm_vblank.cpp

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