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  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27 **************************************************************************/
  28
  29 #include "gtest/gtest.h"
  30
  31 #include "stub_pthread.h"
  32 #include "stub_tdm_display.h"
  33 #include "stub_stdlib.h"
  34 #include "stub_unistd.h"
  35 #include "stub_tdm_event_loop.h"
  36 #include "stub_tdm_thread.h"
  37 #include "stub_tdm.h"
  38 #include "stub_tdm_event_loop.h"
  39 #include "stub_tdm_helper.h"
  40
  41 #include <sys/types.h>
  42
  43 extern "C"  const char*
  44 tdm_server_get_client_name(pid_t pid)
  45 {
  46         (void)pid;
  47         return NULL;
  48 }
  49
  50 #include "tdm_vblank.c"
  51
  52 static void _init_test()
  53 {
  54         stub_tdm_helper_init();
  55         stub_tdm_event_loop_init();
  56         stub_tdm_init();
  57         stub_tdm_thread_init();
  58         stub_tdm_event_loop_init();
  59         stub_stdlib_init();
  60         stub_stdlib_init();
  61         stub_tdm_display_init();
  62         stub_pthread_init();
  63         vblank_list_inited = 0;
  64         tdm_debug_module = TDM_DEBUG_VBLANK;
  65 }
  66
  67 /* UNIT TESTS */
  68
  69 /* tdm_vblank_create() */
  70
  71 TEST(tdm_vblank_create, error_dpy_is_null)
  72 {
  73         tdm_vblank *vblank;
  74         tdm_private_output output;
  75         tdm_error error;
  76
  77         _init_test();
  78
  79         vblank = tdm_vblank_create(NULL, &output, &error);
  80
  81         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
  82         ASSERT_TRUE(vblank == NULL);
  83 }
  84
  85 TEST(tdm_vblank_create, error_output_is_null)
  86 {
  87         tdm_vblank *vblank;
  88         tdm_private_display display;
  89         tdm_error error;
  90
  91         _init_test();
  92
  93         vblank = tdm_vblank_create(&display, NULL, &error);
  94
  95         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
  96         ASSERT_TRUE(vblank == NULL);
  97 }
  98
  99 TEST(tdm_vblank_create, error_list_inited_mutex_init)
 100 {
 101         tdm_vblank *vblank;
 102         tdm_private_display display;
 103         tdm_private_output output;
 104         tdm_error error;
 105
 106         _init_test();
 107
 108         PTHREAD_MUTEX_INIT_ERROR = -1;
 109
 110         vblank = tdm_vblank_create(&display, &output, &error);
 111
 112         ASSERT_EQ(error, TDM_ERROR_OPERATION_FAILED);
 113         ASSERT_TRUE(vblank == NULL);
 114 }
 115
 116 TEST(tdm_vblank_create, error_mode_is_null)
 117 {
 118         tdm_vblank *vblank;
 119         tdm_private_display display;
 120         tdm_private_output output;
 121         tdm_error error;
 122
 123         _init_test();
 124
 125         stub_tdm_output_get_mode_error = 1;
 126
 127         vblank = tdm_vblank_create(&display, &output, &error);
 128
 129         ASSERT_EQ(error, TDM_ERROR_OPERATION_FAILED);
 130         ASSERT_TRUE(vblank == NULL);
 131 }
 132
 133 TEST(tdm_vblank_create, error_calloc_error)
 134 {
 135         tdm_vblank *vblank;
 136         tdm_private_display display;
 137         tdm_private_output output;
 138         tdm_error error;
 139
 140         _init_test();
 141
 142         CALLOC_ERROR = 1;
 143
 144         vblank = tdm_vblank_create(&display, &output, &error);
 145
 146         ASSERT_EQ(error, TDM_ERROR_OUT_OF_MEMORY);
 147         ASSERT_TRUE(vblank == NULL);
 148 }
 149
 150 TEST(tdm_vblank_create, success_vblank_create)
 151 {
 152         tdm_private_vblank *vblank;
 153         tdm_private_display display;
 154         tdm_private_output output;
 155         tdm_error error;
 156         tdm_private_vblank *find_item;
 157         tdm_private_vblank *tmp;
 158
 159         _init_test();
 160
 161         vblank =
 162                 (tdm_private_vblank *) tdm_vblank_create(&display, &output, &error);
 163
 164         ASSERT_EQ(error, TDM_ERROR_NONE);
 165         ASSERT_TRUE(vblank != NULL);
 166         ASSERT_TRUE(stub_tdm_output_change_handler == _tdm_vblank_cb_output_change);
 167         ASSERT_EQ(vblank->stamp, stamp);
 168         ASSERT_EQ(vblank->owner_tid, stub_syscall_return_value);
 169         ASSERT_TRUE(vblank->dpy == &display);
 170         ASSERT_TRUE(vblank->output == &output);
 171         ASSERT_EQ(vblank->dpms, stub_tdm_dpms_returned_value);
 172         ASSERT_EQ(vblank->vrefresh, stub_tdm_mode.vrefresh);
 173         ASSERT_EQ(vblank->HW_vblank_gap, 1.0 / vblank->vrefresh);
 174         ASSERT_EQ(vblank->check_HW_or_SW, 1);
 175         ASSERT_EQ(vblank->fps, stub_tdm_mode.vrefresh);
 176         ASSERT_TRUE(LIST_IS_EMPTY(&vblank->HW_wait_list));
 177         ASSERT_TRUE(LIST_IS_EMPTY(&vblank->SW_wait_list));
 178 //      LIST_FOR_EACH_ENTRY_SAFE(find_item, tmp, &vblank_list, link) {
 179 //              if (find_item == vblank)
 180 //                      break;
 181 //              find_item = NULL;
 182 //      }
 183 //      ASSERT_TRUE(find_item != NULL);
 184 //      ASSERT_TRUE(LIST_IS_EMPTY(&valid_wait_list));
 185 //      free(vblank);
 186 }
 187
 188 /* tdm_vblank_destroy() */
 189
 190 //TEST(tdm_vblank_destroy, success_vblank_destroy)
 191 //{
 192 //      tdm_private_vblank *vblank;
 193 //      int SW_timer = 10;
 194 //      tdm_vblank_wait_info *hw_vblank_wait_info;
 195 //      tdm_vblank_wait_info *sw_vblank_wait_info;
 196 //
 197 //      _init_test();
 198 //
 199 //      vblank = (tdm_private_vblank *) calloc(1, sizeof *vblank);
 200 //      hw_vblank_wait_info =
 201 //              (tdm_vblank_wait_info *) calloc(1, sizeof *hw_vblank_wait_info);
 202 //      sw_vblank_wait_info =
 203 //              (tdm_vblank_wait_info *) calloc(1, sizeof *sw_vblank_wait_info);
 204 //
 205 ////    LIST_INITHEAD(&vblank_list);
 206 ////    LIST_ADD(&vblank->link, &vblank_list);
 207 //
 208 //      vblank->SW_timer = &SW_timer;
 209 //
 210 //      LIST_INITHEAD(&hw_vblank_wait_info->valid_link);
 211 //      LIST_INITHEAD(&vblank->HW_wait_list);
 212 //      LIST_ADD(&hw_vblank_wait_info->link, &vblank->HW_wait_list);
 213 //
 214 //      LIST_INITHEAD(&sw_vblank_wait_info->valid_link);
 215 //      LIST_INITHEAD(&vblank->SW_wait_list);
 216 //      LIST_ADD(&sw_vblank_wait_info->link, &vblank->SW_wait_list);
 217 //
 218 //      tdm_vblank_destroy(vblank);
 219 //
 220 ////    ASSERT_TRUE(LIST_IS_EMPTY(&vblank_list));
 221 //      ASSERT_TRUE(stub_tdm_event_loop_removed_source == &SW_timer);
 222 //      ASSERT_TRUE(stub_tdm_output_change_handler == _tdm_vblank_cb_output_change);
 223 //      ASSERT_TRUE(LIST_IS_EMPTY(&vblank->HW_wait_list));
 224 //      ASSERT_TRUE(LIST_IS_EMPTY(&vblank->SW_wait_list));
 225 //      ASSERT_EQ(FREE_CALLED, 1);
 226 //}
 227
 228 /* tdm_vblank_set_fps() */
 229
 230 TEST(tdm_vblank_set_fps, error_vblank_is_null)
 231 {
 232         tdm_error error;
 233
 234         _init_test();
 235
 236         error = tdm_vblank_set_fps(NULL, 5);
 237
 238         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 239 }
 240
 241 TEST(tdm_vblank_set_fps, error_fps_is_0)
 242 {
 243         tdm_error error;
 244         tdm_private_vblank vblank;
 245
 246         _init_test();
 247
 248         error = tdm_vblank_set_fps(&vblank, 0);
 249
 250         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 251 }
 252
 253 TEST(tdm_vblank_set_fps, success_fps_is_already_set)
 254 {
 255         tdm_error error;
 256         tdm_private_vblank vblank;
 257         unsigned int fps = 60;
 258
 259         _init_test();
 260
 261         vblank.fps = fps;
 262
 263         error = tdm_vblank_set_fps(&vblank, fps);
 264
 265         ASSERT_EQ(error, TDM_ERROR_NONE);
 266         ASSERT_EQ(vblank.fps, fps);
 267 }
 268
 269 TEST(tdm_vblank_set_fps, success_set_fps)
 270 {
 271         tdm_error error;
 272         tdm_private_vblank vblank;
 273         unsigned int fps = 60;
 274
 275         _init_test();
 276
 277         vblank.fps = fps - 10;
 278
 279         error = tdm_vblank_set_fps(&vblank, fps);
 280
 281         ASSERT_EQ(error, TDM_ERROR_NONE);
 282         ASSERT_EQ(vblank.fps, fps);
 283         ASSERT_EQ(vblank.check_HW_or_SW, 1);
 284 }
 285
 286 /* tdm_vblank_set_offset() */
 287
 288 TEST(tdm_vblank_set_offset, error_vblank_is_null)
 289 {
 290         tdm_error error;
 291
 292         _init_test();
 293
 294         error = tdm_vblank_set_offset(NULL, 1);
 295
 296         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 297 }
 298
 299 TEST(tdm_vblank_set_offset, success_offset_is_already_set)
 300 {
 301         tdm_error error;
 302         tdm_private_vblank vblank;
 303         int offset = 256;
 304
 305         _init_test();
 306
 307         vblank.offset = offset;
 308
 309         error = tdm_vblank_set_offset(&vblank, offset);
 310
 311         ASSERT_EQ(error, TDM_ERROR_NONE);
 312         ASSERT_EQ(vblank.offset, offset);
 313 }
 314
 315 TEST(tdm_vblank_set_offset, success_vblank_set_offset)
 316 {
 317         tdm_error error;
 318         tdm_private_vblank vblank;
 319         int offset = 256;
 320
 321         _init_test();
 322
 323         vblank.offset = offset - 64;
 324
 325         error = tdm_vblank_set_offset(&vblank, offset);
 326
 327         ASSERT_EQ(error, TDM_ERROR_NONE);
 328         ASSERT_EQ(vblank.offset, offset);
 329         ASSERT_EQ(vblank.check_HW_or_SW, 1);
 330 }
 331
 332 /* tdm_vblank_set_enable_fake() */
 333
 334 TEST(tdm_vblank_set_enable_fake, error_vblank_is_null)
 335 {
 336         tdm_error error;
 337
 338         _init_test();
 339
 340         error = tdm_vblank_set_enable_fake(NULL, 1);
 341
 342         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 343 }
 344
 345 TEST(tdm_vblank_set_enable_fake, success_enable_fake_is_already_set)
 346 {
 347         tdm_error error;
 348         tdm_private_vblank vblank;
 349         int enable_fake = 256;
 350
 351         _init_test();
 352
 353         vblank.enable_fake = enable_fake;
 354
 355         error = tdm_vblank_set_enable_fake(&vblank, enable_fake);
 356
 357         ASSERT_EQ(error, TDM_ERROR_NONE);
 358         ASSERT_EQ(vblank.enable_fake, enable_fake);
 359 }
 360
 361 TEST(tdm_vblank_set_enable_fake, success_vblank_set_enable_fake)
 362 {
 363         tdm_error error;
 364         tdm_private_vblank vblank;
 365         int enable_fake = 256;
 366
 367         _init_test();
 368
 369         vblank.enable_fake = enable_fake - 64;
 370
 371         error = tdm_vblank_set_enable_fake(&vblank, enable_fake);
 372
 373         ASSERT_EQ(error, TDM_ERROR_NONE);
 374         ASSERT_EQ(vblank.enable_fake, enable_fake);
 375 }
 376
 377 /* tdm_vblank_get_enable_fake() */
 378
 379 TEST(tdm_vblank_get_enable_fake, error_vblank_is_null)
 380 {
 381         unsigned int enable_fake;
 382
 383         _init_test();
 384
 385         tdm_vblank_get_enable_fake(NULL, &enable_fake);
 386
 387         ASSERT_EQ(enable_fake, 0);
 388 }
 389
 390 TEST(tdm_vblank_get_enable_fake, success_vblank_get_enable_fake)
 391 {
 392         tdm_private_vblank vblank;
 393         unsigned int enable_fake;
 394
 395         _init_test();
 396
 397         vblank.enable_fake = 15;
 398
 399         tdm_vblank_get_enable_fake(&vblank, &enable_fake);
 400
 401         ASSERT_EQ(enable_fake, vblank.enable_fake);
 402 }
 403
 404 /* tdm_vblank_cb_vblank_SW() */
 405
 406 TEST(tdm_vblank_cb_vblank_SW, error_vblank_is_null_and_vblank_stamp_less_0)
 407 {
 408         tdm_error error;
 409
 410         _init_test();
 411
 412         error = tdm_vblank_cb_vblank_SW(NULL, -1);
 413
 414         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 415 }
 416
 417 TEST(tdm_vblank_cb_vblank_SW, success_vblank_is_null_and_not_on_vblank_list)
 418 {
 419         tdm_error error;
 420
 421         _init_test();
 422
 423 //      LIST_INITHEAD(&vblank_list);
 424
 425         error = tdm_vblank_cb_vblank_SW(NULL, 5);
 426
 427         ASSERT_EQ(error, TDM_ERROR_NONE);
 428 }
 429
 430 TEST(tdm_vblank_cb_vblank_SW, success_not_in_display_thread)
 431 {
 432         tdm_error error;
 433         tdm_private_vblank vblank;
 434         tdm_thread_cb_vblank_sw *vblank_sw;
 435         tdm_private_display display;
 436
 437         _init_test();
 438
 439         vblank.owner_tid = 10;
 440         vblank.stamp = 15.0;
 441         vblank.dpy = &display;
 442
 443         stub_syscall_return_value = vblank.owner_tid - 1;
 444
 445         error = tdm_vblank_cb_vblank_SW(&vblank, 5);
 446
 447         vblank_sw = (tdm_thread_cb_vblank_sw *) stub_tdm_thread_send_cb_buff;
 448
 449         ASSERT_EQ(error, TDM_ERROR_NONE);
 450         ASSERT_EQ(vblank_sw->base.length, sizeof(tdm_thread_cb_vblank_sw));
 451         ASSERT_EQ(vblank_sw->base.type, TDM_THREAD_CB_VBLANK_SW);
 452         ASSERT_DOUBLE_EQ(vblank_sw->vblank_stamp, vblank.stamp);
 453 }
 454
 455 TEST(tdm_vblank_cb_vblank_SW, success_SW_wait_list_is_empty)
 456 {
 457         tdm_error error;
 458         tdm_private_vblank vblank;
 459
 460         _init_test();
 461
 462         vblank.owner_tid = 10;
 463
 464         stub_syscall_return_value = vblank.owner_tid;
 465
 466         LIST_INITHEAD(&vblank.SW_wait_list);
 467
 468         error = tdm_vblank_cb_vblank_SW(&vblank, 5);
 469
 470         ASSERT_EQ(error, TDM_ERROR_OPERATION_FAILED);
 471 }
 472
 473 TEST(tdm_vblank_cb_vblank_SW, success_vblank_cb_vblank_SW)
 474 {
 475         tdm_error error;
 476         tdm_private_vblank vblank;
 477         tdm_vblank_wait_info *first_wait_info;
 478         tdm_vblank_wait_info *wait_info;
 479
 480         _init_test();
 481
 482         first_wait_info =
 483                 (tdm_vblank_wait_info *) calloc(1, sizeof *first_wait_info);
 484         wait_info = (tdm_vblank_wait_info *) calloc(1, sizeof *wait_info);
 485
 486         vblank.owner_tid = 10;
 487
 488         stub_syscall_return_value = vblank.owner_tid;
 489
 490         LIST_INITHEAD(&vblank.SW_wait_list);
 491         LIST_INITHEAD(&first_wait_info->valid_link);
 492         LIST_INITHEAD(&wait_info->valid_link);
 493
 494         LIST_ADD(&wait_info->link, &vblank.SW_wait_list);
 495         LIST_ADD(&first_wait_info->link, &vblank.SW_wait_list);
 496
 497         vblank.last_seq = 20;
 498         first_wait_info->target_seq = 19;
 499         wait_info->target_seq = 21;
 500
 501         first_wait_info->target_time = 5;
 502         wait_info->target_time = 5;
 503
 504         first_wait_info->func = stub_tdm_vblank_handler;
 505         wait_info->func = stub_tdm_vblank_handler;
 506
 507         error = tdm_vblank_cb_vblank_SW(&vblank, 5);
 508
 509         ASSERT_EQ(error, TDM_ERROR_NONE);
 510         ASSERT_EQ(FREE_CALLED, 1);
 511         ASSERT_EQ(stub_tdm_vblank_handler_call_count, 2);
 512 }
 513
 514 TEST(tdm_vblank_cb_vblank_SW, success_vblank_cb_vblank_SW_2)
 515 {
 516         tdm_error error;
 517         tdm_private_vblank vblank;
 518         tdm_vblank_wait_info *first_wait_info;
 519         tdm_vblank_wait_info *wait_info;
 520
 521         _init_test();
 522
 523         first_wait_info =
 524                 (tdm_vblank_wait_info *) calloc(1, sizeof *first_wait_info);
 525         wait_info = (tdm_vblank_wait_info *) calloc(1, sizeof *wait_info);
 526
 527         vblank.owner_tid = 10;
 528
 529         stub_syscall_return_value = vblank.owner_tid;
 530
 531         LIST_INITHEAD(&vblank.SW_wait_list);
 532         LIST_INITHEAD(&first_wait_info->valid_link);
 533         LIST_INITHEAD(&wait_info->valid_link);
 534
 535         LIST_ADD(&wait_info->link, &vblank.SW_wait_list);
 536         LIST_ADD(&first_wait_info->link, &vblank.SW_wait_list);
 537
 538         vblank.last_seq = 20;
 539         first_wait_info->target_seq = 19;
 540         wait_info->target_seq = 21;
 541
 542         first_wait_info->target_time = 5;
 543         wait_info->target_time = 10;
 544
 545         first_wait_info->func = stub_tdm_vblank_handler;
 546         wait_info->func = stub_tdm_vblank_handler;
 547
 548         error = tdm_vblank_cb_vblank_SW(&vblank, 5);
 549
 550         ASSERT_EQ(error, TDM_ERROR_NONE);
 551         ASSERT_EQ(FREE_CALLED, 1);
 552         ASSERT_EQ(stub_tdm_vblank_handler_call_count, 1);
 553 }
 554
 555 /* tdm_vblank_wait() */
 556
 557 TEST(tdm_vblank_wait, error_vblank_is_null)
 558 {
 559         tdm_error error;
 560
 561         _init_test();
 562
 563         error = tdm_vblank_wait(NULL, 1, 1, 1, stub_tdm_vblank_handler, NULL);
 564
 565         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 566 }
 567
 568 TEST(tdm_vblank_wait, error_func_is_null)
 569 {
 570         tdm_error error;
 571         tdm_private_vblank vblank;
 572
 573         _init_test();
 574
 575         error = tdm_vblank_wait(&vblank, 1, 1, 1, NULL, NULL);
 576
 577         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 578 }
 579
 580 TEST(tdm_vblank_wait, error_not_in_display_thread)
 581 {
 582         tdm_error error;
 583         tdm_private_vblank vblank;
 584
 585         _init_test();
 586
 587         vblank.owner_tid = 10;
 588
 589         stub_syscall_return_value = vblank.owner_tid - 1;
 590
 591         error = tdm_vblank_wait(&vblank, 1, 1, 1, stub_tdm_vblank_handler, NULL);
 592
 593         ASSERT_EQ(error, TDM_ERROR_BAD_REQUEST);
 594 }
 595
 596 TEST(tdm_vblank_wait, error_dpms_is_off_and_enable_fake_is_0)
 597 {
 598         tdm_error error;
 599         tdm_private_vblank vblank;
 600
 601         _init_test();
 602
 603         vblank.owner_tid = 10;
 604         vblank.dpms = TDM_OUTPUT_DPMS_OFF;
 605         vblank.enable_fake = 0;
 606
 607         stub_syscall_return_value = vblank.owner_tid;
 608
 609         error = tdm_vblank_wait(&vblank, 1, 1, 1, stub_tdm_vblank_handler, NULL);
 610
 611         ASSERT_EQ(error, TDM_ERROR_DPMS_OFF);
 612 }
 613
 614 TEST(tdm_vblank_wait, error_calloc)
 615 {
 616         tdm_error error;
 617         tdm_private_vblank vblank;
 618
 619         _init_test();
 620
 621         vblank.owner_tid = 10;
 622         vblank.dpms = TDM_OUTPUT_DPMS_ON;
 623
 624         stub_syscall_return_value = vblank.owner_tid;
 625
 626         CALLOC_ERROR = 1;
 627
 628         error = tdm_vblank_wait(&vblank, 1, 1, 1, stub_tdm_vblank_handler, NULL);
 629
 630         ASSERT_EQ(error, TDM_ERROR_OUT_OF_MEMORY);
 631 }
 632
 633 //TEST(tdm_vblank_wait, error_vblank_wait_HW_and_vblank_wait_SW)
 634 //{
 635 //      tdm_error error;
 636 //      tdm_private_vblank vblank;
 637 //      int SW_timer = 10;
 638 //
 639 //      _init_test();
 640 //
 641 //      LIST_INITHEAD(&vblank.HW_wait_list);
 642 //      LIST_INITHEAD(&vblank.SW_wait_list);
 643 //
 644 //      vblank.owner_tid = 10;
 645 //      vblank.dpms = TDM_OUTPUT_DPMS_ON;
 646 //      vblank.check_HW_or_SW = 1;
 647 //      vblank.vrefresh = 60;
 648 //      vblank.fps = 60;
 649 //      vblank.offset = 1;
 650 //      vblank.last_time = 0;
 651 //      vblank.SW_timer = &SW_timer;
 652 //
 653 //      stub_syscall_return_value = vblank.owner_tid;
 654 //      stub_tdm_output_wait_vblank_error = 1;
 655 //      stub_tdm_event_loop_source_timer_update_error = 1;
 656 //
 657 //      error = tdm_vblank_wait(&vblank, 0, 0, 1, stub_tdm_vblank_handler, NULL);
 658 //
 659 //      ASSERT_EQ(error, TDM_ERROR_OPERATION_FAILED);
 660 //}
 661
 662 //TEST(tdm_vblank_wait, error_vblank_wait_SW)
 663 //{
 664 //      tdm_error error;
 665 //      tdm_private_vblank vblank;
 666 //      int SW_timer = 10;
 667 //
 668 //      _init_test();
 669 //
 670 //      LIST_INITHEAD(&vblank.HW_wait_list);
 671 //      LIST_INITHEAD(&vblank.SW_wait_list);
 672 //
 673 //      vblank.owner_tid = 10;
 674 //      vblank.dpms = TDM_OUTPUT_DPMS_ON;
 675 //      vblank.check_HW_or_SW = 1;
 676 //      vblank.vrefresh = 60;
 677 //      vblank.fps = 24;
 678 //      vblank.offset = 1;
 679 //      vblank.last_time = 0;
 680 //      vblank.SW_timer = &SW_timer;
 681 //
 682 //      stub_syscall_return_value = vblank.owner_tid;
 683 //      stub_tdm_event_loop_source_timer_update_error = 1;
 684 //
 685 //      error = tdm_vblank_wait(&vblank, 0, 0, 1, stub_tdm_vblank_handler, NULL);
 686 //
 687 //      ASSERT_EQ(error, TDM_ERROR_OPERATION_FAILED);
 688 //}
 689
 690 TEST(tdm_vblank_wait, success_vblank_wait_SW)
 691 {
 692         tdm_error error;
 693         tdm_private_vblank vblank;
 694         int SW_timer = 10;
 695
 696         _init_test();
 697
 698         LIST_INITHEAD(&vblank.HW_wait_list);
 699         LIST_INITHEAD(&vblank.SW_wait_list);
 700
 701         vblank.owner_tid = 10;
 702         vblank.enable_fake = 1;
 703         vblank.dpms = TDM_OUTPUT_DPMS_OFF;
 704         vblank.check_HW_or_SW = 1;
 705         vblank.vrefresh = 60;
 706         vblank.fps = 60;
 707         vblank.offset = 1;
 708         vblank.last_time = 0;
 709         vblank.SW_timer = &SW_timer;
 710
 711         stub_syscall_return_value = vblank.owner_tid;
 712
 713         error = tdm_vblank_wait(&vblank, 0, 0, 1, stub_tdm_vblank_handler, NULL);
 714
 715         ASSERT_EQ(error, TDM_ERROR_NONE);
 716 }
 717
 718 TEST(tdm_vblank_wait, success_vblank_wait_HW)
 719 {
 720         tdm_error error;
 721         tdm_private_vblank vblank;
 722         int SW_timer = 10;
 723
 724         _init_test();
 725
 726         LIST_INITHEAD(&vblank.HW_wait_list);
 727         LIST_INITHEAD(&vblank.SW_wait_list);
 728
 729         vblank.owner_tid = 10;
 730         vblank.dpms = TDM_OUTPUT_DPMS_ON;
 731         vblank.check_HW_or_SW = 1;
 732         vblank.vrefresh = 60;
 733         vblank.fps = 60;
 734         vblank.offset = 0;
 735         vblank.last_time = 0;
 736         vblank.SW_timer = &SW_timer;
 737
 738         stub_syscall_return_value = vblank.owner_tid;
 739
 740         error = tdm_vblank_wait(&vblank, 0, 0, 1, stub_tdm_vblank_handler, NULL);
 741
 742         ASSERT_EQ(error, TDM_ERROR_NONE);
 743 }
 744
 745 /* tdm_vblank_wait_seq() */
 746
 747 TEST(tdm_vblank_wait_seq, error_vblank_is_null)
 748 {
 749         tdm_error error;
 750
 751         _init_test();
 752
 753         error = tdm_vblank_wait_seq(NULL, 1, 1, 1, stub_tdm_vblank_handler, NULL);
 754
 755         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 756 }
 757
 758 TEST(tdm_vblank_wait_seq, error_func_is_null)
 759 {
 760         tdm_error error;
 761         tdm_private_vblank vblank;
 762
 763         _init_test();
 764
 765         error = tdm_vblank_wait_seq(&vblank, 1, 1, 1, NULL, NULL);
 766
 767         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 768 }
 769
 770 TEST(tdm_vblank_wait_seq, success_last_seq_is_0)
 771 {
 772         tdm_error error;
 773         tdm_private_vblank vblank;
 774         int SW_timer = 10;
 775
 776         _init_test();
 777
 778         LIST_INITHEAD(&vblank.HW_wait_list);
 779         LIST_INITHEAD(&vblank.SW_wait_list);
 780
 781         vblank.last_seq = 0;
 782         vblank.owner_tid = 10;
 783         vblank.dpms = TDM_OUTPUT_DPMS_ON;
 784         vblank.check_HW_or_SW = 1;
 785         vblank.vrefresh = 60;
 786         vblank.fps = 60;
 787         vblank.offset = 0;
 788         vblank.last_time = 0;
 789         vblank.SW_timer = &SW_timer;
 790
 791         stub_syscall_return_value = vblank.owner_tid;
 792
 793         error =
 794                 tdm_vblank_wait_seq(&vblank, 0, 0, 1, stub_tdm_vblank_handler, NULL);
 795
 796         ASSERT_EQ(error, TDM_ERROR_NONE);
 797 }
 798
 799 TEST(tdm_vblank_wait_seq,
 800          success_sequence_greater_last_seq_and_seq_target_less_curr)
 801 {
 802         tdm_error error;
 803         tdm_private_vblank vblank;
 804
 805         _init_test();
 806
 807         vblank.last_seq = 1;
 808         vblank.vblank_gap = 0;
 809
 810         stub_tdm_helper_get_time_ret_val = 100;
 811
 812         error =
 813                 tdm_vblank_wait_seq(&vblank, 0, 0, 5, stub_tdm_vblank_handler, NULL);
 814
 815         ASSERT_EQ(error, TDM_ERROR_NONE);
 816         ASSERT_EQ(stub_tdm_vblank_handler_call_count, 1);
 817 }
 818
 819 TEST(tdm_vblank_wait_seq, success_target_is_too_close_to_current)
 820 {
 821         tdm_error error;
 822         tdm_private_vblank vblank;
 823
 824         _init_test();
 825
 826         vblank.last_seq = 1;
 827         vblank.vblank_gap = 0;
 828
 829         stub_tdm_helper_get_time_ret_val = vblank.last_time - 0.0001;
 830
 831         error =
 832                 tdm_vblank_wait_seq(&vblank, 0, 0, 5, stub_tdm_vblank_handler, NULL);
 833
 834         ASSERT_EQ(error, TDM_ERROR_NONE);
 835         ASSERT_EQ(stub_tdm_vblank_handler_call_count, 1);
 836 }
 837
 838 TEST(tdm_vblank_wait_seq, success_sequence_greater_last_seq)
 839 {
 840         tdm_error error;
 841         tdm_private_vblank vblank;
 842         int SW_timer = 10;
 843
 844         _init_test();
 845
 846         LIST_INITHEAD(&vblank.HW_wait_list);
 847         LIST_INITHEAD(&vblank.SW_wait_list);
 848
 849         vblank.last_seq = 1;
 850         vblank.owner_tid = 10;
 851         vblank.dpms = TDM_OUTPUT_DPMS_ON;
 852         vblank.check_HW_or_SW = 1;
 853         vblank.vrefresh = 60;
 854         vblank.fps = 60;
 855         vblank.offset = 0;
 856         vblank.last_time = 1;
 857         vblank.SW_timer = &SW_timer;
 858         vblank.vblank_gap = 0;
 859
 860         stub_syscall_return_value = vblank.owner_tid;
 861
 862         stub_tdm_helper_get_time_ret_val = vblank.last_time - 0.5;
 863
 864         error =
 865                 tdm_vblank_wait_seq(&vblank, 0, 0, 5, stub_tdm_vblank_handler, NULL);
 866
 867         ASSERT_EQ(error, TDM_ERROR_NONE);
 868 }
 869
 870 TEST(tdm_vblank_wait_seq,
 871          success_last_seq_is_not_0_and_no_sequence_greater_last_seq)
 872 {
 873         tdm_error error;
 874         tdm_private_vblank vblank;
 875         unsigned int sequence = TDM_VBLANK_UINT_1Q + 100;
 876
 877         _init_test();
 878
 879         vblank.last_seq = sequence + 100;
 880         vblank.vblank_gap = 0;
 881
 882         stub_tdm_helper_get_time_ret_val = vblank.last_time - 0.0001;
 883
 884         error =
 885                 tdm_vblank_wait_seq(&vblank, 0, 0, sequence, stub_tdm_vblank_handler,
 886                                                         NULL);
 887
 888         ASSERT_EQ(error, TDM_ERROR_NONE);
 889         ASSERT_EQ(stub_tdm_vblank_handler_call_count, 1);
 890 }