ut/src/ut_tbm_surface_queue.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 typedef struct _tbm_surface_queue tbm_surface_queue_s;
  32 typedef struct _tbm_surface tbm_surface_s;
  33
  34 #include "pthread_stubs.h"
  35 #include "stdlib_stubs.h"
  36
  37 #define pthread_mutex_lock ut_pthread_mutex_lock
  38 #define pthread_mutex_unlock ut_pthread_mutex_unlock
  39 #define pthread_mutex_init ut_pthread_mutex_init
  40 #define pthread_cond_signal ut_pthread_cond_signal
  41 #define pthread_cond_wait ut_pthread_cond_wait
  42 #define calloc ut_calloc
  43 #define free ut_free
  44
  45 #include "tbm_surface_queue.c"
  46
  47 /* HELPER FUNCTIONS */
  48
  49 static void ut_tbm_surface_queue_notify_cb(tbm_surface_queue_h surface_queue,
  50                                                                                    void *data) {}
  51
  52 static tbm_surface_h ut_tbm_surface_alloc_cb(tbm_surface_queue_h surface_queue,
  53                                                                                          void *data) {}
  54
  55 static void ut_tbm_surface_free_cb(tbm_surface_queue_h surface_queue,
  56                                                                    void *data, tbm_surface_h surface) {}
  57
  58 static void ut_enqueue(tbm_surface_queue_h queue, queue_node *node) {}
  59
  60 static queue_node *ut_dequeue(tbm_surface_queue_h queue)
  61 {
  62         return NULL;
  63 }
  64
  65 static void ut_release(tbm_surface_queue_h queue, queue_node *node) {}
  66
  67 static queue_node *ut_acquire(tbm_surface_queue_h queue)
  68 {
  69         return NULL;
  70 }
  71
  72 static void _init_test()
  73 {
  74         PTHREAD_MUTEX_INIT_ERROR = 0;
  75         CALLOC_ERROR = 0;
  76         FREE_CALLED = 0;
  77         FREE_PTR = NULL;
  78         FREE_TESTED_PTR = NULL;
  79         free_called_for_tested_ptr = 0;
  80         free_call_count = 0;
  81         GETENV_ERROR = 0;
  82 }
  83
  84 /* tbm_surface_queue_sequence_create */
  85
  86 TEST(tbm_surface_queue_sequence_create, work_flow_success_6)
  87 {
  88         tbm_surface_queue_h surface_queue = NULL;
  89         int queue_size = 1000;
  90         int width = 200;
  91         int height = 100;
  92         int format = 50;
  93         int flags = 10;
  94
  95         _init_test();
  96
  97         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
  98                                                                                          format, flags);
  99
 100         ASSERT_NE(surface_queue, NULL);
 101         tbm_surface_queue_s copy_surface_queue = *surface_queue;
 102         tbm_queue_default data = *((tbm_queue_default *) surface_queue->impl_data);
 103         free(surface_queue->impl_data);
 104         free(surface_queue);
 105         ASSERT_EQ(queue_size, data.queue_size);
 106         ASSERT_EQ(flags, data.flags);
 107         ASSERT_EQ(queue_size, copy_surface_queue.queue_size);
 108         ASSERT_EQ(width, copy_surface_queue.width);
 109         ASSERT_EQ(height, copy_surface_queue.height);
 110         ASSERT_EQ(format, copy_surface_queue.format);
 111 }
 112
 113 TEST(tbm_surface_queue_sequence_create, work_flow_success_5)
 114 {
 115         tbm_surface_queue_h surface_queue = NULL;
 116         tbm_surface_queue_h expected_surface_queue = NULL;
 117         int queue_size = 1000;
 118         int width = 200;
 119         int height = 100;
 120         int format = 50;
 121         int flags = 10;
 122
 123         _init_test();
 124
 125         CALLOC_ERROR = 1;
 126
 127         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
 128                                                                                          format, flags);
 129
 130         ASSERT_EQ(surface_queue, expected_surface_queue);
 131 }
 132
 133 TEST(tbm_surface_queue_sequence_create, work_flow_success_4)
 134 {
 135         tbm_surface_queue_h surface_queue = NULL;
 136         tbm_surface_queue_h expected_surface_queue = NULL;
 137         int queue_size = 1000;
 138         int width = 200;
 139         int height = 100;
 140         int format = 0;
 141         int flags = 10;
 142
 143         _init_test();
 144
 145         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
 146                                                                                          format, flags);
 147
 148         ASSERT_EQ(surface_queue, expected_surface_queue);
 149 }
 150
 151 TEST(tbm_surface_queue_sequence_create, work_flow_success_3)
 152 {
 153         tbm_surface_queue_h surface_queue = NULL;
 154         tbm_surface_queue_h expected_surface_queue = NULL;
 155         int queue_size = 1000;
 156         int width = 200;
 157         int height = 0;
 158         int format = 50;
 159         int flags = 10;
 160
 161         _init_test();
 162
 163         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
 164                                                                                          format, flags);
 165
 166         ASSERT_EQ(surface_queue, expected_surface_queue);
 167 }
 168
 169 TEST(tbm_surface_queue_sequence_create, work_flow_success_2)
 170 {
 171         tbm_surface_queue_h surface_queue = NULL;
 172         tbm_surface_queue_h expected_surface_queue = NULL;
 173         int queue_size = 1000;
 174         int width = 0;
 175         int height = 100;
 176         int format = 50;
 177         int flags = 10;
 178
 179         _init_test();
 180
 181         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
 182                                                                                          format, flags);
 183
 184         ASSERT_EQ(surface_queue, expected_surface_queue);
 185 }
 186
 187 TEST(tbm_surface_queue_sequence_create, work_flow_success_1)
 188 {
 189         tbm_surface_queue_h surface_queue = NULL;
 190         tbm_surface_queue_h expected_surface_queue = NULL;
 191         int queue_size = 0;
 192         int width = 200;
 193         int height = 100;
 194         int format = 50;
 195         int flags = 10;
 196
 197         _init_test();
 198
 199         surface_queue = tbm_surface_queue_sequence_create(queue_size, width, height,
 200                                                                                          format, flags);
 201
 202         ASSERT_EQ(surface_queue, expected_surface_queue);
 203 }
 204
 205 /* tbm_surface_queue_create() */
 206
 207 TEST(tbm_surface_queue_create, work_flow_success_6)
 208 {
 209         tbm_surface_queue_h surface_queue = NULL;
 210         int queue_size = 1000;
 211         int width = 200;
 212         int height = 100;
 213         int format = 50;
 214         int flags = 10;
 215
 216         _init_test();
 217
 218         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 219                                                                                          format, flags);
 220
 221         ASSERT_NE(surface_queue, NULL);
 222         tbm_surface_queue_s copy_surface_queue = *surface_queue;
 223         tbm_queue_default data = *((tbm_queue_default *) surface_queue->impl_data);
 224         free(surface_queue->impl_data);
 225         free(surface_queue);
 226         ASSERT_EQ(queue_size, data.queue_size);
 227         ASSERT_EQ(flags, data.flags);
 228         ASSERT_EQ(queue_size, copy_surface_queue.queue_size);
 229         ASSERT_EQ(width, copy_surface_queue.width);
 230         ASSERT_EQ(height, copy_surface_queue.height);
 231         ASSERT_EQ(format, copy_surface_queue.format);
 232 }
 233
 234 TEST(tbm_surface_queue_create, work_flow_success_5)
 235 {
 236         tbm_surface_queue_h surface_queue = NULL;
 237         tbm_surface_queue_h expected_surface_queue = NULL;
 238         int queue_size = 1000;
 239         int width = 200;
 240         int height = 100;
 241         int format = 50;
 242         int flags = 10;
 243
 244         _init_test();
 245
 246         CALLOC_ERROR = 1;
 247
 248         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 249                                                                                          format, flags);
 250
 251         ASSERT_EQ(surface_queue, expected_surface_queue);
 252 }
 253
 254 TEST(tbm_surface_queue_create, work_flow_success_4)
 255 {
 256         tbm_surface_queue_h surface_queue = NULL;
 257         tbm_surface_queue_h expected_surface_queue = NULL;
 258         int queue_size = 1000;
 259         int width = 200;
 260         int height = 100;
 261         int format = 0;
 262         int flags = 10;
 263
 264         _init_test();
 265
 266         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 267                                                                                          format, flags);
 268
 269         ASSERT_EQ(surface_queue, expected_surface_queue);
 270 }
 271
 272 TEST(tbm_surface_queue_create, work_flow_success_3)
 273 {
 274         tbm_surface_queue_h surface_queue = NULL;
 275         tbm_surface_queue_h expected_surface_queue = NULL;
 276         int queue_size = 1000;
 277         int width = 200;
 278         int height = 0;
 279         int format = 50;
 280         int flags = 10;
 281
 282         _init_test();
 283
 284         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 285                                                                                          format, flags);
 286
 287         ASSERT_EQ(surface_queue, expected_surface_queue);
 288 }
 289
 290 TEST(tbm_surface_queue_create, work_flow_success_2)
 291 {
 292         tbm_surface_queue_h surface_queue = NULL;
 293         tbm_surface_queue_h expected_surface_queue = NULL;
 294         int queue_size = 1000;
 295         int width = 0;
 296         int height = 100;
 297         int format = 50;
 298         int flags = 10;
 299
 300         _init_test();
 301
 302         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 303                                                                                          format, flags);
 304
 305         ASSERT_EQ(surface_queue, expected_surface_queue);
 306 }
 307
 308 TEST(tbm_surface_queue_create, work_flow_success_1)
 309 {
 310         tbm_surface_queue_h surface_queue = NULL;
 311         tbm_surface_queue_h expected_surface_queue = NULL;
 312         int queue_size = 0;
 313         int width = 200;
 314         int height = 100;
 315         int format = 50;
 316         int flags = 10;
 317
 318         _init_test();
 319
 320         surface_queue = tbm_surface_queue_create(queue_size, width, height,
 321                                                                                          format, flags);
 322
 323         ASSERT_EQ(surface_queue, expected_surface_queue);
 324 }
 325
 326 /* tbm_surface_queue_flush() */
 327
 328 TEST(tbm_surface_queue_flush, work_flow_success_1)
 329 {
 330         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 331         tbm_surface_queue_error_e expected_error =
 332                         TBM_SURFACE_QUEUE_ERROR_NONE;
 333         tbm_surface_queue_s surface_queue;
 334         LIST_INITHEAD(&surface_queue.list);
 335         LIST_INITHEAD(&surface_queue.reset_noti);
 336         surface_queue.impl = NULL;
 337
 338         _init_test();
 339
 340         error = tbm_surface_queue_flush(&surface_queue);
 341
 342         ASSERT_EQ(error, expected_error);
 343 }
 344
 345 TEST(tbm_surface_queue_flush, null_ptr_fail_1)
 346 {
 347         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 348         tbm_surface_queue_error_e expected_error =
 349                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 350
 351         _init_test();
 352
 353         error = tbm_surface_queue_flush(NULL);
 354
 355         ASSERT_EQ(error, expected_error);
 356 }
 357
 358 /* tbm_surface_queue_reset() */
 359
 360 TEST(tbm_surface_queue_reset, work_flow_success_2)
 361 {
 362         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 363         tbm_surface_queue_error_e expected_error =
 364                         TBM_SURFACE_QUEUE_ERROR_NONE;
 365         tbm_surface_queue_s surface_queue;
 366         int width, height, format;
 367
 368         _init_test();
 369
 370         width = 200;
 371         height = 100;
 372         format = 10;
 373         surface_queue.width = 1;
 374         surface_queue.height = 1;
 375         surface_queue.format = 1;
 376         LIST_INITHEAD(&surface_queue.list);
 377         LIST_INITHEAD(&surface_queue.reset_noti);
 378         surface_queue.impl = NULL;
 379
 380         error = tbm_surface_queue_reset(&surface_queue, width, height, format);
 381
 382         ASSERT_EQ(error, expected_error);
 383         ASSERT_EQ(width, surface_queue.width);
 384         ASSERT_EQ(height, surface_queue.height);
 385         ASSERT_EQ(format, surface_queue.format);
 386 }
 387
 388 TEST(tbm_surface_queue_reset, work_flow_success_1)
 389 {
 390         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 391         tbm_surface_queue_error_e expected_error =
 392                         TBM_SURFACE_QUEUE_ERROR_NONE;
 393         tbm_surface_queue_s surface_queue;
 394         int width, height, format;
 395
 396         _init_test();
 397
 398         width = 200;
 399         height = 100;
 400         format = 10;
 401         surface_queue.width = width;
 402         surface_queue.height = height;
 403         surface_queue.format = format;
 404
 405         error = tbm_surface_queue_reset(&surface_queue, width, height, format);
 406
 407         ASSERT_EQ(error, expected_error);
 408 }
 409
 410 TEST(tbm_surface_queue_reset, null_ptr_fail_1)
 411 {
 412         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 413         tbm_surface_queue_error_e expected_error =
 414                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 415
 416         _init_test();
 417
 418         error = tbm_surface_queue_reset(NULL, 0, 0, 0);
 419
 420         ASSERT_EQ(error, expected_error);
 421 }
 422
 423 /* tbm_surface_queue_destroy() */
 424
 425 TEST(tbm_surface_queue_destroy, work_flow_success_1)
 426 {
 427         tbm_surface_queue_h surface_queue = calloc(1, sizeof(*surface_queue));
 428         queue_notify *destory_item1;
 429         queue_notify *destory_item2;
 430         queue_notify *acquirable_item1;
 431         queue_notify *acquirable_item2;
 432         queue_notify *dequeuable_item1;
 433         queue_notify *dequeuable_item2;
 434         queue_notify *reset_item1;
 435         queue_notify *reset_item2;
 436
 437         _init_test();
 438
 439         surface_queue->impl = NULL;
 440         destory_item1 = calloc(1, sizeof(*destory_item1));
 441         destory_item2 = calloc(1, sizeof(*destory_item2));
 442         acquirable_item1 = calloc(1, sizeof(*acquirable_item1));
 443         acquirable_item2 = calloc(1, sizeof(*acquirable_item2));
 444         dequeuable_item1 = calloc(1, sizeof(*dequeuable_item1));
 445         dequeuable_item2 = calloc(1, sizeof(*dequeuable_item2));
 446         reset_item1 = calloc(1, sizeof(*reset_item1));
 447         reset_item2 = calloc(1, sizeof(*reset_item2));
 448         destory_item1->cb = ut_tbm_surface_queue_notify_cb;
 449         destory_item2->cb = ut_tbm_surface_queue_notify_cb;
 450         LIST_INITHEAD(&surface_queue->destory_noti);
 451         LIST_INITHEAD(&surface_queue->list);
 452         LIST_INITHEAD(&surface_queue->acquirable_noti);
 453         LIST_INITHEAD(&surface_queue->dequeuable_noti);
 454         LIST_INITHEAD(&surface_queue->reset_noti);
 455         LIST_ADD(&destory_item1->link, &surface_queue->destory_noti);
 456         LIST_ADD(&destory_item2->link, &surface_queue->destory_noti);
 457         LIST_ADD(&dequeuable_item1->link, &surface_queue->dequeuable_noti);
 458         LIST_ADD(&dequeuable_item2->link, &surface_queue->dequeuable_noti);
 459         LIST_ADD(&acquirable_item1->link, &surface_queue->acquirable_noti);
 460         LIST_ADD(&acquirable_item2->link, &surface_queue->acquirable_noti);
 461         LIST_ADD(&reset_item1->link, &surface_queue->reset_noti);
 462         LIST_ADD(&reset_item2->link, &surface_queue->reset_noti);
 463
 464         tbm_surface_queue_destroy(surface_queue);
 465
 466         ASSERT_GE(free_call_count, 9);
 467 }
 468
 469 /* tbm_surface_queue_can_acquire() */
 470
 471 TEST(tbm_surface_queue_can_acquire, work_flow_success_3)
 472 {
 473         int actual = 0;
 474         int expected = 1;
 475         int wait = 0;
 476         tbm_surface_queue_s surface_queue;
 477         queue_node node;
 478
 479         _init_test();
 480
 481         _queue_init(&surface_queue.dirty_queue);
 482         _queue_node_push_back(&surface_queue.dirty_queue, &node);
 483
 484         actual = tbm_surface_queue_can_acquire(&surface_queue, wait);
 485
 486         ASSERT_EQ(actual, expected);
 487 }
 488
 489 TEST(tbm_surface_queue_can_acquire, work_flow_success_2)
 490 {
 491         int actual = 1;
 492         int expected = 0;
 493         int wait = 0;
 494         tbm_surface_queue_s surface_queue;
 495
 496         _init_test();
 497
 498         _queue_init(&surface_queue.dirty_queue);
 499
 500         actual = tbm_surface_queue_can_acquire(&surface_queue, wait);
 501
 502         ASSERT_EQ(actual, expected);
 503 }
 504
 505 TEST(tbm_surface_queue_can_acquire, work_flow_success_1)
 506 {
 507         int actual = 1;
 508         int expected = 0;
 509         int wait = 2;
 510         tbm_surface_queue_s surface_queue;
 511
 512         _init_test();
 513
 514         _queue_init(&surface_queue.dirty_queue);
 515         LIST_INITHEAD(&surface_queue.list);
 516
 517         actual = tbm_surface_queue_can_acquire(&surface_queue, wait);
 518
 519         ASSERT_EQ(actual, expected);
 520 }
 521
 522 TEST(tbm_surface_queue_can_acquire, null_ptr_fail_1)
 523 {
 524         int actual = 1;
 525         int expected = 0;
 526
 527         _init_test();
 528
 529         actual = tbm_surface_queue_can_acquire(NULL, 0);
 530
 531         ASSERT_EQ(actual, expected);
 532 }
 533
 534 /* tbm_surface_queue_acquire() */
 535
 536 TEST(tbm_surface_queue_acquire, work_flow_success_4)
 537 {
 538         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 539         tbm_surface_queue_error_e expected_error =
 540                         TBM_SURFACE_QUEUE_ERROR_NONE;
 541         tbm_surface_s expected_surface;
 542         tbm_surface_queue_s surface_queue;
 543         tbm_surface_s *surface;
 544         queue_node node;
 545
 546         _init_test();
 547
 548         surface_queue.impl = NULL;
 549         _queue_init(&surface_queue.dirty_queue);
 550         node.surface = &expected_surface;
 551         _queue_node_push_back(&surface_queue.dirty_queue, &node);
 552
 553         error = tbm_surface_queue_acquire(&surface_queue, &surface);
 554
 555         ASSERT_EQ(error, expected_error);
 556         ASSERT_TRUE(surface == &expected_surface);
 557 }
 558
 559 TEST(tbm_surface_queue_acquire, work_flow_success_3)
 560 {
 561         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 562         tbm_surface_queue_error_e expected_error =
 563                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 564         tbm_surface_queue_s surface_queue;
 565         tbm_surface_s *surface;
 566         queue_node node;
 567
 568         _init_test();
 569
 570         surface_queue.impl = NULL;
 571         _queue_init(&surface_queue.dirty_queue);
 572         node.surface = NULL;
 573         _queue_node_push_back(&surface_queue.dirty_queue, &node);
 574
 575         error = tbm_surface_queue_acquire(&surface_queue, &surface);
 576
 577         ASSERT_EQ(error, expected_error);
 578 }
 579
 580 TEST(tbm_surface_queue_acquire, work_flow_success_2)
 581 {
 582         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 583         tbm_surface_queue_error_e expected_error =
 584                         TBM_SURFACE_QUEUE_ERROR_EMPTY;
 585         tbm_surface_queue_s surface_queue;
 586         tbm_surface_s *surface;
 587
 588         _init_test();
 589
 590         surface_queue.impl = NULL;
 591         _queue_init(&surface_queue.dirty_queue);
 592
 593         error = tbm_surface_queue_acquire(&surface_queue, &surface);
 594
 595         ASSERT_EQ(error, expected_error);
 596 }
 597
 598 TEST(tbm_surface_queue_acquire, work_flow_success_1)
 599 {
 600         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 601         tbm_surface_queue_error_e expected_error =
 602                         TBM_SURFACE_QUEUE_ERROR_EMPTY;
 603         tbm_surface_queue_s surface_queue;
 604         tbm_surface_s *surface;
 605         tbm_surface_queue_interface impl;
 606
 607         _init_test();
 608
 609         surface_queue.impl = &impl;
 610         impl.acquire = ut_acquire;
 611
 612         error = tbm_surface_queue_acquire(&surface_queue, &surface);
 613
 614         ASSERT_EQ(error, expected_error);
 615 }
 616
 617 TEST(tbm_surface_queue_acquire, null_ptr_fail_2)
 618 {
 619         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 620         tbm_surface_queue_error_e expected_error =
 621                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 622         tbm_surface_queue_s surface_queue;
 623
 624         _init_test();
 625
 626         error = tbm_surface_queue_acquire(&surface_queue, NULL);
 627
 628         ASSERT_EQ(error, expected_error);
 629 }
 630
 631 TEST(tbm_surface_queue_acquire, null_ptr_fail_1)
 632 {
 633         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 634         tbm_surface_queue_error_e expected_error =
 635                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 636         tbm_surface_s *surface;
 637
 638         _init_test();
 639
 640         error = tbm_surface_queue_acquire(NULL, &surface);
 641
 642         ASSERT_EQ(error, expected_error);
 643
 644 }
 645
 646 /* tbm_surface_queue_release() */
 647
 648 TEST(tbm_surface_queue_release, work_flow_success_5)
 649 {
 650         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 651         tbm_surface_queue_error_e expected_error =
 652                         TBM_SURFACE_QUEUE_ERROR_NONE;
 653         tbm_surface_queue_s surface_queue;
 654         tbm_surface_s surface;
 655         queue_node node;
 656
 657         _init_test();
 658
 659         _queue_init(&surface_queue.free_queue);
 660         _queue_init(&surface_queue.dirty_queue);
 661         LIST_INITHEAD(&surface_queue.list);
 662         node.surface = &surface;
 663         LIST_ADD(&node.link, &surface_queue.list);
 664         surface_queue.impl = NULL;
 665         LIST_INITHEAD(&surface_queue.dequeuable_noti);
 666
 667         error = tbm_surface_queue_release(&surface_queue, &surface);
 668
 669         ASSERT_EQ(error, expected_error);
 670 }
 671
 672 TEST(tbm_surface_queue_release, work_flow_success_4)
 673 {
 674         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 675         tbm_surface_queue_error_e expected_error =
 676                         TBM_SURFACE_QUEUE_ERROR_NONE;
 677         tbm_surface_queue_s surface_queue;
 678         tbm_surface_s surface;
 679         queue_node node;
 680         tbm_surface_queue_interface impl;
 681
 682         _init_test();
 683
 684         _queue_init(&surface_queue.free_queue);
 685         _queue_init(&surface_queue.dirty_queue);
 686         LIST_INITHEAD(&surface_queue.list);
 687         node.surface = &surface;
 688         LIST_ADD(&node.link, &surface_queue.list);
 689         surface_queue.impl = &impl;
 690         impl.release = &ut_release;
 691
 692         error = tbm_surface_queue_release(&surface_queue, &surface);
 693
 694         ASSERT_EQ(error, expected_error);
 695 }
 696
 697 TEST(tbm_surface_queue_release, work_flow_success_3)
 698 {
 699         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 700         tbm_surface_queue_error_e expected_error =
 701                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 702         tbm_surface_queue_s surface_queue;
 703         tbm_surface_s surface;
 704         queue_node node;
 705
 706         _init_test();
 707
 708         _queue_init(&surface_queue.free_queue);
 709         _queue_init(&surface_queue.dirty_queue);
 710         LIST_INITHEAD(&surface_queue.list);
 711         node.surface = &surface;
 712         LIST_ADD(&node.item_link, &surface_queue.dirty_queue.head);
 713
 714         error = tbm_surface_queue_release(&surface_queue, &surface);
 715
 716         ASSERT_EQ(error, expected_error);
 717 }
 718
 719 TEST(tbm_surface_queue_release, work_flow_success_2)
 720 {
 721         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 722         tbm_surface_queue_error_e expected_error =
 723                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 724         tbm_surface_queue_s surface_queue;
 725         tbm_surface_s surface;
 726         queue_node node;
 727
 728         _init_test();
 729
 730         _queue_init(&surface_queue.free_queue);
 731         _queue_init(&surface_queue.dirty_queue);
 732         LIST_INITHEAD(&surface_queue.list);
 733         node.surface = &surface;
 734         LIST_ADD(&node.item_link, &surface_queue.free_queue.head);
 735
 736         error = tbm_surface_queue_release(&surface_queue, &surface);
 737
 738         ASSERT_EQ(error, expected_error);
 739 }
 740
 741 TEST(tbm_surface_queue_release, work_flow_success_1)
 742 {
 743         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 744         tbm_surface_queue_error_e expected_error =
 745                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 746         tbm_surface_queue_s surface_queue;
 747         tbm_surface_s surface;
 748
 749         _init_test();
 750
 751         _queue_init(&surface_queue.free_queue);
 752         _queue_init(&surface_queue.dirty_queue);
 753         LIST_INITHEAD(&surface_queue.list);
 754
 755         error = tbm_surface_queue_release(&surface_queue, &surface);
 756
 757         ASSERT_EQ(error, expected_error);
 758 }
 759
 760 TEST(tbm_surface_queue_release, null_ptr_fail_2)
 761 {
 762         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 763         tbm_surface_queue_error_e expected_error =
 764                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 765         tbm_surface_queue_s surface_queue;
 766
 767         _init_test();
 768
 769         error = tbm_surface_queue_release(&surface_queue, NULL);
 770
 771         ASSERT_EQ(error, expected_error);
 772 }
 773
 774 TEST(tbm_surface_queue_release, null_ptr_fail_1)
 775 {
 776         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 777         tbm_surface_queue_error_e expected_error =
 778                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 779         tbm_surface_s surface;
 780
 781         _init_test();
 782
 783         error = tbm_surface_queue_release(NULL, &surface);
 784
 785         ASSERT_EQ(error, expected_error);
 786
 787 }
 788
 789 /* tbm_surface_queue_can_dequeue() */
 790
 791 TEST(tbm_surface_queue_can_dequeue, work_flow_success_3)
 792 {
 793         int actual = 0;
 794         int expected = 1;
 795         int wait = 0;
 796         tbm_surface_queue_s surface_queue;
 797         queue_node node;
 798
 799         _init_test();
 800
 801         LIST_INITHEAD(&surface_queue.free_queue.head);
 802         surface_queue.free_queue.count = 0;
 803         surface_queue.impl = NULL;
 804         LIST_INITHEAD(&surface_queue.free_queue.head);
 805         LIST_ADD(&node.item_link, &surface_queue.free_queue.head);
 806
 807         actual = tbm_surface_queue_can_dequeue(&surface_queue, wait);
 808
 809         ASSERT_EQ(actual, expected);
 810 }
 811
 812
 813 TEST(tbm_surface_queue_can_dequeue, work_flow_success_2)
 814 {
 815         int actual = 1;
 816         int expected = 0;
 817         int wait = 0;
 818         tbm_surface_queue_s surface_queue;
 819
 820         _init_test();
 821
 822         LIST_INITHEAD(&surface_queue.free_queue.head);
 823         surface_queue.free_queue.count = 0;
 824         surface_queue.impl = NULL;
 825
 826         actual = tbm_surface_queue_can_dequeue(&surface_queue, wait);
 827
 828         ASSERT_EQ(actual, expected);
 829 }
 830
 831
 832 TEST(tbm_surface_queue_can_dequeue, work_flow_success_1)
 833 {
 834         int actual = 0;
 835         int expected = 1;
 836         int wait = 2;
 837         tbm_surface_queue_s surface_queue;
 838
 839         _init_test();
 840
 841         LIST_INITHEAD(&surface_queue.free_queue.head);
 842         surface_queue.free_queue.count = 0;
 843         surface_queue.impl = NULL;
 844
 845         actual = tbm_surface_queue_can_dequeue(&surface_queue, wait);
 846
 847         ASSERT_EQ(actual, expected);
 848 }
 849
 850 TEST(tbm_surface_queue_can_dequeue, null_ptr_fail_1)
 851 {
 852         int actual = 1;
 853         int expected = 0;
 854
 855         _init_test();
 856
 857         actual = tbm_surface_queue_can_dequeue(NULL, 0);
 858
 859         ASSERT_EQ(actual, expected);
 860 }
 861
 862 /* tbm_surface_queue_dequeue() */
 863
 864 TEST(tbm_surface_queue_dequeue, work_flow_success_3)
 865 {
 866         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 867         tbm_surface_queue_error_e expected_error =
 868                         TBM_SURFACE_QUEUE_ERROR_NONE;
 869         tbm_surface_queue_s surface_queue;
 870         tbm_surface_s *surface;
 871         tbm_surface_s expected_surface;
 872         queue_node node;
 873
 874         _init_test();
 875
 876         surface_queue.impl = NULL;
 877         node.surface = &expected_surface;
 878         LIST_INITHEAD(&surface_queue.free_queue.head);
 879         LIST_ADD(&node.item_link, &surface_queue.free_queue.head);
 880
 881         error = tbm_surface_queue_dequeue(&surface_queue, &surface);
 882
 883         ASSERT_EQ(error, expected_error);
 884         ASSERT_TRUE(surface == &expected_surface);
 885 }
 886
 887 TEST(tbm_surface_queue_dequeue, work_flow_success_2)
 888 {
 889         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 890         tbm_surface_queue_error_e expected_error =
 891                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 892         tbm_surface_queue_s surface_queue;
 893         tbm_surface_s *surface;
 894         queue_node node;
 895
 896         _init_test();
 897
 898         surface_queue.impl = NULL;
 899         node.surface = NULL;
 900         LIST_INITHEAD(&surface_queue.free_queue.head);
 901         LIST_ADD(&node.item_link, &surface_queue.free_queue.head);
 902
 903         error = tbm_surface_queue_dequeue(&surface_queue, &surface);
 904
 905         ASSERT_EQ(error, expected_error);
 906 }
 907
 908 TEST(tbm_surface_queue_dequeue, work_flow_success_1)
 909 {
 910         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 911         tbm_surface_queue_error_e expected_error =
 912                         TBM_SURFACE_QUEUE_ERROR_EMPTY;
 913         tbm_surface_queue_s surface_queue;
 914         tbm_surface_s *surface;
 915         tbm_surface_queue_interface impl;
 916
 917         _init_test();
 918
 919         surface_queue.impl = &impl;
 920         impl.dequeue = ut_dequeue;
 921
 922         error = tbm_surface_queue_dequeue(&surface_queue, &surface);
 923
 924         ASSERT_EQ(error, expected_error);
 925 }
 926
 927 TEST(tbm_surface_queue_dequeue, null_ptr_fail_2)
 928 {
 929         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 930         tbm_surface_queue_error_e expected_error =
 931                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 932         tbm_surface_queue_s surface_queue;
 933
 934         _init_test();
 935
 936         error = tbm_surface_queue_dequeue(&surface_queue, NULL);
 937
 938         ASSERT_EQ(error, expected_error);
 939 }
 940
 941 TEST(tbm_surface_queue_dequeue, null_ptr_fail_1)
 942 {
 943         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
 944         tbm_surface_queue_error_e expected_error =
 945                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
 946         tbm_surface_s *surface;
 947
 948         _init_test();
 949
 950         error = tbm_surface_queue_dequeue(NULL, &surface);
 951
 952         ASSERT_EQ(error, expected_error);
 953 }
 954
 955 /* tbm_surface_queue_enqueue() */
 956
 957 TEST(tbm_surface_queue_enqueue, work_flow_success_5)
 958 {
 959         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 960         tbm_surface_queue_error_e expected_error =
 961                         TBM_SURFACE_QUEUE_ERROR_NONE;
 962         tbm_surface_queue_s surface_queue;
 963         tbm_surface_s surface;
 964         queue_node node;
 965
 966         _init_test();
 967
 968         node.surface = &surface;
 969         LIST_INITHEAD(&surface_queue.free_queue.head);
 970         LIST_INITHEAD(&surface_queue.dirty_queue.head);
 971         LIST_INITHEAD(&surface_queue.list);
 972         LIST_ADD(&node.link, &surface_queue.list);
 973         tbm_surface_queue_interface impl;
 974         surface_queue.impl = &impl;
 975         impl.enqueue = ut_enqueue;
 976         surface_queue.dirty_queue.count = 0;
 977         LIST_INITHEAD(&surface_queue.dirty_queue.head);
 978         LIST_INITHEAD(&surface_queue.acquirable_noti);
 979
 980         error = tbm_surface_queue_enqueue(&surface_queue, &surface);
 981
 982         ASSERT_EQ(error, expected_error);
 983 }
 984
 985 TEST(tbm_surface_queue_enqueue, work_flow_success_4)
 986 {
 987         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
 988         tbm_surface_queue_error_e expected_error =
 989                         TBM_SURFACE_QUEUE_ERROR_NONE;
 990         tbm_surface_queue_s surface_queue;
 991         tbm_surface_s surface;
 992         queue_node node;
 993
 994         _init_test();
 995
 996         node.surface = &surface;
 997         LIST_INITHEAD(&surface_queue.free_queue.head);
 998         LIST_INITHEAD(&surface_queue.dirty_queue.head);
 999         LIST_INITHEAD(&surface_queue.list);
1000         LIST_ADD(&node.link, &surface_queue.list);
1001         surface_queue.impl = NULL;
1002         surface_queue.dirty_queue.count = 0;
1003         LIST_INITHEAD(&surface_queue.dirty_queue.head);
1004         LIST_INITHEAD(&surface_queue.acquirable_noti);
1005
1006         error = tbm_surface_queue_enqueue(&surface_queue, &surface);
1007
1008         ASSERT_EQ(error, expected_error);
1009 }
1010
1011 TEST(tbm_surface_queue_enqueue, work_flow_success_3)
1012 {
1013         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1014         tbm_surface_queue_error_e expected_error =
1015                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
1016         tbm_surface_queue_s surface_queue;
1017         tbm_surface_s surface;
1018         queue_node node;
1019
1020         _init_test();
1021
1022         LIST_INITHEAD(&surface_queue.free_queue.head);
1023         LIST_INITHEAD(&surface_queue.dirty_queue.head);
1024         LIST_INITHEAD(&surface_queue.list);
1025         LIST_ADD(&node.item_link, &surface_queue.dirty_queue.head);
1026
1027         error = tbm_surface_queue_enqueue(&surface_queue, &surface);
1028
1029         ASSERT_EQ(error, expected_error);
1030 }
1031
1032 TEST(tbm_surface_queue_enqueue, work_flow_success_2)
1033 {
1034         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1035         tbm_surface_queue_error_e expected_error =
1036                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
1037         tbm_surface_queue_s surface_queue;
1038         tbm_surface_s surface;
1039         queue_node node;
1040
1041         _init_test();
1042
1043         LIST_INITHEAD(&surface_queue.free_queue.head);
1044         LIST_INITHEAD(&surface_queue.dirty_queue.head);
1045         LIST_INITHEAD(&surface_queue.list);
1046         LIST_ADD(&node.item_link, &surface_queue.free_queue.head);
1047
1048         error = tbm_surface_queue_enqueue(&surface_queue, &surface);
1049
1050         ASSERT_EQ(error, expected_error);
1051 }
1052
1053 TEST(tbm_surface_queue_enqueue, work_flow_success_1)
1054 {
1055         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1056         tbm_surface_queue_error_e expected_error =
1057                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
1058         tbm_surface_queue_s surface_queue;
1059         tbm_surface_s surface;
1060
1061         _init_test();
1062
1063         LIST_INITHEAD(&surface_queue.free_queue.head);
1064         LIST_INITHEAD(&surface_queue.dirty_queue.head);
1065         LIST_INITHEAD(&surface_queue.list);
1066
1067         error = tbm_surface_queue_enqueue(&surface_queue, &surface);
1068
1069         ASSERT_EQ(error, expected_error);
1070 }
1071
1072 TEST(tbm_surface_queue_enqueue, null_ptr_fail_2)
1073 {
1074         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1075         tbm_surface_queue_error_e expected_error =
1076                         TBM_SURFACE_QUEUE_ERROR_INVALID_SURFACE;
1077         tbm_surface_queue_s surface_queue;
1078
1079         _init_test();
1080
1081         error = tbm_surface_queue_enqueue(&surface_queue, NULL);
1082
1083         ASSERT_EQ(error, expected_error);
1084 }
1085
1086 TEST(tbm_surface_queue_enqueue, null_ptr_fail_1)
1087 {
1088         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1089         tbm_surface_queue_error_e expected_error =
1090                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1091         tbm_surface_s surface;
1092
1093         _init_test();
1094
1095         error = tbm_surface_queue_enqueue(NULL, &surface);
1096
1097         ASSERT_EQ(error, expected_error);
1098 }
1099
1100 /* tbm_surface_queue_remove_reset_cb() */
1101
1102 TEST(tbm_surface_queue_remove_reset_cb, work_flow_success_1)
1103 {
1104         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1105         tbm_surface_queue_error_e expected_error =
1106                         TBM_SURFACE_QUEUE_ERROR_NONE;
1107         tbm_surface_queue_s surface;
1108         queue_notify *item;
1109         int data;
1110         queue_notify *find_item;
1111         queue_notify *tmp;
1112
1113         _init_test();
1114
1115         item = (queue_notify *)calloc(1, sizeof(queue_notify));
1116         FREE_TESTED_PTR = item;
1117
1118         LIST_INITHEAD(&item->link);
1119         item->cb = ut_tbm_surface_queue_notify_cb;
1120         item->data = &data;
1121
1122         LIST_INITHEAD(&surface.reset_noti);
1123         LIST_ADDTAIL(&item->link, &surface.reset_noti);
1124
1125         find_item = NULL;
1126
1127         error = tbm_surface_queue_remove_reset_cb(&surface,
1128                                                                                          ut_tbm_surface_queue_notify_cb,
1129                                                                                          &data);
1130
1131         ASSERT_EQ(error, expected_error);
1132         if (!LIST_IS_EMPTY(&surface.reset_noti)) {
1133                 LIST_FOR_EACH_ENTRY_SAFE(find_item, tmp, &surface.reset_noti, link) {
1134                         if (find_item->data == &data)
1135                                 break;
1136                 }
1137         }
1138         ASSERT_TRUE(find_item == NULL);
1139         ASSERT_EQ(free_called_for_tested_ptr, 1);
1140 }
1141
1142 TEST(tbm_surface_queue_remove_reset_cb, null_ptr_fail_1)
1143 {
1144         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1145         tbm_surface_queue_error_e expected_error =
1146                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1147
1148         _init_test();
1149
1150         error = tbm_surface_queue_remove_reset_cb(NULL, NULL, NULL);
1151
1152         ASSERT_EQ(error, expected_error);
1153 }
1154
1155 /* tbm_surface_queue_add_reset_cb() */
1156
1157 TEST(tbm_surface_queue_add_reset_cb, work_flow_success_1)
1158 {
1159         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1160         tbm_surface_queue_error_e expected_error =
1161                         TBM_SURFACE_QUEUE_ERROR_NONE;
1162         tbm_surface_queue_s surface;
1163         int data;
1164         queue_notify *item;
1165         queue_notify *tmp;
1166
1167         _init_test();
1168
1169         LIST_INITHEAD(&surface.reset_noti);
1170
1171         error = tbm_surface_queue_add_reset_cb(&surface,
1172                                                                                          ut_tbm_surface_queue_notify_cb,
1173                                                                                          &data);
1174
1175         ASSERT_EQ(error, expected_error);
1176         if (!LIST_IS_EMPTY(&surface.reset_noti)) {
1177                 LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &surface.reset_noti, link) {
1178                         if (item->data == &data && item->cb == ut_tbm_surface_queue_notify_cb)
1179                                 break;
1180                 }
1181         }
1182         ASSERT_TRUE(item != NULL);
1183         free(item);
1184 }
1185
1186 TEST(tbm_surface_queue_add_reset_cb, null_ptr_fail_1)
1187 {
1188         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1189         tbm_surface_queue_error_e expected_error =
1190                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1191
1192         _init_test();
1193
1194         error = tbm_surface_queue_add_reset_cb(NULL, NULL, NULL);
1195
1196         ASSERT_EQ(error, expected_error);
1197 }
1198
1199 /* tbm_surface_queue_get_size() */
1200
1201 TEST(tbm_surface_queue_get_size, work_flow_success_1)
1202 {
1203         int size = 10;
1204         int expected_size = 1000;
1205         tbm_surface_queue_s surface;
1206
1207         _init_test();
1208
1209         surface.queue_size = expected_size;
1210
1211         size = tbm_surface_queue_get_size(&surface);
1212
1213         ASSERT_EQ(size, expected_size);
1214 }
1215
1216 TEST(tbm_surface_queue_get_size, null_ptr_fail_1)
1217 {
1218         int size = 10;
1219         int expected_size = 0;
1220
1221         _init_test();
1222
1223         size = tbm_surface_queue_get_size(NULL);
1224
1225         ASSERT_EQ(size, expected_size);
1226 }
1227
1228 /* tbm_surface_queue_get_format() */
1229
1230 TEST(tbm_surface_queue_get_format, work_flow_success_1)
1231 {
1232         int format = 10;
1233         int expected_format = 20;
1234         tbm_surface_queue_s surface;
1235
1236         _init_test();
1237
1238         surface.format = expected_format;
1239
1240         format = tbm_surface_queue_get_format(&surface);
1241
1242         ASSERT_EQ(format, expected_format);
1243 }
1244
1245 TEST(tbm_surface_queue_get_format, null_ptr_fail_1)
1246 {
1247         int format = 10;
1248         int expected_format = 0;
1249
1250         _init_test();
1251
1252         format = tbm_surface_queue_get_format(NULL);
1253
1254         ASSERT_EQ(format, expected_format);
1255 }
1256
1257 /* tbm_surface_queue_get_height() */
1258
1259 TEST(tbm_surface_queue_get_height, work_flow_success_1)
1260 {
1261         int height = 0;
1262         int expected_height = 50;
1263         tbm_surface_queue_s surface;
1264
1265         _init_test();
1266
1267         surface.height = expected_height;
1268
1269         height = tbm_surface_queue_get_height(&surface);
1270
1271         ASSERT_EQ(height, expected_height);
1272 }
1273
1274 TEST(tbm_surface_queue_get_height, null_ptr_fail_1)
1275 {
1276         int height = 10;
1277         int expected_height = 0;
1278
1279         _init_test();
1280
1281         height = tbm_surface_queue_get_height(NULL);
1282
1283         ASSERT_EQ(height, expected_height);
1284 }
1285
1286 /* tbm_surface_queue_get_width() */
1287
1288 TEST(tbm_surface_queue_get_width, work_flow_success_1)
1289 {
1290         int width = 0;
1291         int expected_width = 50;
1292         tbm_surface_queue_s surface;
1293
1294         _init_test();
1295
1296         surface.width = expected_width;
1297
1298         width = tbm_surface_queue_get_width(&surface);
1299
1300         ASSERT_EQ(width, expected_width);
1301 }
1302
1303 TEST(tbm_surface_queue_get_width, null_ptr_fail_1)
1304 {
1305         int width = 10;
1306         int expected_width = 0;
1307
1308         _init_test();
1309
1310         width = tbm_surface_queue_get_width(NULL);
1311
1312         ASSERT_EQ(width, expected_width);
1313 }
1314
1315 /* tbm_surface_queue_set_alloc_cb() */
1316
1317 TEST(tbm_surface_queue_set_alloc_cb, work_flow_success_1)
1318 {
1319         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1320         tbm_surface_queue_error_e expected_error =
1321                         TBM_SURFACE_QUEUE_ERROR_NONE;
1322         tbm_surface_queue_s surface;
1323         int data;
1324
1325         _init_test();
1326
1327         error = tbm_surface_queue_set_alloc_cb(&surface, ut_tbm_surface_alloc_cb,
1328                                                                                    ut_tbm_surface_free_cb, &data);
1329
1330         ASSERT_EQ(error, expected_error);
1331         ASSERT_TRUE(surface.alloc_cb == ut_tbm_surface_alloc_cb);
1332         ASSERT_TRUE(surface.free_cb == ut_tbm_surface_free_cb);
1333         ASSERT_TRUE(surface.alloc_cb_data == &data);
1334 }
1335
1336 TEST(tbm_surface_queue_set_alloc_cb, null_ptr_fail_1)
1337 {
1338         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1339         tbm_surface_queue_error_e expected_error =
1340                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1341
1342         _init_test();
1343
1344         error = tbm_surface_queue_set_alloc_cb(NULL, NULL, NULL, NULL);
1345
1346         ASSERT_EQ(error, expected_error);
1347 }
1348
1349 /* tbm_surface_queue_remove_acquirable_cb() */
1350
1351 TEST(tbm_surface_queue_remove_acquirable_cb, work_flow_success_1)
1352 {
1353         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1354         tbm_surface_queue_error_e expected_error =
1355                         TBM_SURFACE_QUEUE_ERROR_NONE;
1356         tbm_surface_queue_s surface;
1357         int data;
1358         queue_notify *item;
1359         queue_notify *find_item;
1360         queue_notify *tmp;
1361
1362         _init_test();
1363
1364         item = (queue_notify *)calloc(1, sizeof(queue_notify));
1365         FREE_TESTED_PTR = item;
1366
1367         LIST_INITHEAD(&item->link);
1368         item->cb = ut_tbm_surface_queue_notify_cb;
1369         item->data = &data;
1370
1371         LIST_INITHEAD(&surface.acquirable_noti);
1372         LIST_ADDTAIL(&item->link, &surface.acquirable_noti);
1373
1374         find_item = NULL;
1375
1376         error = tbm_surface_queue_remove_acquirable_cb(&surface,
1377                                                                                          ut_tbm_surface_queue_notify_cb,
1378                                                                                          &data);
1379
1380         ASSERT_EQ(error, expected_error);
1381         if (!LIST_IS_EMPTY(&surface.acquirable_noti)) {
1382                 LIST_FOR_EACH_ENTRY_SAFE(find_item, tmp, &surface.acquirable_noti, link) {
1383                         if (find_item->data == &data)
1384                                 break;
1385                 }
1386         }
1387         ASSERT_TRUE(find_item == NULL);
1388         ASSERT_EQ(free_called_for_tested_ptr, 1);
1389 }
1390
1391 TEST(tbm_surface_queue_remove_acquirable_cb, null_ptr_fail_1)
1392 {
1393         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1394         tbm_surface_queue_error_e expected_error =
1395                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1396
1397         _init_test();
1398
1399         error = tbm_surface_queue_remove_acquirable_cb(NULL, NULL, NULL);
1400
1401         ASSERT_EQ(error, expected_error);
1402 }
1403
1404 /* tbm_surface_queue_add_acquirable_cb() */
1405
1406 TEST(tbm_surface_queue_add_acquirable_cb, work_flow_success_1)
1407 {
1408         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1409         tbm_surface_queue_error_e expected_error =
1410                         TBM_SURFACE_QUEUE_ERROR_NONE;
1411         tbm_surface_queue_s surface;
1412         int data;
1413         queue_notify *item;
1414         queue_notify *tmp;
1415         tbm_surface_queue_notify_cb cb;
1416         tbm_surface_queue_notify_cb expected_cb;
1417
1418         _init_test();
1419
1420         LIST_INITHEAD(&surface.acquirable_noti);
1421
1422         error = tbm_surface_queue_add_acquirable_cb(&surface,
1423                                                                                          ut_tbm_surface_queue_notify_cb,
1424                                                                                          &data);
1425
1426         ASSERT_EQ(error, expected_error);
1427         if (!LIST_IS_EMPTY(&surface.acquirable_noti)) {
1428                 LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &surface.acquirable_noti, link) {
1429                         if (item->data == &data)
1430                                 break;
1431                 }
1432         }
1433         ASSERT_TRUE(item != NULL);
1434         cb = item->cb;
1435         expected_cb = ut_tbm_surface_queue_notify_cb;
1436         free(item);
1437         ASSERT_TRUE(cb == expected_cb);
1438 }
1439
1440 TEST(tbm_surface_queue_add_acquirable_cb, null_ptr_fail_1)
1441 {
1442         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1443         tbm_surface_queue_error_e expected_error =
1444                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1445
1446         _init_test();
1447
1448         error = tbm_surface_queue_add_acquirable_cb(NULL, NULL, NULL);
1449
1450         ASSERT_EQ(error, expected_error);
1451 }
1452
1453 /* tbm_surface_queue_remove_dequeuable_cb() */
1454
1455 TEST(tbm_surface_queue_remove_dequeuable_cb, work_flow_success_1)
1456 {
1457         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1458         tbm_surface_queue_error_e expected_error =
1459                         TBM_SURFACE_QUEUE_ERROR_NONE;
1460         tbm_surface_queue_s surface;
1461         int data;
1462         queue_notify *item;
1463         queue_notify *find_item;
1464         queue_notify *tmp;
1465
1466         _init_test();
1467
1468         item = (queue_notify *)calloc(1, sizeof(queue_notify));
1469         FREE_TESTED_PTR = item;
1470
1471         LIST_INITHEAD(&item->link);
1472         item->cb = ut_tbm_surface_queue_notify_cb;
1473         item->data = &data;
1474
1475         LIST_INITHEAD(&surface.dequeuable_noti);
1476         LIST_ADDTAIL(&item->link, &surface.dequeuable_noti);
1477
1478         find_item = NULL;
1479
1480         error = tbm_surface_queue_remove_dequeuable_cb(&surface,
1481                                                                                          ut_tbm_surface_queue_notify_cb,
1482                                                                                          &data);
1483
1484         ASSERT_EQ(error, expected_error);
1485         if (!LIST_IS_EMPTY(&surface.dequeuable_noti)) {
1486                 LIST_FOR_EACH_ENTRY_SAFE(find_item, tmp, &surface.dequeuable_noti, link) {
1487                         if (find_item->data == &data)
1488                                 break;
1489                 }
1490         }
1491         ASSERT_TRUE(find_item == NULL);
1492         ASSERT_EQ(free_called_for_tested_ptr, 1);
1493 }
1494
1495 TEST(tbm_surface_queue_remove_dequeuable_cb, null_ptr_fail_1)
1496 {
1497         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1498         tbm_surface_queue_error_e expected_error =
1499                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1500
1501         _init_test();
1502
1503         error = tbm_surface_queue_remove_dequeuable_cb(NULL, NULL, NULL);
1504
1505         ASSERT_EQ(error, expected_error);
1506 }
1507
1508 /* tbm_surface_queue_add_dequeuable_cb() */
1509
1510 TEST(tbm_surface_queue_add_dequeuable_cb, work_flow_success_1)
1511 {
1512         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1513         tbm_surface_queue_error_e expected_error =
1514                         TBM_SURFACE_QUEUE_ERROR_NONE;
1515         tbm_surface_queue_s surface;
1516         int data;
1517         queue_notify *item;
1518         queue_notify *tmp;
1519
1520         _init_test();
1521
1522         LIST_INITHEAD(&surface.dequeuable_noti);
1523
1524         error = tbm_surface_queue_add_dequeuable_cb(&surface,
1525                                                                                          ut_tbm_surface_queue_notify_cb,
1526                                                                                          &data);
1527
1528         ASSERT_EQ(error, expected_error);
1529         if (!LIST_IS_EMPTY(&surface.dequeuable_noti)) {
1530                 LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &surface.dequeuable_noti, link) {
1531                         if (item->data == &data)
1532                                 break;
1533                 }
1534         }
1535         ASSERT_TRUE(item != NULL);
1536         tbm_surface_queue_notify_cb cb = item->cb;
1537         tbm_surface_queue_notify_cb expected_cb = ut_tbm_surface_queue_notify_cb;
1538         free(item);
1539         ASSERT_TRUE(cb == expected_cb);
1540 }
1541
1542 TEST(tbm_surface_queue_add_dequeuable_cb, null_ptr_fail_1)
1543 {
1544         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1545         tbm_surface_queue_error_e expected_error =
1546                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1547
1548         _init_test();
1549
1550         error = tbm_surface_queue_add_dequeuable_cb(NULL, NULL, NULL);
1551
1552         ASSERT_EQ(error, expected_error);
1553 }
1554
1555 /* tbm_surface_queue_remove_destroy_cb() */
1556
1557 TEST(tbm_surface_queue_remove_destroy_cb, work_flow_success_1)
1558 {
1559         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1560         tbm_surface_queue_error_e expected_error =
1561                         TBM_SURFACE_QUEUE_ERROR_NONE;
1562         tbm_surface_queue_s surface;
1563         int data;
1564         queue_notify *item;
1565         queue_notify *find_item;
1566         queue_notify *tmp;
1567
1568         _init_test();
1569
1570         item = (queue_notify *)calloc(1, sizeof(queue_notify));
1571         FREE_TESTED_PTR = item;
1572
1573         LIST_INITHEAD(&item->link);
1574         item->cb = ut_tbm_surface_queue_notify_cb;
1575         item->data = &data;
1576
1577         LIST_INITHEAD(&surface.destory_noti);
1578         LIST_ADDTAIL(&item->link, &surface.destory_noti);
1579
1580         find_item = NULL;
1581
1582         error = tbm_surface_queue_remove_destroy_cb(&surface,
1583                                                                                          ut_tbm_surface_queue_notify_cb,
1584                                                                                          &data);
1585
1586         ASSERT_EQ(error, expected_error);
1587         if (!LIST_IS_EMPTY(&surface.destory_noti)) {
1588                 LIST_FOR_EACH_ENTRY_SAFE(find_item, tmp, &surface.destory_noti, link) {
1589                         if (find_item->data == &data)
1590                                 break;
1591                 }
1592         }
1593         ASSERT_TRUE(find_item == NULL);
1594         ASSERT_EQ(free_called_for_tested_ptr, 1);
1595 }
1596
1597 TEST(tbm_surface_queue_remove_destroy_cb, null_ptr_fail_1)
1598 {
1599         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1600         tbm_surface_queue_error_e expected_error =
1601                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1602
1603         _init_test();
1604
1605         error = tbm_surface_queue_remove_destroy_cb(NULL, NULL, NULL);
1606
1607         ASSERT_EQ(error, expected_error);
1608 }
1609
1610 /* tbm_surface_queue_add_destroy_cb() */
1611
1612 TEST(tbm_surface_queue_add_destroy_cb, work_flow_success_1)
1613 {
1614         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1615         tbm_surface_queue_error_e expected_error =
1616                         TBM_SURFACE_QUEUE_ERROR_NONE;
1617         tbm_surface_queue_s surface;
1618         int data;
1619         queue_notify *item;
1620         queue_notify *tmp;
1621         tbm_surface_queue_notify_cb cb;
1622         tbm_surface_queue_notify_cb expected_cb;
1623
1624         _init_test();
1625
1626         LIST_INITHEAD(&surface.destory_noti);
1627
1628         error = tbm_surface_queue_add_destroy_cb(&surface,
1629                                                                                          ut_tbm_surface_queue_notify_cb,
1630                                                                                          &data);
1631
1632         ASSERT_EQ(error, expected_error);
1633         if (!LIST_IS_EMPTY(&surface.destory_noti)) {
1634                 LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &surface.destory_noti, link) {
1635                         if (item->data == &data)
1636                                 break;
1637                 }
1638         }
1639         ASSERT_TRUE(item != NULL);
1640         cb = item->cb;
1641         expected_cb = ut_tbm_surface_queue_notify_cb;
1642         free(item);
1643         ASSERT_EQ(cb, expected_cb);
1644 }
1645
1646 TEST(tbm_surface_queue_add_destroy_cb, null_ptr_fail_1)
1647 {
1648         tbm_surface_queue_error_e error = TBM_SURFACE_QUEUE_ERROR_NONE;
1649         tbm_surface_queue_error_e expected_error =
1650                         TBM_SURFACE_QUEUE_ERROR_INVALID_QUEUE;
1651
1652         _init_test();
1653
1654         error = tbm_surface_queue_add_destroy_cb(NULL, NULL, NULL);
1655
1656         ASSERT_EQ(error, expected_error);
1657 }