utests/src/ut_tdm_vblank.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "gtest/gtest.h"
  32 #include "tdm.h"
  33 #include "tbm_bufmgr.h"
  34 #include "ut_common.h"
  35 #include <sys/epoll.h>
  36 #include <sys/timerfd.h>
  37 #include <pthread.h>
  38
  39 class TDMVblankWithoutCreating: public ::testing::Test {
  40 protected:
  41         tbm_bufmgr bufmgr = NULL;
  42         tdm_display *dpy = NULL;
  43         int output_count = 0;
  44         bool has_output = 0;
  45         tdm_output *connected_output = NULL;
  46         const tdm_output_mode *preferred_mode = NULL;
  47         tdm_output *disconnected_output = NULL;
  48         tdm_output *default_output = NULL;
  49
  50         void SetUp(void) {
  51                 tdm_output *output;
  52                 tdm_output_conn_status status;
  53                 tdm_error error = TDM_ERROR_NONE;
  54
  55                 setenv("TDM_DLOG", "1", 1);
  56                 setenv("XDG_RUNTIME_DIR", ".", 1);
  57                 setenv("TBM_DLOG", "1", 1);
  58                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  59
  60                 /* FIXME: fix the error. If we initialize TBM before TDM we get fail
  61                  * in the tdm_output_set_dpms */
  62 #if 0
  63                 tbm_bufmgr = tbm_bufmgr_init(-1);
  64                 ASSERT_FALSE(tbm_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);},
 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, VblankGetOffsetFailWrongOffsetPtr)
 876 {
 877         tdm_error error = TDM_ERROR_BAD_MODULE;
 878         SKIP_FLAG(has_output);
 879
 880         ASSERT_EXIT({error = tdm_vblank_get_offset(default_vblank, (int *)0xFFFFFFFF);
 881                                 if (error == TDM_ERROR_NONE)
 882                                         exit(1);
 883                                 else
 884                                         exit(0);},
 885                                 ::testing::ExitedWithCode(0), "");
 886 }
 887
 888 TEST_F(TDMVblank, VblankGetOffsetSuccesWithoutSet)
 889 {
 890         tdm_error error;
 891         int offset;
 892
 893         SKIP_FLAG(has_output);
 894
 895         error = tdm_vblank_get_offset(default_vblank, &offset);
 896         ASSERT_TRUE(error == TDM_ERROR_NONE);
 897 }
 898
 899 TEST_F(TDMVblank, VblankGetOffsetSucces)
 900 {
 901         tdm_error error;
 902         int set_offset = 567;
 903         int ret_offset;
 904
 905         SKIP_FLAG(has_output);
 906
 907         error = tdm_vblank_set_offset(default_vblank, set_offset);
 908         ASSERT_TRUE(error != TDM_ERROR_NONE);
 909
 910         error = tdm_vblank_get_offset(default_vblank, &ret_offset);
 911         ASSERT_TRUE(error != TDM_ERROR_NONE);
 912
 913         ASSERT_TRUE(set_offset == ret_offset);
 914 }
 915
 916 /* tdm_vblank_set_enable_fake() */
 917
 918 TEST_F(TDMVblank, VblankSetEnableFakeFailNullVblank)
 919 {
 920         tdm_error error;
 921         SKIP_FLAG(has_output);
 922
 923         error = tdm_vblank_set_enable_fake(NULL, 1);
 924         ASSERT_TRUE(error != TDM_ERROR_NONE);
 925 }
 926
 927 TEST_F(TDMVblank, VblankSetEnableFakeFailFailWrongVblankPtr)
 928 {
 929         tdm_error error = TDM_ERROR_BAD_MODULE;
 930
 931         SKIP_FLAG(has_output);
 932
 933         ASSERT_EXIT({error = tdm_vblank_set_enable_fake((tdm_vblank *)0xFFFFFFFF, 1);
 934                                 if (error == TDM_ERROR_NONE)
 935                                         exit(1);
 936                                 else
 937                                         exit(0);},
 938                                 ::testing::ExitedWithCode(0), "");
 939 }
 940
 941 TEST_F(TDMVblank, VblankSetEnableFakeSuccessSet)
 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
 950 TEST_F(TDMVblank, VblankSetEnableFakeSuccessSetTwice)
 951 {
 952         tdm_error error;
 953         SKIP_FLAG(has_output);
 954
 955         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 956         ASSERT_TRUE(error == TDM_ERROR_NONE);
 957
 958         error = tdm_vblank_set_enable_fake(default_vblank, 1);
 959         ASSERT_TRUE(error == TDM_ERROR_NONE);
 960 }
 961
 962 /* tdm_vblank_get_enable_fake() */
 963
 964 TEST_F(TDMVblank, VblankGetEnableFakeFailNullAll)
 965 {
 966         tdm_error error;
 967         SKIP_FLAG(has_output);
 968
 969         error = tdm_vblank_get_enable_fake(NULL, NULL);
 970         ASSERT_TRUE(error != TDM_ERROR_NONE);
 971 }
 972
 973 TEST_F(TDMVblank, VblankGetEnableFakeFailNullVblank)
 974 {
 975         tdm_error error;
 976         unsigned int enable_fake;
 977         SKIP_FLAG(has_output);
 978
 979         error = tdm_vblank_get_enable_fake(NULL, &enable_fake);
 980         ASSERT_TRUE(error != TDM_ERROR_NONE);
 981 }
 982
 983 TEST_F(TDMVblank, VblankGetEnableFakeFailNullEnableFake)
 984 {
 985         tdm_error error;
 986         SKIP_FLAG(has_output);
 987
 988         error = tdm_vblank_get_enable_fake(default_vblank, NULL);
 989         ASSERT_TRUE(error != TDM_ERROR_NONE);
 990 }
 991
 992 TEST_F(TDMVblank, VblankGetEnableFakeFailWrongVblankPtr)
 993 {
 994         tdm_error error = TDM_ERROR_BAD_MODULE;
 995         unsigned int enable_fake;
 996         SKIP_FLAG(has_output);
 997
 998         ASSERT_EXIT({error = tdm_vblank_get_enable_fake((tdm_vblank *)0xFFFFFFFF, &enable_fake);
 999                                 if (error == TDM_ERROR_NONE)
1000                                         exit(1);
1001                                 else
1002                                         exit(0);},
1003                                 ::testing::ExitedWithCode(0), "");
1004 }
1005
1006 TEST_F(TDMVblank, DISABLED_VblankGetEnableFakeFailWrongOffsetPtr)
1007 {
1008         tdm_error error = TDM_ERROR_BAD_MODULE;
1009         SKIP_FLAG(has_output);
1010
1011         ASSERT_EXIT({error = tdm_vblank_get_enable_fake(default_vblank, (unsigned int *)0xFFFFFFFF);
1012                                 if (error == TDM_ERROR_NONE)
1013                                         exit(1);
1014                                 else
1015                                         exit(0);},
1016                                 ::testing::ExitedWithCode(0), "");
1017 }
1018
1019 TEST_F(TDMVblank, VblankGetEnableFakeSuccessWithoutSet)
1020 {
1021         tdm_error error;
1022         unsigned int enable_fake;
1023
1024         SKIP_FLAG(has_output);
1025
1026         error = tdm_vblank_get_enable_fake(default_vblank, &enable_fake);
1027         ASSERT_TRUE(error == TDM_ERROR_NONE);
1028 }
1029
1030 TEST_F(TDMVblank, VblankGetEnableFakeSuccess)
1031 {
1032         tdm_error error;
1033         unsigned int set_enable_fake = 1;
1034         unsigned int ret_enable_fake;
1035
1036         SKIP_FLAG(has_output);
1037
1038         error = tdm_vblank_set_enable_fake(default_vblank, set_enable_fake);
1039         ASSERT_TRUE(error == TDM_ERROR_NONE);
1040
1041         error = tdm_vblank_get_enable_fake(default_vblank, &ret_enable_fake);
1042         ASSERT_TRUE(error == TDM_ERROR_NONE);
1043
1044         ASSERT_TRUE(set_enable_fake == ret_enable_fake);
1045 }
1046
1047 /* tdm_vblank_set_client_vblank_fps() */
1048
1049 /* TODO: need to create the tdm client */
1050 TEST_F(TDMVblank, VblankSetClientVblankFpsFailNullAll)
1051 {
1052         tdm_error error;
1053
1054         SKIP_FLAG(has_output);
1055
1056         error = tdm_vblank_set_client_vblank_fps(0, 0, 0);
1057         ASSERT_TRUE(error != TDM_ERROR_NONE);
1058 }
1059
1060 /* TODO: need to create the tdm client */
1061 TEST_F(TDMVblank, VblankSetClientVblankFpsFailNullPid)
1062 {
1063         tdm_error error;
1064
1065         SKIP_FLAG(has_output);
1066
1067         error = tdm_vblank_set_client_vblank_fps(0, 0, 0);
1068         ASSERT_TRUE(error != TDM_ERROR_NONE);
1069 }
1070
1071 /* tdm_vblank_wait() */
1072
1073 TEST_F(TDMVblank, VblankWaitFailNullAll)
1074 {
1075         tdm_error error;
1076
1077         SKIP_FLAG(has_output);
1078
1079         error = tdm_vblank_wait(NULL, 0, 0, 0, NULL, NULL);
1080         ASSERT_TRUE(error != TDM_ERROR_NONE);
1081 }
1082
1083 TEST_F(TDMVblankWait, VblankWaitFailNullVblank)
1084 {
1085         tdm_error error;
1086
1087         SKIP_FLAG(has_output);
1088
1089         error = tdm_vblank_wait(NULL, 0, 0, 1, UtVblankHandler, NULL);
1090         ASSERT_TRUE(error != TDM_ERROR_NONE);
1091 }
1092
1093 TEST_F(TDMVblankWait, VblankWaitFailNullFunc)
1094 {
1095         tdm_error error;
1096
1097         SKIP_FLAG(has_output);
1098
1099         error = tdm_vblank_wait(default_vblank, 0, 0, 1, NULL, NULL);
1100         ASSERT_TRUE(error != TDM_ERROR_NONE);
1101 }
1102
1103 TEST_F(TDMVblankWait, VblankWaitFailWrongVblankPtr)
1104 {
1105         tdm_error error = TDM_ERROR_BAD_MODULE;
1106         SKIP_FLAG(has_output);
1107
1108         ASSERT_EXIT({error = tdm_vblank_wait((tdm_vblank *)0xFFFFFFFF, 0, 0, 1, UtVblankHandler, NULL);;
1109                                 if (error == TDM_ERROR_NONE)
1110                                         exit(1);
1111                                 else
1112                                         exit(0);},
1113                                 ::testing::ExitedWithCode(0), "");
1114 }
1115
1116 void *UtWaitVblankThreadHndl(void *ptr)
1117 {
1118         tdm_error error;
1119         TDMVblankWait *vblankWait = (TDMVblankWait *)ptr;
1120
1121         error = tdm_vblank_wait(vblankWait->default_vblank, 0, 0, 1, TDMVblankWait::UtVblankHandler, NULL);
1122         if (error != TDM_ERROR_NONE)
1123                 vblankWait->utWaitVblankThreadHndlResult = 0;
1124         else
1125                 vblankWait->utWaitVblankThreadHndlResult = 1;
1126
1127         return NULL;
1128 }
1129
1130 TEST_F(TDMVblankWait, VblankWaitFailInOtherThread)
1131 {
1132         pthread_t thread = 0;
1133
1134         SKIP_FLAG(has_output);
1135
1136         ASSERT_FALSE(pthread_create(&thread, NULL, UtWaitVblankThreadHndl, this));
1137
1138         ASSERT_FALSE(pthread_join(thread, NULL));
1139
1140         ASSERT_FALSE(utWaitVblankThreadHndlResult);
1141 }
1142
1143 TEST_F(TDMVblankWait, VblankWaitFailDisconnectedOutput)
1144 {
1145         tdm_error error;
1146
1147         SKIP_FLAG(has_output);
1148
1149         if (!discon_output_vblank)
1150                 return;
1151
1152         error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1153         ASSERT_TRUE(error != TDM_ERROR_NONE);
1154 }
1155
1156 TEST_F(TDMVblankWait, VblankWaitFailDpmsOff)
1157 {
1158         tdm_error error;
1159
1160         SKIP_FLAG(has_output);
1161
1162         if (!con_output_vblank)
1163                 return;
1164
1165         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1166         ASSERT_TRUE(error == TDM_ERROR_NONE);
1167
1168         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1169         ASSERT_TRUE(error != TDM_ERROR_NONE);
1170 }
1171
1172 TEST_F(TDMVblankWait, VblankWaitSuccessFpsNonMultipleVrefresh)
1173 {
1174         tdm_error error;
1175         int data = 0;
1176
1177         SKIP_FLAG(has_output);
1178
1179         if (!con_output_vblank)
1180                 return;
1181
1182         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1183         ASSERT_TRUE(error == TDM_ERROR_NONE);
1184
1185         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1186         ASSERT_TRUE(error == TDM_ERROR_NONE);
1187
1188         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1189         ASSERT_TRUE(error == TDM_ERROR_NONE);
1190
1191         UtHandleVblankEvent();
1192
1193         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1194         ASSERT_TRUE(data == 1);
1195 }
1196
1197 TEST_F(TDMVblankWait, VblankWaitSuccessFpsNonMultipleVrefreshRepeatedly)
1198 {
1199         tdm_error error;
1200         int data = 0;
1201
1202         SKIP_FLAG(has_output);
1203
1204         if (!con_output_vblank)
1205                 return;
1206
1207         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1208         ASSERT_TRUE(error == TDM_ERROR_NONE);
1209
1210         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1211         ASSERT_TRUE(error == TDM_ERROR_NONE);
1212
1213         for (int i = 0; i < 10; ++i) {
1214                 utVblankHandlerIsCalled = 0;
1215                 data = 0;
1216
1217                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1218                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1219
1220                 UtHandleVblankEvent();
1221
1222                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1223                 ASSERT_TRUE(data == 1);
1224         }
1225 }
1226
1227 TEST_F(TDMVblankWait, VblankWaitSuccessDisconnectedOutput)
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         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 TEST_F(TDMVblankWait, VblankWaitSuccessDisconnectedOutputRepeatedly)
1250 {
1251         tdm_error error;
1252         int data = 0;
1253
1254         SKIP_FLAG(has_output);
1255
1256         if (!discon_output_vblank)
1257                 return;
1258
1259         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1260         ASSERT_TRUE(error == TDM_ERROR_NONE);
1261
1262         for (int i = 0; i < 10; ++i) {
1263                 utVblankHandlerIsCalled = 0;
1264                 data = 0;
1265
1266                 error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1267                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1268
1269                 UtHandleVblankEvent();
1270
1271                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1272                 ASSERT_TRUE(data == 1);
1273         }
1274 }
1275
1276 TEST_F(TDMVblankWait, VblankWaitSuccessHW)
1277 {
1278         tdm_error error;
1279         int data = 0;
1280
1281         SKIP_FLAG(has_output);
1282
1283         if (!con_output_vblank)
1284                 return;
1285
1286         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1287         ASSERT_TRUE(error == TDM_ERROR_NONE);
1288
1289         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1290         ASSERT_TRUE(error == TDM_ERROR_NONE);
1291
1292         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1293         ASSERT_TRUE(error == TDM_ERROR_NONE);
1294
1295         error = tdm_vblank_set_offset(con_output_vblank, 0);
1296         ASSERT_TRUE(error == TDM_ERROR_NONE);
1297
1298         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1299         ASSERT_TRUE(error == TDM_ERROR_NONE);
1300
1301         UtHandleVblankEvent();
1302
1303         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1304         ASSERT_TRUE(data == 1);
1305 }
1306
1307 TEST_F(TDMVblankWait, VblankWaitSuccessDestroy)
1308 {
1309         tdm_error error;
1310         int data = 0;
1311
1312         SKIP_FLAG(has_output);
1313
1314         if (!con_output_vblank)
1315                 return;
1316
1317         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1318         ASSERT_TRUE(error == TDM_ERROR_NONE);
1319
1320         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1321         ASSERT_TRUE(error == TDM_ERROR_NONE);
1322
1323         error = tdm_vblank_set_offset(con_output_vblank, 0);
1324         ASSERT_TRUE(error == TDM_ERROR_NONE);
1325
1326         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1327         ASSERT_TRUE(error == TDM_ERROR_NONE);
1328
1329         tdm_vblank_destroy(con_output_vblank);
1330
1331         ASSERT_TRUE(utVblankHandlerIsCalled == 0);
1332         ASSERT_TRUE(data == 0);
1333 }
1334
1335 TEST_F(TDMVblankWait, VblankWaitSuccessChangeDpms)
1336 {
1337         tdm_error error;
1338         int data = 0;
1339
1340         SKIP_FLAG(has_output);
1341
1342         if (!con_output_vblank)
1343                 return;
1344
1345         error = tdm_vblank_set_enable_fake(con_output_vblank, 0);
1346         ASSERT_TRUE(error == TDM_ERROR_NONE);
1347
1348         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1349         ASSERT_TRUE(error == TDM_ERROR_NONE);
1350
1351         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1352         ASSERT_TRUE(error == TDM_ERROR_NONE);
1353
1354         error = tdm_vblank_set_offset(con_output_vblank, 0);
1355         ASSERT_TRUE(error == TDM_ERROR_NONE);
1356
1357         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1358         ASSERT_TRUE(error == TDM_ERROR_NONE);
1359
1360         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1361         ASSERT_TRUE(error == TDM_ERROR_NONE);
1362
1363         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1364         ASSERT_TRUE(data == 1);
1365 }
1366
1367 TEST_F(TDMVblankWait, VblankWaitSuccessChangeDpmsWithEnableFake)
1368 {
1369         tdm_error error;
1370         int data = 0;
1371
1372         SKIP_FLAG(has_output);
1373
1374         if (!con_output_vblank)
1375                 return;
1376
1377         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1378         ASSERT_TRUE(error == TDM_ERROR_NONE);
1379
1380         error = tdm_vblank_set_enable_fake(con_output_vblank, 1);
1381         ASSERT_TRUE(error == TDM_ERROR_NONE);
1382
1383         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1384         ASSERT_TRUE(error == TDM_ERROR_NONE);
1385
1386         error = tdm_vblank_set_offset(con_output_vblank, 0);
1387         ASSERT_TRUE(error == TDM_ERROR_NONE);
1388
1389         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1390         ASSERT_TRUE(error == TDM_ERROR_NONE);
1391
1392         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1393         ASSERT_TRUE(error == TDM_ERROR_NONE);
1394
1395         UtHandleVblankEvent();
1396
1397         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1398         ASSERT_TRUE(data == 1);
1399 }
1400
1401 TEST_F(TDMVblankWait, VblankWaitSuccessHWRepeatedly)
1402 {
1403         tdm_error error;
1404         int data;
1405
1406         SKIP_FLAG(has_output);
1407
1408         if (!con_output_vblank)
1409                 return;
1410
1411         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1412         ASSERT_TRUE(error == TDM_ERROR_NONE);
1413
1414         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1415         ASSERT_TRUE(error == TDM_ERROR_NONE);
1416
1417         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1418         ASSERT_TRUE(error == TDM_ERROR_NONE);
1419
1420         error = tdm_vblank_set_offset(con_output_vblank, 0);
1421         ASSERT_TRUE(error == TDM_ERROR_NONE);
1422
1423         for (int i = 0; i < 10; ++i) {
1424                 utVblankHandlerIsCalled = 0;
1425                 data = 0;
1426
1427                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1428                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1429
1430                 UtHandleVblankEvent();
1431
1432                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1433                 ASSERT_TRUE(data == 1);
1434         }
1435 }
1436
1437 TEST_F(TDMVblankWait, VblankWaitSuccessOffsenGreaterThanZero)
1438 {
1439         tdm_error error;
1440         int data = 0;
1441
1442         SKIP_FLAG(has_output);
1443
1444         if (!con_output_vblank)
1445                 return;
1446
1447         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1448         ASSERT_TRUE(error == TDM_ERROR_NONE);
1449
1450         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1451         ASSERT_TRUE(error == TDM_ERROR_NONE);
1452
1453         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1454         ASSERT_TRUE(error == TDM_ERROR_NONE);
1455
1456         error = tdm_vblank_set_offset(con_output_vblank, 10);
1457         ASSERT_TRUE(error == TDM_ERROR_NONE);
1458
1459         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1460         ASSERT_TRUE(error == TDM_ERROR_NONE);
1461
1462         UtHandleVblankEvent();
1463
1464         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1465         ASSERT_TRUE(data == 1);
1466 }
1467
1468 TEST_F(TDMVblankWait, VblankWaitSuccessOffsenGreaterThanZeroRepeatedly)
1469 {
1470         tdm_error error;
1471         int data = 0;
1472
1473         SKIP_FLAG(has_output);
1474
1475         if (!con_output_vblank)
1476                 return;
1477
1478         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1479         ASSERT_TRUE(error == TDM_ERROR_NONE);
1480
1481         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1482         ASSERT_TRUE(error == TDM_ERROR_NONE);
1483
1484         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1485         ASSERT_TRUE(error == TDM_ERROR_NONE);
1486
1487         error = tdm_vblank_set_offset(con_output_vblank, 10);
1488         ASSERT_TRUE(error == TDM_ERROR_NONE);
1489
1490         for (int i = 0; i < 10; ++i) {
1491                 utVblankHandlerIsCalled = 0;
1492                 data = 0;
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
1504 TEST_F(TDMVblankWaitThread, VblankWaitSuccessFpsNonMultipleVrefresh)
1505 {
1506         tdm_error error;
1507         int data;
1508
1509         SKIP_FLAG(has_output);
1510
1511         if (!con_output_vblank)
1512                 return;
1513
1514         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1515         ASSERT_TRUE(error == TDM_ERROR_NONE);
1516
1517         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1518         ASSERT_TRUE(error == TDM_ERROR_NONE);
1519
1520         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1521         ASSERT_TRUE(error == TDM_ERROR_NONE);
1522
1523         UtHandleVblankEvent();
1524
1525         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1526         ASSERT_TRUE(data == 1);
1527 }
1528
1529 TEST_F(TDMVblankWaitThread, VblankWaitSuccessFpsNonMultipleVrefreshRepeatedly)
1530 {
1531         tdm_error error;
1532         int data;
1533
1534         SKIP_FLAG(has_output);
1535
1536         if (!con_output_vblank)
1537                 return;
1538
1539         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1540         ASSERT_TRUE(error == TDM_ERROR_NONE);
1541
1542         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1543         ASSERT_TRUE(error == TDM_ERROR_NONE);
1544
1545         for (int i = 0; i < 10; ++i) {
1546                 utVblankHandlerIsCalled = 0;
1547                 data = 0;
1548
1549                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1550                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1551
1552                 UtHandleVblankEvent();
1553
1554                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1555                 ASSERT_TRUE(data == 1);
1556         }
1557 }
1558
1559 TEST_F(TDMVblankWaitThread, VblankWaitSuccessDisconnectedOutput)
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         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 TEST_F(TDMVblankWaitThread, VblankWaitSuccessDisconnectedOutputRepeatedly)
1582 {
1583         tdm_error error;
1584         int data;
1585
1586         SKIP_FLAG(has_output);
1587
1588         if (!discon_output_vblank)
1589                 return;
1590
1591         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1592         ASSERT_TRUE(error == TDM_ERROR_NONE);
1593
1594         for (int i = 0; i < 10; ++i) {
1595                 utVblankHandlerIsCalled = 0;
1596                 data = 0;
1597
1598                 error = tdm_vblank_wait(discon_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1599                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1600
1601                 UtHandleVblankEvent();
1602
1603                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1604                 ASSERT_TRUE(data == 1);
1605         }
1606 }
1607
1608 TEST_F(TDMVblankWaitThread, VblankWaitSuccessHW)
1609 {
1610         tdm_error error;
1611         int data = 0;
1612
1613         SKIP_FLAG(has_output);
1614
1615         if (!con_output_vblank)
1616                 return;
1617
1618         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1619         ASSERT_TRUE(error == TDM_ERROR_NONE);
1620
1621         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1622         ASSERT_TRUE(error == TDM_ERROR_NONE);
1623
1624         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1625         ASSERT_TRUE(error == TDM_ERROR_NONE);
1626
1627         error = tdm_vblank_set_offset(con_output_vblank, 0);
1628         ASSERT_TRUE(error == TDM_ERROR_NONE);
1629
1630         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1631         ASSERT_TRUE(error == TDM_ERROR_NONE);
1632
1633         UtHandleVblankEvent();
1634
1635         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1636         ASSERT_TRUE(data == 1);
1637 }
1638
1639 TEST_F(TDMVblankWaitThread, VblankWaitSuccessHWRepeatedly)
1640 {
1641         tdm_error error;
1642         int data;
1643
1644         SKIP_FLAG(has_output);
1645
1646         if (!con_output_vblank)
1647                 return;
1648
1649         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1650         ASSERT_TRUE(error == TDM_ERROR_NONE);
1651
1652         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1653         ASSERT_TRUE(error == TDM_ERROR_NONE);
1654
1655         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1656         ASSERT_TRUE(error == TDM_ERROR_NONE);
1657
1658         error = tdm_vblank_set_offset(con_output_vblank, 0);
1659         ASSERT_TRUE(error == TDM_ERROR_NONE);
1660
1661         for (int i = 0; i < 10; ++i) {
1662                 utVblankHandlerIsCalled = 0;
1663                 data = 0;
1664
1665                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1666                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1667
1668                 UtHandleVblankEvent();
1669
1670                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1671                 ASSERT_TRUE(data == 1);
1672         }
1673 }
1674
1675 TEST_F(TDMVblankWaitThread, VblankWaitSuccessOffsenGreaterThanZero)
1676 {
1677         tdm_error error;
1678         int data = 0;
1679
1680         SKIP_FLAG(has_output);
1681
1682         if (!con_output_vblank)
1683                 return;
1684
1685         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1686         ASSERT_TRUE(error == TDM_ERROR_NONE);
1687
1688         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1689         ASSERT_TRUE(error == TDM_ERROR_NONE);
1690
1691         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1692         ASSERT_TRUE(error == TDM_ERROR_NONE);
1693
1694         error = tdm_vblank_set_offset(con_output_vblank, 10);
1695         ASSERT_TRUE(error == TDM_ERROR_NONE);
1696
1697         error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1698         ASSERT_TRUE(error == TDM_ERROR_NONE);
1699
1700         UtHandleVblankEvent();
1701
1702         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1703         ASSERT_TRUE(data == 1);
1704 }
1705
1706 TEST_F(TDMVblankWaitThread, VblankWaitSuccessOffsenGreaterThanZeroRepeatedly)
1707 {
1708         tdm_error error;
1709         int data;
1710
1711         SKIP_FLAG(has_output);
1712
1713         if (!con_output_vblank)
1714                 return;
1715
1716         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1717         ASSERT_TRUE(error == TDM_ERROR_NONE);
1718
1719         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1720         ASSERT_TRUE(error == TDM_ERROR_NONE);
1721
1722         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1723         ASSERT_TRUE(error == TDM_ERROR_NONE);
1724
1725         error = tdm_vblank_set_offset(con_output_vblank, 10);
1726         ASSERT_TRUE(error == TDM_ERROR_NONE);
1727
1728         for (int i = 0; i < 10; ++i) {
1729                 utVblankHandlerIsCalled = 0;
1730                 data = 0;
1731
1732                 error = tdm_vblank_wait(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1733                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1734
1735                 UtHandleVblankEvent();
1736
1737                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1738                 ASSERT_TRUE(data == 1);
1739         }
1740 }
1741
1742 /* tdm_vblank_wait_seq() */
1743
1744 TEST_F(TDMVblank, VblankWaitSeqFailNullAll)
1745 {
1746         tdm_error error;
1747
1748         SKIP_FLAG(has_output);
1749
1750         error = tdm_vblank_wait_seq(NULL, 0, 0, 0, NULL, NULL);
1751         ASSERT_TRUE(error != TDM_ERROR_NONE);
1752 }
1753
1754 TEST_F(TDMVblankWait, VblankWaitSeqFailNullVblank)
1755 {
1756         tdm_error error;
1757
1758         SKIP_FLAG(has_output);
1759
1760         error = tdm_vblank_wait_seq(NULL, 0, 0, 1, UtVblankHandler, NULL);
1761         ASSERT_TRUE(error != TDM_ERROR_NONE);
1762 }
1763
1764 TEST_F(TDMVblankWait, VblankWaitSeqFailWrongVblankPtr)
1765 {
1766         tdm_error error = TDM_ERROR_BAD_MODULE;
1767         SKIP_FLAG(has_output);
1768
1769         ASSERT_EXIT({error = tdm_vblank_wait_seq((tdm_vblank *)0xFFFFFFFF, 0, 0, 1, UtVblankHandler, NULL);;
1770                                 if (error == TDM_ERROR_NONE)
1771                                         exit(1);
1772                                 else
1773                                         exit(0);},
1774                                 ::testing::ExitedWithCode(0), "");
1775 }
1776
1777 TEST_F(TDMVblankWait, VblankWaitSeqFailNullFunc)
1778 {
1779         tdm_error error;
1780
1781         SKIP_FLAG(has_output);
1782
1783         error = tdm_vblank_wait_seq(NULL, 0, 0, 1, UtVblankHandler, NULL);
1784         ASSERT_TRUE(error != TDM_ERROR_NONE);
1785 }
1786
1787 void *UtWaitVblankSeqThreadHndl(void *ptr)
1788 {
1789         tdm_error error;
1790         TDMVblankWait *vblankWait = (TDMVblankWait *)ptr;
1791
1792         error = tdm_vblank_wait_seq(vblankWait->default_vblank, 0, 0, 1, TDMVblankWait::UtVblankHandler, NULL);
1793         if (error != TDM_ERROR_NONE)
1794                 vblankWait->utWaitVblankSeqThreadHndlResult = 0;
1795         else
1796                 vblankWait->utWaitVblankSeqThreadHndlResult = 1;
1797
1798         return NULL;
1799 }
1800
1801 TEST_F(TDMVblankWait, VblankWaitSeqFailInOtherThread)
1802 {
1803         pthread_t thread = 0;
1804
1805         SKIP_FLAG(has_output);
1806
1807         ASSERT_FALSE(pthread_create(&thread, NULL, UtWaitVblankSeqThreadHndl, this));
1808
1809         ASSERT_FALSE(pthread_join(thread, NULL));
1810
1811         ASSERT_FALSE(utWaitVblankSeqThreadHndlResult);
1812 }
1813
1814 TEST_F(TDMVblankWait, VblankWaitSeqFailDisconnectedOutput)
1815 {
1816         tdm_error error;
1817
1818         SKIP_FLAG(has_output);
1819
1820         if (!discon_output_vblank)
1821                 return;
1822
1823         error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1824         ASSERT_TRUE(error != TDM_ERROR_NONE);
1825 }
1826
1827 TEST_F(TDMVblankWait, VblankWaitSeqFailDpmsOff)
1828 {
1829         tdm_error error;
1830
1831         SKIP_FLAG(has_output);
1832
1833         if (!con_output_vblank)
1834                 return;
1835
1836         error = tdm_output_set_dpms(connected_output, TDM_OUTPUT_DPMS_OFF);
1837         ASSERT_TRUE(error == TDM_ERROR_NONE);
1838
1839         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, NULL);
1840         ASSERT_TRUE(error != TDM_ERROR_NONE);
1841 }
1842
1843 TEST_F(TDMVblankWait, VblankWaitSeqSuccessFpsNonMultipleVrefresh)
1844 {
1845         tdm_error error;
1846         int data = 0;
1847
1848         SKIP_FLAG(has_output);
1849
1850         if (!con_output_vblank)
1851                 return;
1852
1853         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1854         ASSERT_TRUE(error == TDM_ERROR_NONE);
1855
1856         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1857         ASSERT_TRUE(error == TDM_ERROR_NONE);
1858
1859         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1860         ASSERT_TRUE(error == TDM_ERROR_NONE);
1861
1862         UtHandleVblankEvent();
1863
1864         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1865         ASSERT_TRUE(data == 1);
1866 }
1867
1868 TEST_F(TDMVblankWait, VblankWaitSeqSuccessFpsNonMultipleVrefreshRepeatedly)
1869 {
1870         tdm_error error;
1871         int data;
1872
1873         SKIP_FLAG(has_output);
1874
1875         if (!con_output_vblank)
1876                 return;
1877
1878         error = tdm_vblank_ignore_global_fps(con_output_vblank, 1);
1879         ASSERT_TRUE(error == TDM_ERROR_NONE);
1880
1881         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh - 1);
1882         ASSERT_TRUE(error == TDM_ERROR_NONE);
1883
1884         for (int i = 1; i < 10; ++i) {
1885                 utVblankHandlerIsCalled = 0;
1886                 data = 0;
1887
1888                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
1889                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1890
1891                 UtHandleVblankEvent();
1892
1893                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1894                 ASSERT_TRUE(data == 1);
1895         }
1896 }
1897
1898 TEST_F(TDMVblankWait, VblankWaitSeqSuccessDisconnectedOutput)
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         error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, 1, 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 TEST_F(TDMVblankWait, VblankWaitSeqSuccessDisconnectedOutputRepeatedly)
1921 {
1922         tdm_error error;
1923         int data;
1924
1925         SKIP_FLAG(has_output);
1926
1927         if (!discon_output_vblank)
1928                 return;
1929
1930         error = tdm_vblank_set_enable_fake(discon_output_vblank, 1);
1931         ASSERT_TRUE(error == TDM_ERROR_NONE);
1932
1933         for (int i = 1; i < 10; ++i) {
1934                 utVblankHandlerIsCalled = 0;
1935                 data = 0;
1936
1937                 error = tdm_vblank_wait_seq(discon_output_vblank, 0, 0, i, UtVblankHandler, &data);
1938                 ASSERT_TRUE(error == TDM_ERROR_NONE);
1939
1940                 UtHandleVblankEvent();
1941
1942                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1943                 ASSERT_TRUE(data == 1);
1944         }
1945 }
1946
1947 TEST_F(TDMVblankWait, VblankWaitSeqSuccessHW)
1948 {
1949         tdm_error error;
1950         int data;
1951
1952         SKIP_FLAG(has_output);
1953
1954         if (!con_output_vblank)
1955                 return;
1956
1957         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1958         ASSERT_TRUE(error == TDM_ERROR_NONE);
1959
1960         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1961         ASSERT_TRUE(error == TDM_ERROR_NONE);
1962
1963         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1964         ASSERT_TRUE(error == TDM_ERROR_NONE);
1965
1966         error = tdm_vblank_set_offset(con_output_vblank, 0);
1967         ASSERT_TRUE(error == TDM_ERROR_NONE);
1968
1969         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
1970         ASSERT_TRUE(error == TDM_ERROR_NONE);
1971
1972         UtHandleVblankEvent();
1973
1974         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
1975         ASSERT_TRUE(data == 1);
1976 }
1977
1978 TEST_F(TDMVblankWait, VblankWaitSeqSuccessHWRepeatedly)
1979 {
1980         tdm_error error;
1981         int data;
1982
1983         SKIP_FLAG(has_output);
1984
1985         if (!con_output_vblank)
1986                 return;
1987
1988         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
1989         ASSERT_TRUE(error == TDM_ERROR_NONE);
1990
1991         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
1992         ASSERT_TRUE(error == TDM_ERROR_NONE);
1993
1994         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
1995         ASSERT_TRUE(error == TDM_ERROR_NONE);
1996
1997         error = tdm_vblank_set_offset(con_output_vblank, 0);
1998         ASSERT_TRUE(error == TDM_ERROR_NONE);
1999
2000         for (int i = 1; i < 10; ++i) {
2001                 utVblankHandlerIsCalled = 0;
2002                 data = 0;
2003
2004                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2005                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2006
2007                 UtHandleVblankEvent();
2008
2009                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2010                 ASSERT_TRUE(data == 1);
2011         }
2012 }
2013
2014 TEST_F(TDMVblankWait, VblankWaitSeqSuccessOffsenGreaterThanZero)
2015 {
2016         tdm_error error;
2017         int data = 0;
2018
2019         SKIP_FLAG(has_output);
2020
2021         if (!con_output_vblank)
2022                 return;
2023
2024         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2025         ASSERT_TRUE(error == TDM_ERROR_NONE);
2026
2027         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
2028         ASSERT_TRUE(error == TDM_ERROR_NONE);
2029
2030         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2031         ASSERT_TRUE(error == TDM_ERROR_NONE);
2032
2033         error = tdm_vblank_set_offset(con_output_vblank, 10);
2034         ASSERT_TRUE(error == TDM_ERROR_NONE);
2035
2036         error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 1, UtVblankHandler, &data);
2037         ASSERT_TRUE(error == TDM_ERROR_NONE);
2038
2039         UtHandleVblankEvent();
2040
2041         ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2042         ASSERT_TRUE(data == 1);
2043 }
2044
2045 TEST_F(TDMVblankWait, VblankWaitSeqSuccessOffsenGreaterThanZeroRepeatedly)
2046 {
2047         tdm_error error;
2048         int data;
2049
2050         SKIP_FLAG(has_output);
2051
2052         if (!con_output_vblank)
2053                 return;
2054
2055         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2056         ASSERT_TRUE(error == TDM_ERROR_NONE);
2057
2058         error = tdm_vblank_enable_global_fps(1, preferred_mode->vrefresh);
2059         ASSERT_TRUE(error == TDM_ERROR_NONE);
2060
2061         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2062         ASSERT_TRUE(error == TDM_ERROR_NONE);
2063
2064         error = tdm_vblank_set_offset(con_output_vblank, 10);
2065         ASSERT_TRUE(error == TDM_ERROR_NONE);
2066
2067         for (int i = 1; i < 10; ++i) {
2068                 utVblankHandlerIsCalled = 0;
2069
2070                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2071                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2072
2073                 UtHandleVblankEvent();
2074
2075                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2076                 ASSERT_TRUE(data == 1);
2077         }
2078 }
2079
2080 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithSameSeq)
2081 {
2082         tdm_error error;
2083         int data = 0;
2084
2085         SKIP_FLAG(has_output);
2086
2087         if (!con_output_vblank)
2088                 return;
2089
2090         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2091         ASSERT_TRUE(error == TDM_ERROR_NONE);
2092
2093         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2094         ASSERT_TRUE(error == TDM_ERROR_NONE);
2095
2096         error = tdm_vblank_set_offset(con_output_vblank, 0);
2097         ASSERT_TRUE(error == TDM_ERROR_NONE);
2098
2099         for (int i = 1; i < 10; ++i) {
2100                 utVblankHandlerIsCalled = 0;
2101                 data = 0;
2102
2103                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, 2, UtVblankHandler, &data);
2104                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2105
2106                 UtHandleVblankEvent();
2107
2108                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2109                 ASSERT_TRUE(data == 1);
2110         }
2111 }
2112
2113 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithBigFps)
2114 {
2115         tdm_error error;
2116         int data = 0;
2117
2118         SKIP_FLAG(has_output);
2119
2120         if (!con_output_vblank)
2121                 return;
2122
2123         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2124         ASSERT_TRUE(error == TDM_ERROR_NONE);
2125
2126         error = tdm_vblank_set_fps(con_output_vblank, 5000);
2127         ASSERT_TRUE(error == TDM_ERROR_NONE);
2128
2129         for (int i = 1; i < 10; ++i) {
2130                 utVblankHandlerIsCalled = 0;
2131                 data = 0;
2132
2133                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2134                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2135
2136                 if (i < 4)
2137                         continue;
2138
2139                 UtHandleVblankEvent();
2140
2141                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2142                 ASSERT_TRUE(data == 1);
2143         }
2144 }
2145
2146 TEST_F(TDMVblankWait, VblankWaitSeqSuccessRepeatedlyWithDelay)
2147 {
2148         tdm_error error;
2149         int data = 0;
2150
2151         SKIP_FLAG(has_output);
2152
2153         if (!con_output_vblank)
2154                 return;
2155
2156         error = tdm_vblank_ignore_global_fps(con_output_vblank, 0);
2157         ASSERT_TRUE(error == TDM_ERROR_NONE);
2158
2159         error = tdm_vblank_set_fps(con_output_vblank, preferred_mode->vrefresh);
2160         ASSERT_TRUE(error == TDM_ERROR_NONE);
2161
2162         for (int i = 1; i < 10; ++i) {
2163                 utVblankHandlerIsCalled = 0;
2164                 data = 0;
2165
2166                 error = tdm_vblank_wait_seq(con_output_vblank, 0, 0, i, UtVblankHandler, &data);
2167                 ASSERT_TRUE(error == TDM_ERROR_NONE);
2168
2169                 usleep(100000);
2170
2171                 UtHandleVblankEvent();
2172
2173                 ASSERT_TRUE(utVblankHandlerIsCalled == 1);
2174                 ASSERT_TRUE(data == 1);
2175         }
2176 }