utests/src/ut_tdm_pp.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_tdm_helper.h"
  35 #include "stub_backend.h"
  36 #include "stub_tdm_buffer.h"
  37 #include "stub_unistd.h"
  38 #include "stub_tdm_thread.h"
  39 #include "stub_tdm_helper.h"
  40 #include "stub_tdm_buffer.h"
  41
  42 #include "tdm_pp.c"
  43
  44 //local stubs for callbeck functions
  45 static int stub_pp_destroy_is_called = 0;
  46 static int stub_tdm_pp_done_handler_is_called;
  47
  48 static void stub_pp_destroy(tdm_pp *pp)
  49 {
  50         (void)pp;
  51
  52         stub_pp_destroy_is_called = 1;
  53 }
  54
  55 static int stub_pp_set_done_handler_is_called = 0;
  56 static int stub_pp_set_done_handler_error = 0;
  57 static tdm_error stub_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func,
  58                                                                  void *user_data)
  59 {
  60         (void)pp;
  61         (void)func;
  62         (void)user_data;
  63
  64         if (stub_pp_set_done_handler_error)
  65                 return TDM_ERROR_OPERATION_FAILED;
  66
  67         stub_pp_set_done_handler_is_called = 1;
  68         return TDM_ERROR_NONE;
  69 }
  70
  71 static int stub_display_create_pp_is_called = 0;
  72 static int stub_display_create_pp_error = 0;
  73 static tdm_pp *stub_display_create_pp(tdm_backend_data *bdata, tdm_error *error)
  74 {
  75         (void)bdata;
  76
  77         if (stub_display_create_pp_error) {
  78                 if (error)
  79                         *error = TDM_ERROR_OPERATION_FAILED;
  80                 return NULL;
  81         }
  82         stub_display_create_pp_is_called = 1;
  83         static int backend_pp;
  84         return &backend_pp;
  85 }
  86
  87 static int stub_pp_attach_is_called = 0;
  88 static int stub_pp_attach_error = 0;
  89 tdm_error stub_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
  90 {
  91         (void)pp;
  92         (void)src;
  93         (void)dst;
  94
  95         if (stub_pp_attach_error)
  96                 return TDM_ERROR_OPERATION_FAILED;
  97
  98         stub_pp_attach_is_called = 1;
  99         return TDM_ERROR_NONE;
 100 }
 101
 102 static void stub_tdm_pp_done_handler(tdm_pp *pp, tbm_surface_h src,
 103                                                                         tbm_surface_h dst, void *user_data)
 104 {
 105         (void)pp;
 106         (void)src;
 107         (void)dst;
 108         (void)user_data;
 109
 110         stub_tdm_pp_done_handler_is_called = 1;
 111 }
 112
 113 static void _init_test()
 114 {
 115         stub_tdm_buffer_init();
 116         stub_tdm_helper_init();
 117         stub_tdm_buffer_init();
 118         stub_tdm_thread_init();
 119         stub_unistd_init();
 120         stub_pthread_init();
 121         stub_backend_init();
 122         stub_tbm_init();
 123         stub_stdlib_init();
 124         stub_pp_destroy_is_called = 0;
 125         stub_pp_set_done_handler_is_called = 0;
 126         stub_pp_set_done_handler_error = 0;
 127         stub_display_create_pp_is_called = 0;
 128         stub_pp_attach_is_called = 0;
 129         stub_pp_attach_error = 0;
 130         stub_tdm_pp_done_handler_is_called = 0;
 131         stub_display_create_pp_error = 0;
 132         tdm_debug_dump = TDM_DUMP_FLAG_PP;
 133         tdm_debug_module = TDM_DEBUG_BUFFER;
 134 }
 135
 136 /* UNIT TESTS */
 137
 138 /* tdm_pp_commit */
 139
 140 TEST(tdm_pp_commit, work_flow_success_3)
 141 {
 142         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 143         tdm_private_pp pp;
 144         tdm_private_display private_display;
 145         tdm_pp_private_buffer b_1, b_2;
 146
 147         _init_test();
 148
 149         pp.private_display = &private_display;
 150         private_display.func_pp.pp_commit = pp_commit;
 151
 152         LIST_INITHEAD(&pp.pending_buffer_list);
 153         LIST_INITHEAD(&pp.buffer_list);
 154
 155         LIST_ADD(&b_1.link, &pp.pending_buffer_list);
 156         LIST_ADD(&b_2.link, &pp.pending_buffer_list);
 157
 158
 159         error = tdm_pp_commit(&pp);
 160
 161         ASSERT_EQ(error, TDM_ERROR_NONE);
 162         ASSERT_EQ(LIST_LENGTH(&pp.buffer_list), 2);
 163 }
 164
 165 //TEST(tdm_pp_commit, work_flow_success_2)
 166 //{
 167 //      tdm_error error = TDM_ERROR_NONE;
 168 //      tdm_error not_expected_error = TDM_ERROR_NONE;
 169 //      tdm_private_pp pp;
 170 //      tdm_private_display private_display;
 171 //      tdm_pp_private_buffer b_1, b_2;
 172 //
 173 //      _init_test();
 174 //
 175 //      pp.private_display = &private_display;
 176 //      private_display.func_pp.pp_commit = pp_commit;
 177 //      PP_COMMIT_ERROR = 1;
 178 //
 179 //      LIST_INITHEAD(&pp.pending_buffer_list);
 180 //      LIST_INITHEAD(&pp.buffer_list);
 181 //
 182 //      LIST_ADD(&b_1.link, &pp.pending_buffer_list);
 183 //      LIST_ADD(&b_2.link, &pp.pending_buffer_list);
 184 //
 185 //      error = tdm_pp_commit(&pp);
 186 //
 187 //      ASSERT_NE(error, not_expected_error);
 188 //      ASSERT_EQ(LIST_LENGTH(&pp.buffer_list), 0);
 189 //      ASSERT_EQ(stub_tdm_buffer_remove_release_handler_internal_count, 4);
 190 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 4);
 191 //}
 192
 193 TEST(tdm_pp_commit, work_flow_success_1)
 194 {
 195         tdm_error error = TDM_ERROR_NONE;
 196         tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
 197         tdm_private_pp pp;
 198         tdm_private_display private_display;
 199
 200         _init_test();
 201
 202         pp.private_display = &private_display;
 203         private_display.func_pp.pp_commit = NULL;
 204
 205         error = tdm_pp_commit(&pp);
 206
 207         ASSERT_EQ(error, expected_error);
 208 }
 209
 210 TEST(tdm_pp_commit, null_ptr_fail_1)
 211 {
 212         tdm_error error = TDM_ERROR_NONE;
 213         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 214
 215         _init_test();
 216
 217         error = tdm_pp_commit(NULL);
 218
 219         ASSERT_EQ(error, expected_error);
 220 }
 221
 222 /* tdm_pp_attach */
 223
 224 TEST(tdm_pp_attach, error_pp_attach)
 225 {
 226         tdm_error error = TDM_ERROR_NONE;
 227         tdm_private_pp private_pp;
 228         tdm_private_display private_display;
 229         tdm_backend_module module;
 230         struct _tbm_surface src;
 231         struct _tbm_surface dst;
 232
 233         _init_test();
 234
 235         LIST_INITHEAD(&private_display.pp_list);
 236         LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
 237         private_display.module_data = &module;
 238         private_display.func_pp.pp_attach = stub_pp_attach;
 239         private_display.caps_pp.max_attach_count = 3;
 240         module.abi_version  = 0x00010002;
 241
 242         private_pp.private_display = &private_display;
 243         LIST_INITHEAD(&private_pp.pending_buffer_list);
 244         LIST_INITHEAD(&private_pp.buffer_list);
 245
 246         stub_pp_attach_error = 1;
 247
 248         error = tdm_pp_attach(&private_pp, &src, &dst);
 249
 250         ASSERT_NE(TDM_ERROR_NONE, error);
 251 }
 252
 253 TEST(tdm_pp_attach, error_calloc_error)
 254 {
 255         tdm_error error = TDM_ERROR_NONE;
 256         tdm_private_pp private_pp;
 257         tdm_private_display private_display;
 258         tdm_backend_module module;
 259         struct _tbm_surface src;
 260         struct _tbm_surface dst;
 261
 262         _init_test();
 263
 264         LIST_INITHEAD(&private_display.pp_list);
 265         LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
 266         private_display.module_data = &module;
 267         private_display.func_pp.pp_attach = stub_pp_attach;
 268         private_display.caps_pp.max_attach_count = 3;
 269         module.abi_version  = 0x00010002;
 270
 271         private_pp.private_display = &private_display;
 272         LIST_INITHEAD(&private_pp.pending_buffer_list);
 273         LIST_INITHEAD(&private_pp.buffer_list);
 274
 275         CALLOC_ERROR = 1;
 276
 277         error = tdm_pp_attach(&private_pp, &src, &dst);
 278
 279         ASSERT_EQ(TDM_ERROR_OUT_OF_MEMORY, error);
 280 }
 281
 282 TEST(tdm_pp_attach, error_bad_request)
 283 {
 284         tdm_error error = TDM_ERROR_NONE;
 285         tdm_private_pp private_pp;
 286         tdm_private_display private_display;
 287         tdm_backend_module module;
 288         struct _tbm_surface src;
 289         struct _tbm_surface dst;
 290         tdm_pp_private_buffer pp_buffer_1;
 291         tdm_pp_private_buffer pp_buffer_2;
 292
 293         _init_test();
 294
 295         LIST_INITHEAD(&private_display.pp_list);
 296         LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
 297         private_display.module_data = &module;
 298         private_display.func_pp.pp_attach = stub_pp_attach;
 299         private_display.caps_pp.max_attach_count = 1;
 300         module.abi_version  = 0x00010002;
 301
 302         private_pp.private_display = &private_display;
 303         LIST_INITHEAD(&private_pp.pending_buffer_list);
 304         LIST_INITHEAD(&private_pp.buffer_list);
 305
 306         LIST_ADD(&pp_buffer_1.link, &private_pp.pending_buffer_list);
 307         LIST_ADD(&pp_buffer_2.link, &private_pp.pending_buffer_list);
 308
 309         error = tdm_pp_attach(&private_pp, &src, &dst);
 310
 311         ASSERT_EQ(TDM_ERROR_BAD_REQUEST, error);
 312 }
 313
 314 TEST(tdm_pp_attach, error_pp_attach_is_not_implemented)
 315 {
 316         tdm_error error = TDM_ERROR_NONE;
 317         tdm_private_pp private_pp;
 318         tdm_private_display private_display;
 319         struct _tbm_surface src;
 320         struct _tbm_surface dst;
 321
 322         _init_test();
 323
 324         private_display.func_pp.pp_attach = NULL;
 325
 326         private_pp.private_display = &private_display;
 327
 328         error = tdm_pp_attach(&private_pp, &src, &dst);
 329
 330         ASSERT_EQ(TDM_ERROR_NOT_IMPLEMENTED, error);
 331 }
 332
 333 TEST(tdm_pp_attach, work_flow_success_1)
 334 {
 335         tdm_error error = TDM_ERROR_NONE;
 336         tdm_private_pp private_pp;
 337         tdm_private_display private_display;
 338         tdm_backend_module module;
 339         struct _tbm_surface src;
 340         struct _tbm_surface dst;
 341
 342         _init_test();
 343
 344         LIST_INITHEAD(&private_display.pp_list);
 345         LIST_ADDTAIL(&private_pp.link, &private_display.pp_list);
 346         private_display.module_data = &module;
 347         private_display.func_pp.pp_attach = stub_pp_attach;
 348         private_display.caps_pp.max_attach_count = 3;
 349         module.abi_version  = 0x00010002;
 350
 351         private_pp.private_display = &private_display;
 352         LIST_INITHEAD(&private_pp.pending_buffer_list);
 353         LIST_INITHEAD(&private_pp.buffer_list);
 354         tdm_debug_dump = TDM_DUMP_FLAG_PP;
 355         tdm_debug_module = TDM_DEBUG_BUFFER;
 356
 357         error = tdm_pp_attach(&private_pp, &src, &dst);
 358
 359         ASSERT_EQ(TDM_ERROR_NONE, error);
 360         int num_of_pp_buff = LIST_LENGTH(&private_pp.pending_buffer_list);
 361         ASSERT_EQ(1, num_of_pp_buff);
 362 }
 363
 364 TEST(tdm_pp_attach, null_ptr_fail_3)
 365 {
 366         tdm_error error = TDM_ERROR_NONE;
 367         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 368         tdm_private_pp pp;
 369         tdm_private_display private_display;
 370         struct _tbm_surface src;
 371
 372         _init_test();
 373
 374         pp.private_display = &private_display;
 375
 376         error = tdm_pp_attach(&pp, &src, NULL);
 377
 378         ASSERT_EQ(error, expected_error);
 379 }
 380
 381 TEST(tdm_pp_attach, null_ptr_fail_2)
 382 {
 383         tdm_error error = TDM_ERROR_NONE;
 384         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 385         tdm_private_pp pp;
 386         tdm_private_display private_display;
 387         struct _tbm_surface dst;
 388
 389         _init_test();
 390
 391         pp.private_display = &private_display;
 392
 393         error = tdm_pp_attach(&pp, NULL, &dst);
 394
 395         ASSERT_EQ(error, expected_error);
 396 }
 397
 398 TEST(tdm_pp_attach, null_ptr_fail_1)
 399 {
 400         tdm_error error = TDM_ERROR_NONE;
 401         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 402         struct _tbm_surface src;
 403         struct _tbm_surface dst;
 404
 405         _init_test();
 406
 407         error = tdm_pp_attach(NULL, &src, &dst);
 408
 409         ASSERT_EQ(error, expected_error);
 410 }
 411
 412 /* tdm_pp_set_info */
 413
 414 TEST(tdm_pp_set_info, work_flow_success_3)
 415 {
 416         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 417         tdm_error expected_error = TDM_ERROR_NONE;
 418         tdm_info_pp info;
 419         tdm_private_pp pp;
 420         tdm_private_display private_display;
 421
 422         _init_test();
 423
 424         pp.private_display = &private_display;
 425         private_display.func_pp.pp_set_info = pp_set_info;
 426
 427         error = tdm_pp_set_info(&pp, &info);
 428
 429         ASSERT_EQ(error, expected_error);
 430 }
 431
 432 TEST(tdm_pp_set_info, work_flow_success_2)
 433 {
 434         tdm_error error = TDM_ERROR_NONE;
 435         tdm_error not_expected_error = TDM_ERROR_NONE;
 436         tdm_info_pp info;
 437         tdm_private_pp pp;
 438         tdm_private_display private_display;
 439
 440         _init_test();
 441
 442         pp.private_display = &private_display;
 443         private_display.func_pp.pp_set_info = pp_set_info;
 444         PP_SET_INFO_ERROR = 1;
 445
 446         error = tdm_pp_set_info(&pp, &info);
 447
 448         ASSERT_NE(error, not_expected_error);
 449 }
 450
 451 TEST(tdm_pp_set_info, work_flow_success_1)
 452 {
 453         tdm_error error = TDM_ERROR_NONE;
 454         tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
 455         tdm_info_pp info;
 456         tdm_private_pp pp;
 457         tdm_private_display private_display;
 458
 459         _init_test();
 460
 461         pp.private_display = &private_display;
 462         private_display.func_pp.pp_set_info = NULL;
 463
 464         error = tdm_pp_set_info(&pp, &info);
 465
 466         ASSERT_EQ(error, expected_error);
 467 }
 468
 469 TEST(tdm_pp_set_info, null_ptr_fail_2)
 470 {
 471         tdm_error error = TDM_ERROR_NONE;
 472         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 473         tdm_private_pp pp;
 474         tdm_private_display private_display;
 475
 476         _init_test();
 477
 478         pp.private_display = &private_display;
 479
 480         error = tdm_pp_set_info(&pp, NULL);
 481
 482         ASSERT_EQ(error, expected_error);
 483 }
 484
 485 TEST(tdm_pp_set_info, null_ptr_fail_1)
 486 {
 487         tdm_error error = TDM_ERROR_NONE;
 488         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 489         tdm_info_pp info;
 490
 491         _init_test();
 492
 493         error = tdm_pp_set_info(NULL, &info);
 494
 495         ASSERT_EQ(error, expected_error);
 496 }
 497
 498 TEST(tdm_pp_set_done_handler, work_flow_success_1)
 499 {
 500         tdm_error error;
 501         tdm_private_pp pp;
 502         tdm_private_display private_display;
 503         int user_data = 0;
 504
 505         _init_test();
 506
 507         pp.private_display = &private_display;
 508         private_display.func_pp.pp_set_info = NULL;
 509
 510         error = tdm_pp_set_done_handler(&pp, stub_tdm_pp_done_handler, &user_data);
 511         ASSERT_EQ(TDM_ERROR_NONE, error);
 512         ASSERT_EQ(stub_tdm_pp_done_handler, pp.done_func);
 513         ASSERT_EQ(&user_data, pp.done_user_data);
 514
 515         error = tdm_pp_set_done_handler(&pp, stub_tdm_pp_done_handler, NULL);
 516         ASSERT_EQ(TDM_ERROR_NONE, error);
 517         ASSERT_EQ(TDM_ERROR_NONE, error);
 518         ASSERT_EQ(stub_tdm_pp_done_handler, pp.done_func);
 519         ASSERT_EQ(0, pp.done_user_data);
 520 }
 521
 522 TEST(tdm_pp_set_done_handler, work_flow_error_1___NULL)
 523 {
 524         tdm_error error;
 525         tdm_private_pp pp;
 526         tdm_private_display private_display;
 527
 528         _init_test();
 529
 530         pp.private_display = &private_display;
 531         private_display.func_pp.pp_set_info = NULL;
 532
 533         error = tdm_pp_set_done_handler(&pp, NULL, NULL);
 534         ASSERT_NE(TDM_ERROR_NONE, error);
 535
 536         error = tdm_pp_set_done_handler(NULL, stub_tdm_pp_done_handler, NULL);
 537         ASSERT_NE(TDM_ERROR_NONE, error);
 538 }
 539
 540 TEST(tdm_pp_destroy, work_flow_success_1)
 541 {
 542         tdm_private_pp *private_pp;
 543         tdm_pp_private_buffer *pp_buffer1;
 544         tdm_pp_private_buffer *pp_buffer2;
 545         tdm_private_display private_display;
 546         private_pp = (tdm_private_pp *)calloc(1, sizeof(tdm_private_pp));
 547         pp_buffer1 = (tdm_pp_private_buffer *)calloc(1, sizeof *pp_buffer1);
 548         pp_buffer2 = (tdm_pp_private_buffer *)calloc(1, sizeof *pp_buffer2);
 549
 550         private_display.func_pp.pp_destroy = stub_pp_destroy;
 551         _init_test();
 552
 553         LIST_INITHEAD(&private_display.pp_list);
 554         private_display.func_pp.pp_destroy = stub_pp_destroy;
 555         LIST_ADDTAIL(&private_pp->link, &private_display.pp_list);
 556
 557
 558         private_pp->private_display = &private_display;
 559         LIST_INITHEAD(&private_pp->pending_buffer_list);
 560         LIST_ADDTAIL(&pp_buffer1->link, &private_pp->pending_buffer_list);
 561
 562         LIST_INITHEAD(&private_pp->buffer_list);
 563         LIST_ADDTAIL(&pp_buffer2->link, &private_pp->buffer_list);
 564
 565         tdm_pp_destroy(private_pp);
 566
 567         ASSERT_EQ(4, stub_tdm_buffer_unref_backend_count);
 568         ASSERT_EQ(3, stub_free_call_count);
 569         ASSERT_TRUE(stub_pp_destroy_is_called);
 570 }
 571
 572 TEST(tdm_pp_destroy, work_flow_error_1___NULL)
 573 {
 574         tdm_pp_destroy(NULL);
 575 }
 576
 577 /* tdm_pp_create_internal() */
 578
 579 TEST(tdm_pp_create_internal, work_flow_success_1)
 580 {
 581         tdm_error error;
 582         tdm_private_display private_display;
 583         tdm_private_pp *private_pp_ret;
 584         tdm_private_pp private_pp;
 585
 586         _init_test();
 587
 588         stub_tdm_helper_get_time_ret_val = 1.1;
 589
 590         private_display.func_pp.pp_destroy = stub_pp_destroy;
 591         private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
 592         private_display.func_display.display_create_pp = stub_display_create_pp;
 593         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 594         LIST_INITHEAD(&private_display.pp_list);
 595
 596         private_pp.stamp = stub_tdm_helper_get_time_ret_val;
 597
 598         LIST_ADD(&private_pp.link, &private_display.pp_list);
 599
 600         private_pp_ret = tdm_pp_create_internal(&private_display, &error);
 601
 602         ASSERT_EQ(TDM_ERROR_NONE, error);
 603         ASSERT_TRUE(stub_pp_set_done_handler_is_called);
 604         ASSERT_TRUE(stub_display_create_pp_is_called);
 605         ASSERT_TRUE(private_pp_ret != NULL);
 606 }
 607
 608 TEST(tdm_pp_create_internal, work_flow_error_1___TDM_DISPLAY_CAPABILITY_PP_is_not_set)
 609 {
 610         tdm_error error;
 611         tdm_private_display private_display;
 612         tdm_private_pp *private_pp;
 613
 614         _init_test();
 615
 616         private_display.func_pp.pp_destroy = stub_pp_destroy;
 617         private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
 618         private_display.func_display.display_create_pp = stub_display_create_pp;
 619         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 620         LIST_INITHEAD(&private_display.pp_list);
 621
 622
 623         private_display.capabilities = (tdm_display_capability)0;
 624
 625         private_pp = tdm_pp_create_internal(&private_display, &error);
 626         ASSERT_NE(TDM_ERROR_NONE, error);
 627         ASSERT_TRUE(private_pp == NULL);
 628 }
 629
 630 TEST(tdm_pp_create_internal, work_flow_error_1___calloc_error)
 631 {
 632         tdm_error error;
 633         tdm_private_display private_display;
 634         tdm_private_pp *private_pp;
 635
 636         _init_test();
 637
 638         private_display.func_pp.pp_destroy = stub_pp_destroy;
 639         private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
 640         private_display.func_display.display_create_pp = stub_display_create_pp;
 641         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 642         LIST_INITHEAD(&private_display.pp_list);
 643
 644         CALLOC_ERROR = 1;
 645
 646         private_pp = tdm_pp_create_internal(&private_display, &error);
 647         ASSERT_NE(TDM_ERROR_NONE, error);
 648         ASSERT_TRUE(private_pp == NULL);
 649 }
 650
 651 TEST(tdm_pp_create_internal, work_flow_error_1___create_pp_error)
 652 {
 653         tdm_error error;
 654         tdm_private_display private_display;
 655         tdm_private_pp *private_pp;
 656
 657         _init_test();
 658
 659         stub_display_create_pp_error = 1;
 660         private_display.func_display.display_create_pp = stub_display_create_pp;
 661         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 662
 663         private_pp = tdm_pp_create_internal(&private_display, &error);
 664         ASSERT_NE(TDM_ERROR_NONE, error);
 665         ASSERT_TRUE(private_pp == NULL);
 666 }
 667
 668 TEST(tdm_pp_create_internal, work_flow_error_1___set_done_handler_error)
 669 {
 670         tdm_error error;
 671         tdm_private_display private_display;
 672         tdm_private_pp *private_pp;
 673
 674         _init_test();
 675
 676         stub_pp_set_done_handler_error = 1;
 677
 678         private_display.func_pp.pp_destroy = stub_pp_destroy;
 679         private_display.func_pp.pp_set_done_handler = stub_pp_set_done_handler;
 680         private_display.func_display.display_create_pp = stub_display_create_pp;
 681         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 682         LIST_INITHEAD(&private_display.pp_list);
 683
 684         private_pp = tdm_pp_create_internal(&private_display, &error);
 685         ASSERT_NE(TDM_ERROR_NONE, error);
 686         ASSERT_TRUE(private_pp == NULL);
 687 }
 688
 689 /* tdm_pp_cb_done() */
 690
 691 TEST(tdm_pp_cb_done, success_not_in_display_thread)
 692 {
 693         tdm_private_pp private_pp;
 694         struct _tbm_surface src, dst;
 695         tdm_thread_cb_pp_done *pp_done;
 696
 697         _init_test();
 698
 699         stub_syscall_return_value = 100;
 700         private_pp.owner_tid = stub_syscall_return_value + 1;
 701         private_pp.stamp = 200.05;
 702
 703         tdm_pp_cb_done(&private_pp, &src, &dst, &private_pp);
 704
 705         pp_done = (tdm_thread_cb_pp_done *)stub_tdm_thread_send_cb_buff;
 706
 707         ASSERT_EQ(pp_done->base.type, TDM_THREAD_CB_PP_DONE);
 708         ASSERT_EQ(pp_done->base.length, sizeof * pp_done);
 709         ASSERT_DOUBLE_EQ(pp_done->pp_stamp, private_pp.stamp);
 710         ASSERT_TRUE(pp_done->src == &src);
 711         ASSERT_TRUE(pp_done->dst == &dst);
 712         ASSERT_TRUE(pp_done->user_data == &private_pp);
 713 }
 714
 715 //TEST(tdm_pp_cb_done, success_in_display_thread)
 716 //{
 717 //      tdm_private_pp private_pp;
 718 //      struct _tbm_surface src, dst;
 719 //      tdm_pp_private_buffer *pp_buffer_1;
 720 //      tdm_pp_private_buffer *pp_buffer_2;
 721 //
 722 //      _init_test();
 723 //
 724 //      stub_syscall_return_value = 100;
 725 //      stub_syscall_reset = 1;
 726 //      private_pp.owner_tid = stub_syscall_return_value;
 727 //
 728 //      pp_buffer_1 = (tdm_pp_private_buffer *)calloc(1, sizeof (tdm_pp_private_buffer));
 729 //      pp_buffer_2 = (tdm_pp_private_buffer *)calloc(1, sizeof (tdm_pp_private_buffer));
 730 //      pp_buffer_1->src = &src;
 731 //      pp_buffer_1->dst = &dst;
 732 //      private_pp.done_func = stub_tdm_pp_done_handler;
 733 //
 734 //      LIST_INITHEAD(&private_pp.buffer_list);
 735 //      LIST_ADD(&pp_buffer_1->link, &private_pp.buffer_list);
 736 //      LIST_ADD(&pp_buffer_2->link, &private_pp.buffer_list);
 737 //
 738 //      tdm_pp_cb_done(&private_pp, &src, &dst, &private_pp);
 739 //
 740 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
 741 //      ASSERT_EQ(FREE_CALLED, 1);
 742 //      ASSERT_EQ(stub_tdm_pp_done_handler_is_called, 1);
 743 //      free(pp_buffer_2);
 744 //}
 745
 746 /* tdm_pp_find_stamp() */
 747
 748 TEST(tdm_pp_find_stamp, success_pp_list_is_empty)
 749 {
 750         tdm_private_pp *private_pp_ret;
 751         tdm_private_display private_display;
 752
 753         _init_test();
 754
 755         LIST_INITHEAD(&private_display.pp_list);
 756
 757         private_pp_ret = tdm_pp_find_stamp(&private_display, 0.5);
 758
 759         ASSERT_TRUE(private_pp_ret == NULL);
 760 }
 761
 762 TEST(tdm_pp_find_stamp, success_pp_find_stamp)
 763 {
 764         tdm_private_pp *private_pp_ret;
 765         tdm_private_display private_display;
 766         tdm_private_pp private_pp;
 767         double stamp = 12.25;
 768
 769         _init_test();
 770
 771         LIST_INITHEAD(&private_display.pp_list);
 772         LIST_ADD(&private_pp.link, &private_display.pp_list);
 773
 774         private_pp.stamp = stamp;
 775
 776         private_pp_ret = tdm_pp_find_stamp(&private_display, stamp);
 777
 778         ASSERT_TRUE(private_pp_ret == &private_pp);
 779 }