utests/src/ut_tdm_capture.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_backend.h"
  35 #include "stub_unistd.h"
  36 #include "stub_tdm_thread.h"
  37 #include "stub_tdm_buffer.h"
  38 #include "stub_tdm_helper.h"
  39
  40 #include "tdm_capture.c"
  41
  42 //local stubs for callbeck functions
  43 static int stub_tdm_capture_done_handler_called;
  44 static void stub_tdm_capture_done_handler(tdm_capture *capture,
  45                                                                                   tbm_surface_h buffer, void *user_data)
  46 {
  47         stub_tdm_capture_done_handler_called = 1;
  48 }
  49
  50 /* UNIT TESTS */
  51
  52 static void _init_test()
  53 {
  54         stub_tdm_helper_init();
  55         stub_tdm_buffer_init();
  56         stub_tdm_thread_init();
  57         stub_unistd_init();
  58         stub_pthread_init();
  59         stub_backend_init();
  60         stub_tbm_init();
  61         stub_stdlib_init();
  62         tdm_debug_dump = TDM_DUMP_FLAG_CAPTURE;
  63         tdm_debug_module = TDM_DEBUG_BUFFER;
  64         stub_tdm_capture_done_handler_called = 0;
  65 }
  66
  67 /* tdm_capture_commit */
  68
  69 TEST(tdm_capture_commit, work_flow_success_4)
  70 {
  71         tdm_error error = TDM_ERROR_OPERATION_FAILED;
  72         struct _tdm_private_capture capture;
  73         struct _tdm_private_display private_display;
  74         tdm_private_output private_output;
  75         tdm_error expected_error = TDM_ERROR_NONE;
  76         tdm_pp_private_buffer b_1, b_2;
  77
  78         _init_test();
  79
  80         LIST_INITHEAD(&capture.pending_buffer_list);
  81         LIST_INITHEAD(&capture.buffer_list);
  82
  83         LIST_ADD(&b_1.link, &capture.pending_buffer_list);
  84         LIST_ADD(&b_2.link, &capture.pending_buffer_list);
  85
  86         capture.private_display = &private_display;
  87         private_display.func_capture.capture_commit = capture_commit;
  88         CALLOC_RETURN_BUFFER = 1;
  89         capture.private_output = &private_output;
  90         private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
  91
  92         error = tdm_capture_commit(&capture);
  93
  94         ASSERT_EQ(error, expected_error);
  95         ASSERT_EQ(LIST_LENGTH(&capture.buffer_list), 2);
  96 }
  97
  98 //TEST(tdm_capture_commit, work_flow_success_3)
  99 //{
 100 //      tdm_error error = TDM_ERROR_NONE;
 101 //      struct _tdm_private_capture capture;
 102 //      struct _tdm_private_display private_display;
 103 //      tdm_private_output private_output;
 104 //      tdm_pp_private_buffer b_1, b_2;
 105 //
 106 //      _init_test();
 107 //
 108 //      LIST_INITHEAD(&capture.pending_buffer_list);
 109 //      LIST_INITHEAD(&capture.buffer_list);
 110 //
 111 //      LIST_ADD(&b_1.link, &capture.pending_buffer_list);
 112 //      LIST_ADD(&b_2.link, &capture.pending_buffer_list);
 113 //
 114 //      capture.private_display = &private_display;
 115 //      private_display.func_capture.capture_commit = capture_commit;
 116 //      CAPTURE_COMMIT_ERROR = 1;
 117 //      capture.private_output = &private_output;
 118 //      private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
 119 //
 120 //      error = tdm_capture_commit(&capture);
 121 //
 122 //      ASSERT_NE(error, TDM_ERROR_NONE);
 123 //      ASSERT_EQ(LIST_LENGTH(&capture.buffer_list), 0);
 124 //      ASSERT_EQ(stub_tdm_buffer_remove_release_handler_internal_count, 2);
 125 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
 126 //}
 127
 128 TEST(tdm_capture_commit, work_flow_success_2)
 129 {
 130         tdm_error error = TDM_ERROR_NONE;
 131         tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
 132         struct _tdm_private_capture capture;
 133         struct _tdm_private_display private_display;
 134         tdm_private_output private_output;
 135
 136         _init_test();
 137
 138         LIST_INITHEAD(&capture.pending_buffer_list);
 139
 140         capture.private_display = &private_display;
 141         private_display.func_capture.capture_commit = NULL;
 142         capture.private_output = &private_output;
 143         private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
 144
 145         error = tdm_capture_commit(&capture);
 146
 147         ASSERT_EQ(error, expected_error);
 148 }
 149
 150 TEST(tdm_capture_commit, work_flow_success_1)
 151 {
 152         tdm_error error = TDM_ERROR_NONE;
 153         tdm_error expected_error = TDM_ERROR_BAD_REQUEST;
 154         struct _tdm_private_capture capture;
 155         struct _tdm_private_display private_display;
 156         tdm_private_output private_output;
 157
 158         _init_test();
 159
 160         LIST_INITHEAD(&capture.pending_buffer_list);
 161
 162         capture.private_display = &private_display;
 163         private_display.func_capture.capture_commit = NULL;
 164         capture.private_output = &private_output;
 165         private_output.current_dpms_value = TDM_OUTPUT_DPMS_OFF;
 166
 167         error = tdm_capture_commit(&capture);
 168
 169         ASSERT_EQ(error, expected_error);
 170 }
 171
 172 TEST(tdm_capture_commit, null_ptr_fail_1)
 173 {
 174         tdm_error error = TDM_ERROR_NONE;
 175         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 176
 177         _init_test();
 178
 179         error = tdm_capture_commit(NULL);
 180
 181         ASSERT_EQ(error, expected_error);
 182 }
 183
 184 /* tdm_capture_set_info */
 185
 186 TEST(tdm_capture_set_info, error_capture_set_info_is_null)
 187 {
 188         tdm_info_capture info;
 189         tdm_error error;
 190         struct _tdm_private_capture capture;
 191         struct _tdm_private_display private_display;
 192
 193         _init_test();
 194
 195         capture.private_display = &private_display;
 196         private_display.func_capture.capture_set_info = NULL;
 197
 198         error = tdm_capture_set_info(&capture, &info);
 199
 200         ASSERT_EQ(error, TDM_ERROR_NOT_IMPLEMENTED);
 201 }
 202
 203 TEST(tdm_capture_set_info, work_flow_success_2)
 204 {
 205         tdm_info_capture info;
 206         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 207         struct _tdm_private_capture capture;
 208         struct _tdm_private_display private_display;
 209         tdm_error expected_error = TDM_ERROR_NONE;
 210         tdm_private_output private_output;
 211         tdm_output_mode current_mode;
 212
 213         _init_test();
 214
 215         capture.private_output = &private_output;
 216         private_output.current_mode = &current_mode;
 217         current_mode.vrefresh = 24;
 218         info.type = TDM_CAPTURE_TYPE_STREAM;
 219         info.frequency = 0;
 220
 221         capture.private_display = &private_display;
 222         private_display.func_capture.capture_set_info = capture_set_info;
 223
 224         error = tdm_capture_set_info(&capture, &info);
 225
 226         ASSERT_EQ(error, expected_error);
 227         ASSERT_EQ(info.frequency, current_mode.vrefresh);
 228 }
 229
 230 TEST(tdm_capture_set_info, work_flow_success_1)
 231 {
 232         tdm_info_capture info;
 233         tdm_error error = TDM_ERROR_NONE;
 234         struct _tdm_private_capture capture;
 235         struct _tdm_private_display private_display;
 236         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 237
 238         _init_test();
 239
 240         capture.private_display = &private_display;
 241         private_display.func_capture.capture_set_info = capture_set_info;
 242         CAPTURE_SET_INFO_ERROR = 1;
 243
 244         error = tdm_capture_set_info(&capture, &info);
 245
 246         ASSERT_EQ(error, expected_error);
 247 }
 248
 249 TEST(tdm_capture_set_info, null_ptr_fail_2)
 250 {
 251         tdm_error error = TDM_ERROR_NONE;
 252         struct _tdm_private_capture capture;
 253         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 254
 255         _init_test();
 256
 257         error = tdm_capture_set_info(&capture, NULL);
 258
 259         ASSERT_EQ(error, expected_error);
 260 }
 261
 262 TEST(tdm_capture_set_info, null_ptr_fail_1)
 263 {
 264         tdm_error error = TDM_ERROR_NONE;
 265         tdm_info_capture info;
 266         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 267
 268         _init_test();
 269
 270         error = tdm_capture_set_info(NULL, &info);
 271
 272         ASSERT_EQ(error, expected_error);
 273 }
 274
 275 /* tdm_capture_create_layer_internal */
 276
 277 TEST(tdm_capture_create_layer_internal, work_flow_success_4)
 278 {
 279         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 280         struct _tdm_private_layer private_layer;
 281         struct _tdm_private_output private_output;
 282         struct _tdm_private_display private_display;
 283         tdm_private_capture *actual;
 284         tdm_private_capture *not_expected = NULL;
 285         tdm_error expected_error = TDM_ERROR_NONE;
 286
 287         _init_test();
 288
 289         LIST_INITHEAD(&private_layer.capture_list);
 290         LIST_INITHEAD(&private_display.capture_list);
 291
 292         private_layer.private_output = &private_output;
 293         private_output.private_display = &private_display;
 294         private_display.func_layer.layer_create_capture = layer_create_capture;
 295         private_display.func_capture.capture_destroy = capture_destroy;
 296         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 297         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_LAYER;
 298
 299         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 300
 301         ASSERT_EQ(error, expected_error);
 302         ASSERT_TRUE(actual != not_expected);
 303         free(actual);
 304 }
 305
 306 TEST(tdm_capture_create_layer_internal, work_flow_success_3)
 307 {
 308         tdm_error error = TDM_ERROR_NONE;
 309         struct _tdm_private_layer private_layer;
 310         struct _tdm_private_output private_output;
 311         struct _tdm_private_display private_display;
 312         tdm_private_capture *actual;
 313         tdm_private_capture *expected = NULL;
 314         tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
 315
 316         _init_test();
 317
 318         LIST_INITHEAD(&private_layer.capture_list);
 319         LIST_INITHEAD(&private_display.capture_list);
 320
 321         private_layer.private_output = &private_output;
 322         private_output.private_display = &private_display;
 323         private_display.func_layer.layer_create_capture = layer_create_capture;
 324         private_display.func_capture.capture_destroy = capture_destroy;
 325         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 326         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_LAYER;
 327
 328         CALLOC_ERROR = 1;
 329
 330         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 331
 332         ASSERT_EQ(error, expected_error);
 333         ASSERT_TRUE(actual == expected);
 334 }
 335
 336 TEST(tdm_capture_create_layer_internal, work_flow_success_2)
 337 {
 338         tdm_error error = TDM_ERROR_NONE;
 339         struct _tdm_private_layer private_layer;
 340         struct _tdm_private_output private_output;
 341         struct _tdm_private_display private_display;
 342         tdm_private_capture *actual;
 343         tdm_private_capture *expected = NULL;
 344
 345         _init_test();
 346
 347         LIST_INITHEAD(&private_layer.capture_list);
 348         LIST_INITHEAD(&private_display.capture_list);
 349
 350         private_layer.private_output = &private_output;
 351         private_output.private_display = &private_display;
 352         private_display.func_layer.layer_create_capture = layer_create_capture;
 353         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 354
 355         LAYER_CREATE_CAPTURE_ERROR = 1;
 356
 357         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 358
 359         ASSERT_TRUE(actual == expected);
 360 }
 361
 362 TEST(tdm_capture_create_layer_internal, work_flow_success_1)
 363 {
 364         tdm_error error = TDM_ERROR_NONE;
 365         struct _tdm_private_layer private_layer;
 366         struct _tdm_private_output private_output;
 367         struct _tdm_private_display private_display;
 368         tdm_private_capture *actual;
 369         tdm_private_capture *expected = NULL;
 370         tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
 371
 372         _init_test();
 373
 374         LIST_INITHEAD(&private_layer.capture_list);
 375         LIST_INITHEAD(&private_display.capture_list);
 376
 377         private_layer.private_output = &private_output;
 378         private_output.private_display = &private_display;
 379         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 380
 381         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 382
 383         ASSERT_EQ(error, expected_error);
 384         ASSERT_TRUE(actual == expected);
 385 }
 386
 387 /* tc_tdm_capture_create_output_internal */
 388
 389 TEST(tdm_capture_create_output_internal, work_flow_success_5)
 390 {
 391         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 392         struct _tdm_private_output private_output;
 393         struct _tdm_private_display private_display;
 394         tdm_private_capture *actual;
 395         tdm_private_capture *not_expected = NULL;
 396         tdm_error expected_error = TDM_ERROR_NONE;
 397         tdm_private_capture private_capture;
 398
 399         _init_test();
 400
 401         LIST_INITHEAD(&private_output.capture_list);
 402         LIST_INITHEAD(&private_display.capture_list);
 403
 404         private_output.private_display = &private_display;
 405         private_display.func_output.output_create_capture = output_create_capture;
 406         private_display.func_capture.capture_destroy = capture_destroy;
 407         private_display.func_capture.capture_set_done_handler =
 408                         capture_set_done_handler;
 409         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 410         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_OUTPUT;
 411
 412         private_capture.stamp = stub_tdm_helper_get_time_ret_val;
 413
 414         LIST_ADD(&private_capture.display_link, &private_display.capture_list);
 415
 416         actual = tdm_capture_create_output_internal(&private_output, &error);
 417
 418         ASSERT_EQ(error, expected_error);
 419         ASSERT_TRUE(actual != not_expected);
 420         free(actual);
 421 }
 422
 423 TEST(tdm_capture_create_output_internal, work_flow_success_4)
 424 {
 425         tdm_error error = TDM_ERROR_NONE;
 426         struct _tdm_private_output private_output;
 427         struct _tdm_private_display private_display;
 428         tdm_private_capture *actual;
 429         tdm_private_capture *expected = NULL;
 430         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 431
 432         _init_test();
 433
 434         LIST_INITHEAD(&private_output.capture_list);
 435         LIST_INITHEAD(&private_display.capture_list);
 436
 437         private_output.private_display = &private_display;
 438         private_display.func_output.output_create_capture = output_create_capture;
 439         private_display.func_capture.capture_destroy = capture_destroy;
 440         private_display.func_capture.capture_set_done_handler = capture_set_done_handler;
 441         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 442         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_OUTPUT;
 443         CAPTURE_SET_DONE_HANDLER_ERROR = 1;
 444
 445         actual = tdm_capture_create_output_internal(&private_output, &error);
 446
 447         ASSERT_EQ(error, expected_error);
 448         ASSERT_TRUE(actual == expected);
 449 }
 450
 451 TEST(tdm_capture_create_output_internal, work_flow_success_3)
 452 {
 453         tdm_error error = TDM_ERROR_NONE;
 454         struct _tdm_private_output private_output;
 455         struct _tdm_private_display private_display;
 456         tdm_private_capture *actual;
 457         tdm_private_capture *expected = NULL;
 458         tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
 459
 460         _init_test();
 461
 462         LIST_INITHEAD(&private_output.capture_list);
 463         LIST_INITHEAD(&private_display.capture_list);
 464
 465         private_output.private_display = &private_display;
 466         private_display.func_output.output_create_capture = output_create_capture;
 467         private_display.func_capture.capture_destroy = capture_destroy;
 468         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 469         CALLOC_ERROR = 1;
 470         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_OUTPUT;
 471
 472         actual = tdm_capture_create_output_internal(&private_output, &error);
 473
 474         ASSERT_EQ(error, expected_error);
 475         ASSERT_TRUE(actual == expected);
 476 }
 477
 478 TEST(tdm_capture_create_output_internal, work_flow_success_2)
 479 {
 480         tdm_error error = TDM_ERROR_NONE;
 481         struct _tdm_private_output private_output;
 482         struct _tdm_private_display private_display;
 483         tdm_private_capture *actual;
 484         tdm_private_capture *expected = NULL;
 485         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 486
 487         _init_test();
 488
 489         LIST_INITHEAD(&private_output.capture_list);
 490         LIST_INITHEAD(&private_display.capture_list);
 491
 492         private_output.private_display = &private_display;
 493         private_display.func_output.output_create_capture = output_create_capture;
 494         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 495         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_OUTPUT;
 496         OUTPUT_CREATE_CAPTURE_ERROR = 1;
 497
 498         actual = tdm_capture_create_output_internal(&private_output, &error);
 499
 500         ASSERT_EQ(error, expected_error);
 501         ASSERT_TRUE(actual == expected);
 502 }
 503
 504 TEST(tdm_capture_create_output_internal, work_flow_success_1)
 505 {
 506         tdm_error error = TDM_ERROR_NONE;
 507         struct _tdm_private_output private_output;
 508         struct _tdm_private_display private_display;
 509         tdm_private_capture *actual;
 510         tdm_private_capture *expected = NULL;
 511         tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
 512
 513         _init_test();
 514
 515         LIST_INITHEAD(&private_output.capture_list);
 516         LIST_INITHEAD(&private_display.capture_list);
 517
 518         private_output.private_display = &private_display;
 519         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 520         actual = tdm_capture_create_output_internal(&private_output, &error);
 521
 522         ASSERT_EQ(error, expected_error);
 523         ASSERT_TRUE(actual == expected);
 524 }
 525
 526 TEST(tdm_capture_create_output_internal, TDM_CAPTURE_CAPABILITY_OUTPUT_is_not_set)
 527 {
 528         tdm_error error = TDM_ERROR_NONE;
 529         struct _tdm_private_output private_output;
 530         struct _tdm_private_display private_display;
 531         tdm_private_capture *actual;
 532         tdm_private_capture *expected = NULL;
 533         tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
 534
 535         _init_test();
 536
 537         LIST_INITHEAD(&private_output.capture_list);
 538         LIST_INITHEAD(&private_display.capture_list);
 539
 540         private_output.private_display = &private_display;
 541         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 542         private_display.caps_capture.capabilities = TDM_CAPTURE_CAPABILITY_LAYER;
 543
 544         actual = tdm_capture_create_output_internal(&private_output, &error);
 545
 546         ASSERT_EQ(error, expected_error);
 547         ASSERT_TRUE(actual == expected);
 548 }
 549
 550 /* tdm_capture_cb_done() */
 551
 552 TEST(tdm_capture_cb_done, success_not_in_display_thread)
 553 {
 554         tdm_private_capture private_capture;
 555         struct _tbm_surface buffer;
 556         tdm_thread_cb_capture_done *capture_done;
 557         tdm_private_display private_display;
 558
 559         _init_test();
 560
 561         private_capture.private_display = &private_display;
 562         stub_syscall_return_value = 50;
 563         private_capture.owner_tid = stub_syscall_return_value + 1;
 564         private_capture.stamp = 10.15;
 565
 566         tdm_capture_cb_done(&private_capture, &buffer, &private_capture);
 567
 568         capture_done = (tdm_thread_cb_capture_done *)stub_tdm_thread_send_cb_buff;
 569
 570         ASSERT_EQ(capture_done->base.type, TDM_THREAD_CB_CAPTURE_DONE);
 571         ASSERT_EQ(capture_done->base.length, sizeof * capture_done);
 572         ASSERT_DOUBLE_EQ(capture_done->capture_stamp, private_capture.stamp);
 573         ASSERT_TRUE(capture_done->buffer == &buffer);
 574         ASSERT_TRUE(capture_done->user_data == &private_capture);
 575 }
 576
 577 //TEST(tdm_capture_cb_done, success_in_display_thread)
 578 //{
 579 //      tdm_private_capture private_capture;
 580 //      struct _tbm_surface buffer;
 581 //      tdm_thread_cb_capture_done *capture_done;
 582 //      tdm_private_display private_display;
 583 //      tdm_capture_private_buffer *capture_buffer_1;
 584 //      tdm_capture_private_buffer *capture_buffer_2;
 585 //
 586 //      _init_test();
 587 //
 588 //      capture_buffer_1 = (tdm_capture_private_buffer *)
 589 //                                                                              calloc(1, sizeof * capture_buffer_1);
 590 //      capture_buffer_2 = (tdm_capture_private_buffer *)
 591 //                                                                              calloc(1, sizeof * capture_buffer_2);
 592 //
 593 //      LIST_INITHEAD(&private_capture.buffer_list);
 594 //      LIST_ADD(&capture_buffer_1->link, &private_capture.buffer_list);
 595 //      LIST_ADD(&capture_buffer_2->link, &private_capture.buffer_list);
 596 //
 597 //      capture_buffer_1->buffer = &buffer;
 598 //
 599 //      private_capture.private_display = &private_display;
 600 //      stub_syscall_return_value = 50;
 601 //      stub_syscall_reset = 1;
 602 //      private_capture.owner_tid = stub_syscall_return_value;
 603 //      private_capture.done_func = stub_tdm_capture_done_handler;
 604 //
 605 //      tdm_capture_cb_done(&private_capture, &buffer, &private_capture);
 606 //
 607 //      ASSERT_EQ(FREE_CALLED, 1);
 608 //      ASSERT_EQ(stub_tdm_capture_done_handler_called, 1);
 609 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 1);
 610 //      ASSERT_TRUE(!_tdm_capture_find_tbm_buffer(&private_capture.buffer_list, &buffer));
 611 //}
 612
 613 /* tdm_capture_find_stamp() */
 614
 615 TEST(tdm_capture_find_stamp, success_capture_list_is_empty)
 616 {
 617         tdm_private_capture *capture_ret;
 618         tdm_private_display private_display;
 619
 620         _init_test();
 621
 622         LIST_INITHEAD(&private_display.capture_list);
 623
 624         capture_ret = tdm_capture_find_stamp(&private_display, 0.5);
 625
 626         ASSERT_EQ(capture_ret, NULL);
 627 }
 628
 629 TEST(tdm_capture_find_stamp, success)
 630 {
 631         tdm_private_capture *capture_ret;
 632         tdm_private_display private_display;
 633         double stamp = 54.54;
 634         tdm_private_capture capture;
 635
 636         _init_test();
 637
 638         capture.stamp = stamp;
 639
 640         LIST_INITHEAD(&private_display.capture_list);
 641         LIST_ADD(&capture.display_link, &private_display.capture_list);
 642
 643         capture_ret = tdm_capture_find_stamp(&private_display, stamp);
 644
 645         ASSERT_EQ(capture_ret, &capture);
 646 }
 647
 648 /* tdm_capture_destroy_internal() */
 649
 650 //TEST(tdm_capture_destroy_internal, success)
 651 //{
 652 //      tdm_private_capture *capture;
 653 //      tdm_private_display private_display;
 654 //      struct list_head list;
 655 //      struct list_head dsp_list;
 656 //      tdm_buffer_info *b1, *b2;
 657 //
 658 //      _init_test();
 659 //
 660 //      b1 = (tdm_buffer_info *)calloc(1, sizeof * b1);
 661 //      b2 = (tdm_buffer_info *)calloc(1, sizeof * b2);
 662 //
 663 //      capture = (tdm_private_capture *)calloc(1, sizeof * capture);
 664 //      capture->private_display = &private_display;
 665 //
 666 //      private_display.func_capture.capture_destroy = capture_destroy;
 667 //
 668 //      LIST_INITHEAD(&list);
 669 //      LIST_INITHEAD(&dsp_list);
 670 //      LIST_INITHEAD(&capture->pending_buffer_list);
 671 //      LIST_INITHEAD(&capture->buffer_list);
 672 //
 673 //      LIST_ADD(&capture->link, &list);
 674 //      LIST_ADD(&capture->display_link, &dsp_list);
 675 //      LIST_ADD(&b1->link, &capture->pending_buffer_list);
 676 //      LIST_ADD(&b2->link, &capture->buffer_list);
 677 //
 678 //      tdm_capture_destroy_internal(capture);
 679 //
 680 //      ASSERT_TRUE(LIST_IS_EMPTY(&list));
 681 //      ASSERT_TRUE(LIST_IS_EMPTY(&dsp_list));
 682 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
 683 //      ASSERT_EQ(FREE_CALLED, 1);
 684 //      ASSERT_EQ(capture_destroy_is_called, 1);
 685 //}
 686
 687 /* tdm_capture_destroy() */
 688
 689 //TEST(tdm_capture_destroy, success)
 690 //{
 691 //      tdm_private_capture *capture;
 692 //      tdm_private_display private_display;
 693 //      struct list_head list;
 694 //      struct list_head dsp_list;
 695 //      tdm_buffer_info *b1, *b2;
 696 //
 697 //      _init_test();
 698 //
 699 //      b1 = (tdm_buffer_info *)calloc(1, sizeof * b1);
 700 //      b2 = (tdm_buffer_info *)calloc(1, sizeof * b2);
 701 //
 702 //      capture = (tdm_private_capture *)calloc(1, sizeof * capture);
 703 //      capture->private_display = &private_display;
 704 //
 705 //      private_display.func_capture.capture_destroy = capture_destroy;
 706 //
 707 //      LIST_INITHEAD(&list);
 708 //      LIST_INITHEAD(&dsp_list);
 709 //      LIST_INITHEAD(&capture->pending_buffer_list);
 710 //      LIST_INITHEAD(&capture->buffer_list);
 711 //
 712 //      LIST_ADD(&capture->link, &list);
 713 //      LIST_ADD(&capture->display_link, &dsp_list);
 714 //      LIST_ADD(&b1->link, &capture->pending_buffer_list);
 715 //      LIST_ADD(&b2->link, &capture->buffer_list);
 716 //
 717 //      tdm_capture_destroy(capture);
 718 //
 719 //      ASSERT_TRUE(LIST_IS_EMPTY(&list));
 720 //      ASSERT_TRUE(LIST_IS_EMPTY(&dsp_list));
 721 //      ASSERT_EQ(stub_tdm_buffer_unref_backend_count, 2);
 722 //      ASSERT_EQ(FREE_CALLED, 1);
 723 //      ASSERT_EQ(capture_destroy_is_called, 1);
 724 //}
 725
 726 /* tdm_capture_set_done_handler() */
 727
 728 TEST(tdm_capture_set_done_handler, error_capture_is_null)
 729 {
 730         tdm_error error;
 731
 732         error = tdm_capture_set_done_handler(NULL, stub_tdm_capture_done_handler, NULL);
 733
 734         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 735 }
 736
 737 TEST(tdm_capture_set_done_handler, error_func_is_null)
 738 {
 739         tdm_error error;
 740         tdm_private_capture capture;
 741
 742         error = tdm_capture_set_done_handler(&capture, NULL, NULL);
 743
 744         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 745 }
 746
 747 TEST(tdm_capture_set_done_handler, success)
 748 {
 749         tdm_error error;
 750         tdm_private_capture capture;
 751         int user_data;
 752
 753         error = tdm_capture_set_done_handler(&capture, stub_tdm_capture_done_handler, &user_data);
 754
 755         ASSERT_EQ(error, TDM_ERROR_NONE);
 756         ASSERT_TRUE(capture.done_func == stub_tdm_capture_done_handler);
 757         ASSERT_TRUE(capture.done_user_data == &user_data);
 758 }
 759
 760 /* tdm_capture_attach() */
 761
 762 TEST(tdm_capture_attach, error_buffer_is_null)
 763 {
 764         tdm_error error = TDM_ERROR_NONE;
 765         struct _tdm_private_capture capture;
 766         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 767
 768         _init_test();
 769
 770         error = tdm_capture_attach(&capture, NULL);
 771
 772         ASSERT_EQ(error, expected_error);
 773 }
 774
 775 TEST(tdm_capture_attach, error_capture_is_null)
 776 {
 777         tdm_error error = TDM_ERROR_NONE;
 778         struct _tbm_surface buffer;
 779
 780         _init_test();
 781
 782         error = tdm_capture_attach(NULL, &buffer);
 783
 784         ASSERT_EQ(error, TDM_ERROR_INVALID_PARAMETER);
 785 }
 786
 787 TEST(tdm_capture_attach, error_func_capture_attach_is_null)
 788 {
 789         tdm_error error = TDM_ERROR_NONE;
 790         struct _tdm_private_capture capture;
 791         struct _tbm_surface buffer;
 792         tdm_private_display dsp;
 793
 794         _init_test();
 795
 796         capture.private_display = &dsp;
 797         dsp.func_capture.capture_attach = NULL;
 798
 799         error = tdm_capture_attach(&capture, &buffer);
 800
 801         ASSERT_EQ(error, TDM_ERROR_NOT_IMPLEMENTED);
 802 }
 803
 804 TEST(tdm_capture_attach, error_length_of_pending_buffer_list_ge_max_attach_count)
 805 {
 806         tdm_error error = TDM_ERROR_NONE;
 807         struct _tdm_private_capture capture;
 808         struct _tbm_surface buffer;
 809         tdm_private_display dsp;
 810         tdm_backend_module module;
 811         tdm_capture_private_buffer b1, b2;
 812
 813         _init_test();
 814
 815         capture.private_display = &dsp;
 816         dsp.func_capture.capture_attach = capture_attach;
 817
 818         dsp.module_data = &module;
 819         module.abi_version = 0x000100002;
 820
 821         LIST_INITHEAD(&capture.pending_buffer_list);
 822         LIST_INITHEAD(&capture.buffer_list);
 823         LIST_ADD(&b1.link, &capture.pending_buffer_list);
 824         LIST_ADD(&b2.link, &capture.pending_buffer_list);
 825
 826         dsp.caps_capture.max_attach_count = 1;
 827
 828         error = tdm_capture_attach(&capture, &buffer);
 829
 830         ASSERT_EQ(error, TDM_ERROR_BAD_REQUEST);
 831 }
 832
 833 TEST(tdm_capture_attach, error_calloc)
 834 {
 835         tdm_error error = TDM_ERROR_NONE;
 836         struct _tdm_private_capture capture;
 837         struct _tbm_surface buffer;
 838         tdm_private_display dsp;
 839         tdm_backend_module module;
 840
 841         _init_test();
 842
 843         capture.private_display = &dsp;
 844         dsp.func_capture.capture_attach = capture_attach;
 845
 846         dsp.module_data = &module;
 847         module.abi_version = 0x000100002;
 848
 849         LIST_INITHEAD(&capture.pending_buffer_list);
 850         LIST_INITHEAD(&capture.buffer_list);
 851
 852         dsp.caps_capture.max_attach_count = 3;
 853
 854         CALLOC_ERROR = 1;
 855
 856         error = tdm_capture_attach(&capture, &buffer);
 857
 858         ASSERT_EQ(error, TDM_ERROR_OUT_OF_MEMORY);
 859 }
 860
 861 TEST(tdm_capture_attach, error_capture_attach)
 862 {
 863         tdm_error error = TDM_ERROR_NONE;
 864         struct _tdm_private_capture capture;
 865         struct _tbm_surface buffer;
 866         tdm_private_display dsp;
 867         tdm_backend_module module;
 868
 869         _init_test();
 870
 871         capture.private_display = &dsp;
 872         dsp.func_capture.capture_attach = capture_attach;
 873
 874         dsp.module_data = &module;
 875         module.abi_version = 0x000100002;
 876
 877         LIST_INITHEAD(&capture.pending_buffer_list);
 878         LIST_INITHEAD(&capture.buffer_list);
 879
 880         dsp.caps_capture.max_attach_count = 3;
 881
 882         CAPTURE_ATTACH_ERROR = 1;
 883
 884         error = tdm_capture_attach(&capture, &buffer);
 885
 886         ASSERT_NE(error, TDM_ERROR_NONE);
 887 }
 888
 889 TEST(tdm_capture_attach, success)
 890 {
 891         tdm_error error = TDM_ERROR_NONE;
 892         struct _tdm_private_capture capture;
 893         struct _tbm_surface buffer;
 894         tdm_private_display dsp;
 895         tdm_backend_module module;
 896         tdm_capture_private_buffer *capture_buffer;
 897
 898         _init_test();
 899
 900         capture.private_display = &dsp;
 901         dsp.func_capture.capture_attach = capture_attach;
 902
 903         dsp.module_data = &module;
 904         module.abi_version = 0x000100002;
 905
 906         LIST_INITHEAD(&capture.pending_buffer_list);
 907         LIST_INITHEAD(&capture.buffer_list);
 908
 909         dsp.caps_capture.max_attach_count = 3;
 910
 911         error = tdm_capture_attach(&capture, &buffer);
 912
 913         ASSERT_EQ(error, TDM_ERROR_NONE);
 914         ASSERT_TRUE(!LIST_IS_EMPTY(&capture.pending_buffer_list));
 915         free(container_of(capture.pending_buffer_list.next, capture_buffer, link));
 916 }