ut/src/ut_tdm_thread.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 "tbm_stubs.h"
  32 #include "stub_pthread.h"
  33 #include "stub_stdlib.h"
  34 #include "stub_unistd.h"
  35 #include "stub_tdm.h"
  36 #include "stub_tdm_display.h"
  37 #include "stub_tdm_pp.h"
  38 #include "stub_tdm_capture.h"
  39 #include "stub_tdm_vblank.h"
  40
  41 #include "tdm_thread.c"
  42
  43 static void _init_test()
  44 {
  45         keep_private_thread = NULL;
  46         tdm_mutex_locked = 0;
  47
  48         stub_pthread_init();
  49         stub_stdlib_init();
  50         stub_unistd_init();
  51         stub_tdm_display_init();
  52         stub_tdm_pp_init();
  53 }
  54
  55 /* UNIT TESTS */
  56
  57 /* tdm_thread_init */
  58
  59 TEST(tdm_thread_init, error_mutex_is_not_locked)
  60 {
  61         tdm_error error;
  62         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
  63         tdm_private_loop private_loop;
  64         tdm_private_thread private_thread;
  65
  66         _init_test();
  67
  68         keep_private_thread = &private_thread;
  69
  70         error = tdm_thread_init(&private_loop);
  71
  72         ASSERT_EQ(error, expected_error);
  73 }
  74
  75 TEST(tdm_thread_init, error_dpy_is_null)
  76 {
  77         tdm_error error;
  78         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
  79         tdm_private_loop private_loop;
  80
  81         _init_test();
  82
  83         memset(&private_loop, 0, sizeof(tdm_private_loop));
  84
  85         tdm_mutex_locked = 1;
  86
  87         error = tdm_thread_init(&private_loop);
  88
  89         ASSERT_EQ(error, expected_error);
  90 }
  91
  92 TEST(tdm_thread_init, error_dpy_private_loop_is_null)
  93 {
  94         tdm_error error;
  95         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
  96         tdm_private_loop private_loop;
  97         tdm_private_display private_display;
  98
  99         _init_test();
 100
 101         memset(&private_loop, 0, sizeof(tdm_private_loop));
 102         memset(&private_display, 0, sizeof(tdm_private_display));
 103
 104         tdm_mutex_locked = 1;
 105         private_loop.dpy = &private_display;
 106
 107         error = tdm_thread_init(&private_loop);
 108
 109         ASSERT_EQ(error, expected_error);
 110 }
 111
 112 TEST(tdm_thread_init, success_private_thread_is_not_null)
 113 {
 114         tdm_error error;
 115         tdm_error expected_error = TDM_ERROR_NONE;
 116         tdm_private_loop private_loop;
 117         tdm_private_display private_display;
 118         tdm_private_loop dpy_private_loop;
 119         tdm_private_thread private_thread;
 120
 121         _init_test();
 122
 123         memset(&private_loop, 0, sizeof(tdm_private_loop));
 124         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 125         memset(&private_display, 0, sizeof(tdm_private_display));
 126
 127         tdm_mutex_locked = 1;
 128         private_loop.dpy = &private_display;
 129         private_display.private_loop = &dpy_private_loop;
 130         private_loop.private_thread = &private_thread;
 131
 132         error = tdm_thread_init(&private_loop);
 133
 134         ASSERT_EQ(error, expected_error);
 135 }
 136
 137 TEST(tdm_thread_init, success_getenv_return_null)
 138 {
 139         tdm_error error;
 140         tdm_error expected_error = TDM_ERROR_NONE;
 141         tdm_private_loop private_loop;
 142         tdm_private_display private_display;
 143         tdm_private_loop dpy_private_loop;
 144
 145         _init_test();
 146
 147         memset(&private_loop, 0, sizeof(tdm_private_loop));
 148         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 149         memset(&private_display, 0, sizeof(tdm_private_display));
 150
 151         tdm_mutex_locked = 1;
 152         private_loop.dpy = &private_display;
 153         private_display.private_loop = &dpy_private_loop;
 154
 155         stub_getenv_name = "TDM_THREAD";
 156         stub_getenv_return_value = NULL;
 157
 158         error = tdm_thread_init(&private_loop);
 159
 160         ASSERT_EQ(error, expected_error);
 161 }
 162
 163 TEST(tdm_thread_init, success_getenv_return_0)
 164 {
 165         tdm_error error;
 166         tdm_error expected_error = TDM_ERROR_NONE;
 167         tdm_private_loop private_loop;
 168         tdm_private_display private_display;
 169         tdm_private_loop dpy_private_loop;
 170
 171         _init_test();
 172
 173         memset(&private_loop, 0, sizeof(tdm_private_loop));
 174         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 175         memset(&private_display, 0, sizeof(tdm_private_display));
 176
 177         tdm_mutex_locked = 1;
 178         private_loop.dpy = &private_display;
 179         private_display.private_loop = &dpy_private_loop;
 180
 181         stub_getenv_name = "TDM_THREAD";
 182         stub_getenv_return_value = "0";
 183
 184         error = tdm_thread_init(&private_loop);
 185
 186         ASSERT_EQ(error, expected_error);
 187 }
 188
 189 TEST(tdm_thread_init, error_calloc_return_null)
 190 {
 191         tdm_error error;
 192         tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
 193         tdm_private_loop private_loop;
 194         tdm_private_display private_display;
 195         tdm_private_loop dpy_private_loop;
 196
 197         _init_test();
 198
 199         memset(&private_loop, 0, sizeof(tdm_private_loop));
 200         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 201         memset(&private_display, 0, sizeof(tdm_private_display));
 202
 203         tdm_mutex_locked = 1;
 204         private_loop.dpy = &private_display;
 205         private_display.private_loop = &dpy_private_loop;
 206
 207         stub_getenv_name = "TDM_THREAD";
 208         stub_getenv_return_value = "1";
 209         CALLOC_ERROR = 1;
 210
 211         error = tdm_thread_init(&private_loop);
 212
 213         ASSERT_EQ(error, expected_error);
 214 }
 215
 216 TEST(tdm_thread_init, error_pipe_return_error)
 217 {
 218         tdm_error error;
 219         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 220         tdm_private_loop private_loop;
 221         tdm_private_display private_display;
 222         tdm_private_loop dpy_private_loop;
 223
 224         _init_test();
 225
 226         memset(&private_loop, 0, sizeof(tdm_private_loop));
 227         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 228         memset(&private_display, 0, sizeof(tdm_private_display));
 229
 230         tdm_mutex_locked = 1;
 231         private_loop.dpy = &private_display;
 232         private_display.private_loop = &dpy_private_loop;
 233
 234         stub_getenv_name = "TDM_THREAD";
 235         stub_getenv_return_value = "1";
 236
 237         stub_pipe_error = 1;
 238
 239         error = tdm_thread_init(&private_loop);
 240
 241         ASSERT_EQ(error, expected_error);
 242 }
 243
 244 TEST(tdm_thread_init, success_init)
 245 {
 246         tdm_error error;
 247         tdm_error expected_error = TDM_ERROR_NONE;
 248         tdm_private_loop private_loop;
 249         tdm_private_display private_display;
 250         tdm_private_loop dpy_private_loop;
 251
 252         _init_test();
 253
 254         memset(&private_loop, 0, sizeof(tdm_private_loop));
 255         memset(&dpy_private_loop, 0, sizeof(tdm_private_loop));
 256         memset(&private_display, 0, sizeof(tdm_private_display));
 257
 258         tdm_mutex_locked = 1;
 259         private_loop.dpy = &private_display;
 260         private_display.private_loop = &dpy_private_loop;
 261
 262         stub_getenv_name = "TDM_THREAD";
 263         stub_getenv_return_value = "1";
 264         stub_syscall_return_value = 10;
 265
 266         error = tdm_thread_init(&private_loop);
 267
 268         ASSERT_EQ(error, expected_error);
 269         ASSERT_TRUE(keep_private_thread != NULL);
 270         ASSERT_TRUE(keep_private_thread->private_loop == &private_loop);
 271         ASSERT_TRUE(private_loop.private_thread != NULL);
 272         ASSERT_EQ(private_loop.private_thread->display_tid, stub_syscall_return_value);
 273         free(private_loop.private_thread);
 274 }
 275
 276 /* tdm_thread_deinit */
 277
 278 TEST(tdm_thread_deinit, error_mutex_is_not_locked)
 279 {
 280         tdm_private_loop private_loop;
 281
 282         _init_test();
 283
 284         memset(&private_loop, 0, sizeof(tdm_private_loop));
 285
 286         private_loop.private_thread = calloc(1, sizeof(tdm_private_thread));
 287
 288         keep_private_thread = private_loop.private_thread;
 289
 290         tdm_thread_deinit(&private_loop);
 291
 292         ASSERT_TRUE(keep_private_thread != NULL);
 293 }
 294
 295 TEST(tdm_thread_deinit, error_private_thread_is_null)
 296 {
 297         tdm_private_loop private_loop;
 298
 299         _init_test();
 300
 301         memset(&private_loop, 0, sizeof(tdm_private_loop));
 302
 303         keep_private_thread = calloc(1, sizeof(tdm_private_thread));
 304
 305         tdm_thread_deinit(&private_loop);
 306
 307         ASSERT_TRUE(keep_private_thread != NULL);
 308 }
 309
 310 TEST(tdm_thread_deinit, success_deinit)
 311 {
 312         tdm_private_loop private_loop;
 313
 314         _init_test();
 315
 316         memset(&private_loop, 0, sizeof(tdm_private_loop));
 317
 318         tdm_mutex_locked = 1;
 319
 320         private_loop.private_thread = calloc(1, sizeof(tdm_private_thread));
 321
 322         private_loop.private_thread->pipe[0] = 1;
 323         private_loop.private_thread->pipe[1] = 2;
 324
 325         keep_private_thread = private_loop.private_thread;
 326
 327         tdm_thread_deinit(&private_loop);
 328
 329         ASSERT_TRUE(keep_private_thread == NULL);
 330         ASSERT_EQ(FREE_CALLED, 1);
 331         ASSERT_EQ(stub_unistd_closed_fds[1], 1);
 332         ASSERT_EQ(stub_unistd_closed_fds[2], 1);
 333         ASSERT_TRUE(private_loop.private_thread == NULL);
 334 }
 335
 336 /* tdm_thread_get_fd */
 337
 338 TEST(tdm_thread_get_fd, error_mutex_is_not_locked)
 339 {
 340         int ret;
 341         int expected_ret = TDM_ERROR_OPERATION_FAILED;
 342         tdm_private_loop private_loop;
 343         tdm_private_thread private_thread;
 344
 345         _init_test();
 346
 347         keep_private_thread = &private_thread;
 348
 349         ret = tdm_thread_get_fd(&private_loop);
 350
 351         ASSERT_EQ(ret, expected_ret);
 352 }
 353
 354 TEST(tdm_thread_get_fd, error_private_loop_is_null)
 355 {
 356         int ret;
 357         int expected_ret = -1;
 358
 359         _init_test();
 360
 361         tdm_mutex_locked = 1;
 362
 363         ret = tdm_thread_get_fd(NULL);
 364
 365         ASSERT_EQ(ret, expected_ret);
 366 }
 367
 368 TEST(tdm_thread_get_fd, error_private_thread_is_null)
 369 {
 370         int ret;
 371         int expected_ret = -1;
 372         tdm_private_loop private_loop;
 373
 374         _init_test();
 375
 376         memset(&private_loop, 0, sizeof(tdm_private_loop));
 377
 378         ret = tdm_thread_get_fd(&private_loop);
 379
 380         ASSERT_EQ(ret, expected_ret);
 381 }
 382
 383 TEST(tdm_thread_get_fd, success_get_fd)
 384 {
 385         int ret;
 386         int expected_ret;
 387         tdm_private_loop private_loop;
 388         tdm_private_thread private_thread;
 389
 390         _init_test();
 391
 392         memset(&private_loop, 0, sizeof(tdm_private_loop));
 393         private_loop.private_thread = &private_thread;
 394         private_thread.pipe[0] = 15;
 395
 396         expected_ret = private_thread.pipe[0];
 397
 398         ret = tdm_thread_get_fd(&private_loop);
 399
 400         ASSERT_EQ(ret, expected_ret);
 401 }
 402
 403 /* tdm_thread_send_cb */
 404
 405 TEST(tdm_thread_send_cb, error_mutex_is_not_locked)
 406 {
 407         tdm_error ret;
 408         tdm_error expected_ret = TDM_ERROR_OPERATION_FAILED;
 409         tdm_private_loop private_loop;
 410         tdm_thread_cb_base base;
 411         tdm_private_thread private_thread;
 412
 413         _init_test();
 414
 415         keep_private_thread = &private_thread;
 416
 417         ret = tdm_thread_send_cb(&private_loop, &base);
 418
 419         ASSERT_EQ(ret, expected_ret);
 420 }
 421
 422 TEST(tdm_thread_send_cb, error_base_is_null)
 423 {
 424         tdm_error ret;
 425         tdm_error expected_ret = TDM_ERROR_INVALID_PARAMETER;
 426         tdm_private_loop private_loop;
 427
 428         _init_test();
 429
 430         ret = tdm_thread_send_cb(&private_loop, NULL);
 431
 432         ASSERT_EQ(ret, expected_ret);
 433 }
 434
 435 TEST(tdm_thread_send_cb, error_private_loop_is_null)
 436 {
 437         tdm_error ret;
 438         tdm_error expected_ret = TDM_ERROR_INVALID_PARAMETER;
 439         tdm_thread_cb_base base;
 440
 441         _init_test();
 442
 443         ret = tdm_thread_send_cb(NULL, &base);
 444
 445         ASSERT_EQ(ret, expected_ret);
 446 }
 447
 448 TEST(tdm_thread_send_cb, error_private_thread_is_null)
 449 {
 450         tdm_error ret;
 451         tdm_error expected_ret = TDM_ERROR_INVALID_PARAMETER;
 452         tdm_private_loop private_loop;
 453         tdm_thread_cb_base base;
 454
 455         _init_test();
 456
 457         memset(&private_loop, 0, sizeof(tdm_private_loop));
 458
 459         ret = tdm_thread_send_cb(&private_loop, &base);
 460
 461         ASSERT_EQ(ret, expected_ret);
 462 }
 463
 464 TEST(tdm_thread_send_cb, error_write_error)
 465 {
 466         tdm_error ret;
 467         tdm_error expected_ret = TDM_ERROR_OPERATION_FAILED;
 468         tdm_private_loop private_loop;
 469         tdm_thread_cb_base base;
 470         tdm_private_thread private_thread;
 471
 472         _init_test();
 473
 474         memset(&private_loop, 0, sizeof(tdm_private_loop));
 475         private_loop.private_thread = &private_thread;
 476         base.length = 256;
 477
 478         stub_write_error = 1;
 479
 480         ret = tdm_thread_send_cb(&private_loop, &base);
 481
 482         ASSERT_EQ(ret, expected_ret);
 483 }
 484
 485 TEST(tdm_thread_send_cb, success_send_cb)
 486 {
 487         tdm_error ret;
 488         tdm_error expected_ret = TDM_ERROR_NONE;
 489         tdm_private_loop private_loop;
 490         tdm_thread_cb_base base;
 491         tdm_private_thread private_thread;
 492
 493         _init_test();
 494
 495         memset(&private_loop, 0, sizeof(tdm_private_loop));
 496         private_loop.private_thread = &private_thread;
 497         base.length = 256;
 498
 499         ret = tdm_thread_send_cb(&private_loop, &base);
 500
 501         ASSERT_EQ(ret, expected_ret);
 502 }
 503
 504 /* tdm_thread_handle_cb */
 505
 506 TEST(tdm_thread_handle_cb, error_private_loop_is_null)
 507 {
 508         tdm_error error;
 509         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 510
 511         error = tdm_thread_handle_cb(NULL);
 512
 513         ASSERT_EQ(error, expected_error);
 514 }
 515
 516 TEST(tdm_thread_handle_cb, error_private_thread_is_null)
 517 {
 518         tdm_error error;
 519         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 520         tdm_private_loop private_loop;
 521
 522         _init_test();
 523
 524         memset(&private_loop, 0, sizeof(tdm_private_loop));
 525
 526         error = tdm_thread_handle_cb(&private_loop);
 527
 528         ASSERT_EQ(error, expected_error);
 529 }
 530
 531 TEST(tdm_thread_handle_cb, success_read_0_bytes)
 532 {
 533         tdm_error error;
 534         tdm_error expected_error = TDM_ERROR_NONE;
 535         tdm_private_loop private_loop;
 536         tdm_private_thread private_thread;
 537
 538         _init_test();
 539
 540         memset(&private_loop, 0, sizeof(tdm_private_loop));
 541         private_loop.private_thread = &private_thread;
 542
 543         error = tdm_thread_handle_cb(&private_loop);
 544
 545         ASSERT_EQ(error, expected_error);
 546 }
 547
 548 TEST(tdm_thread_handle_cb, error_partial_reading)
 549 {
 550         tdm_error error;
 551         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 552         tdm_private_loop private_loop;
 553         tdm_private_thread private_thread;
 554         tdm_thread_cb_base base;
 555
 556         _init_test();
 557
 558         memset(&private_loop, 0, sizeof(tdm_private_loop));
 559         private_loop.private_thread = &private_thread;
 560
 561         stub_read_buf = (void *)&base;
 562         base.length = sizeof(tdm_thread_cb_base);
 563
 564         stub_read_returned_size = sizeof(tdm_thread_cb_base) - 1;
 565
 566         error = tdm_thread_handle_cb(&private_loop);
 567
 568         ASSERT_EQ(error, expected_error);
 569 }
 570
 571 TEST(tdm_thread_handle_cb, success_case_thread_cb_output_commit)
 572 {
 573         tdm_error error;
 574         tdm_error expected_error = TDM_ERROR_NONE;
 575         tdm_private_loop private_loop;
 576         tdm_private_thread private_thread;
 577         tdm_thread_cb_output_commit cb_output_commit;
 578
 579         _init_test();
 580
 581         memset(&private_loop, 0, sizeof(tdm_private_loop));
 582         private_loop.private_thread = &private_thread;
 583
 584         stub_read_buf = (void *)&cb_output_commit;
 585         cb_output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
 586         cb_output_commit.base.length = sizeof(tdm_thread_cb_output_commit);
 587
 588         stub_read_returned_size = sizeof(tdm_thread_cb_output_commit);
 589
 590         error = tdm_thread_handle_cb(&private_loop);
 591
 592         ASSERT_EQ(error, expected_error);
 593         ASSERT_EQ(stub_tdm_output_cb_commit_called, 1);
 594 }
 595
 596 TEST(tdm_thread_handle_cb, success_case_thread_cb_output_vblank)
 597 {
 598         tdm_error error;
 599         tdm_error expected_error = TDM_ERROR_NONE;
 600         tdm_private_loop private_loop;
 601         tdm_private_thread private_thread;
 602         tdm_thread_cb_output_vblank cb_output_vblank;
 603
 604         _init_test();
 605
 606         memset(&private_loop, 0, sizeof(tdm_private_loop));
 607         private_loop.private_thread = &private_thread;
 608
 609         stub_read_buf = (void *)&cb_output_vblank;
 610         cb_output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
 611         cb_output_vblank.base.length = sizeof(tdm_thread_cb_output_vblank);
 612
 613         stub_read_returned_size = sizeof(tdm_thread_cb_output_vblank);
 614
 615         error = tdm_thread_handle_cb(&private_loop);
 616
 617         ASSERT_EQ(error, expected_error);
 618         ASSERT_EQ(stub_tdm_output_cb_vblank_called, 1);
 619 }
 620
 621 TEST(tdm_thread_handle_cb, success_case_thread_cb_output_status)
 622 {
 623         tdm_error error;
 624         tdm_error expected_error = TDM_ERROR_NONE;
 625         tdm_private_loop private_loop;
 626         tdm_private_thread private_thread;
 627         tdm_thread_cb_output_status cb_output_status;
 628
 629         _init_test();
 630
 631         memset(&private_loop, 0, sizeof(tdm_private_loop));
 632         private_loop.private_thread = &private_thread;
 633
 634         stub_read_buf = (void *)&cb_output_status;
 635         cb_output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
 636         cb_output_status.base.length = sizeof(tdm_thread_cb_output_status);
 637
 638         stub_read_returned_size = sizeof(tdm_thread_cb_output_status);
 639
 640         error = tdm_thread_handle_cb(&private_loop);
 641
 642         ASSERT_EQ(error, expected_error);
 643         ASSERT_EQ(stub_tdm_output_cb_status_called, 1);
 644 }
 645
 646 TEST(tdm_thread_handle_cb, success_case_thread_cb_output_dpms)
 647 {
 648         tdm_error error;
 649         tdm_error expected_error = TDM_ERROR_NONE;
 650         tdm_private_loop private_loop;
 651         tdm_private_thread private_thread;
 652         tdm_thread_cb_output_dpms cb_output_dpms;
 653
 654         _init_test();
 655
 656         memset(&private_loop, 0, sizeof(tdm_private_loop));
 657         private_loop.private_thread = &private_thread;
 658
 659         stub_read_buf = (void *)&cb_output_dpms;
 660         cb_output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS;
 661         cb_output_dpms.base.length = sizeof(tdm_thread_cb_output_dpms);
 662
 663         stub_read_returned_size = sizeof(tdm_thread_cb_output_dpms);
 664
 665         error = tdm_thread_handle_cb(&private_loop);
 666
 667         ASSERT_EQ(error, expected_error);
 668         ASSERT_EQ(stub_tdm_output_cb_dpms_called, 1);
 669 }
 670
 671 TEST(tdm_thread_handle_cb, success_case_thread_cb_pp_done)
 672 {
 673         tdm_error error;
 674         tdm_error expected_error = TDM_ERROR_NONE;
 675         tdm_private_loop private_loop;
 676         tdm_private_thread private_thread;
 677         tdm_thread_cb_pp_done cb_pp_done;
 678
 679         _init_test();
 680
 681         memset(&private_loop, 0, sizeof(tdm_private_loop));
 682         private_loop.private_thread = &private_thread;
 683
 684         stub_read_buf = (void *)&cb_pp_done;
 685         cb_pp_done.base.type = TDM_THREAD_CB_PP_DONE;
 686         cb_pp_done.base.length = sizeof(tdm_thread_cb_pp_done);
 687
 688         stub_read_returned_size = sizeof(tdm_thread_cb_pp_done);
 689
 690         error = tdm_thread_handle_cb(&private_loop);
 691
 692         ASSERT_EQ(error, expected_error);
 693         ASSERT_EQ(stub_tdm_pp_cb_done_called, 1);
 694 }
 695
 696 TEST(tdm_thread_handle_cb, success_case_thread_cb_capture_done)
 697 {
 698         tdm_error error;
 699         tdm_error expected_error = TDM_ERROR_NONE;
 700         tdm_private_loop private_loop;
 701         tdm_private_thread private_thread;
 702         tdm_thread_cb_capture_done cb_capture_done;
 703
 704         _init_test();
 705
 706         memset(&private_loop, 0, sizeof(tdm_private_loop));
 707         private_loop.private_thread = &private_thread;
 708
 709         stub_read_buf = (void *)&cb_capture_done;
 710         cb_capture_done.base.type = TDM_THREAD_CB_CAPTURE_DONE;
 711         cb_capture_done.base.length = sizeof(tdm_thread_cb_capture_done);
 712
 713         stub_read_returned_size = sizeof(tdm_thread_cb_capture_done);
 714
 715         error = tdm_thread_handle_cb(&private_loop);
 716
 717         ASSERT_EQ(error, expected_error);
 718         ASSERT_EQ(stub_tdm_capture_cb_done_called, 1);
 719 }
 720
 721 TEST(tdm_thread_handle_cb, success_case_thread_cb_vblank_sw)
 722 {
 723         tdm_error error;
 724         tdm_error expected_error = TDM_ERROR_NONE;
 725         tdm_private_loop private_loop;
 726         tdm_private_thread private_thread;
 727         tdm_thread_cb_vblank_sw cb_vblank_sw;
 728
 729         _init_test();
 730
 731         memset(&private_loop, 0, sizeof(tdm_private_loop));
 732         private_loop.private_thread = &private_thread;
 733
 734         stub_read_buf = (void *)&cb_vblank_sw;
 735         cb_vblank_sw.base.type = TDM_THREAD_CB_VBLANK_SW;
 736         cb_vblank_sw.base.length = sizeof(tdm_thread_cb_vblank_sw);
 737
 738         stub_read_returned_size = sizeof(tdm_thread_cb_vblank_sw);
 739
 740         error = tdm_thread_handle_cb(&private_loop);
 741
 742         ASSERT_EQ(error, expected_error);
 743         ASSERT_EQ(stub_tdm_vblank_cb_vblank_SW_called, 1);
 744 }
 745
 746 /* tdm_thread_in_display_thread */
 747
 748 TEST(tdm_thread_in_display_thread, success_keep_private_thread_is_null)
 749 {
 750         int ret;
 751         int expected_ret = 1;
 752         pid_t tid;
 753
 754         _init_test();
 755
 756         ret = tdm_thread_in_display_thread(tid);
 757
 758         ASSERT_EQ(ret, expected_ret);
 759 }
 760
 761 TEST(tdm_thread_in_display_thread, success_in_display_thread)
 762 {
 763         int ret;
 764         int expected_ret = 1;
 765         pid_t tid = 20;
 766         static tdm_private_thread private_thread;
 767
 768         _init_test();
 769
 770         private_thread.display_tid = tid;
 771         keep_private_thread = &private_thread;
 772
 773         ret = tdm_thread_in_display_thread(tid);
 774
 775         ASSERT_EQ(ret, expected_ret);
 776 }
 777
 778 TEST(tdm_thread_in_display_thread, success_no_in_display_thread)
 779 {
 780         int ret;
 781         int expected_ret = 0;
 782         pid_t tid = 20;
 783         static tdm_private_thread private_thread;
 784
 785         _init_test();
 786
 787         private_thread.display_tid = tid + 1;
 788         keep_private_thread = &private_thread;
 789
 790         ret = tdm_thread_in_display_thread(tid);
 791
 792         ASSERT_EQ(ret, expected_ret);
 793 }
 794
 795 /* tdm_thread_is_running */
 796
 797 TEST(tdm_thread_is_running, success_no_is_running)
 798 {
 799         int ret;
 800         int expected_ret = 0;
 801
 802         _init_test();
 803
 804         ret = tdm_thread_is_running();
 805
 806         ASSERT_EQ(ret, expected_ret);
 807 }
 808
 809 TEST(tdm_thread_is_running, success_is_running)
 810 {
 811         int ret;
 812         int expected_ret = 1;
 813         static tdm_private_thread private_thread;
 814
 815         _init_test();
 816
 817         keep_private_thread = &private_thread;
 818
 819         ret = tdm_thread_is_running();
 820
 821         ASSERT_EQ(ret, expected_ret);
 822 }