ut/src/ut_tbm_surface_internal.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_bufmgr_int.h"
  32
  33 #include "pthread_stubs.h"
  34 #include "stdlib_stubs.h"
  35 #include "tbm_bufmgr_stubs.h"
  36
  37 /* HELPER FUNCTIONS */
  38
  39 #include "tbm_bufmgr.h"
  40
  41 static int UT_TBM_SURFACE_INTERNAL_ERROR = 0;
  42 static int ut_tbm_bo_unmap_count = 0;
  43
  44 static void ut_tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
  45 {
  46         (void)bufmgr;
  47 }
  48
  49 static int ut_surface_supported_format(uint32_t **formats,
  50                                                                            uint32_t *num)
  51 {
  52         (void)formats;
  53         (void)num;
  54
  55         if (UT_TBM_SURFACE_INTERNAL_ERROR) {
  56                 return 0;
  57         }
  58
  59         return 1;
  60 }
  61
  62 static tbm_bo_handle ut_tbm_bo_get_handle(tbm_bo bo, int device)
  63 {
  64         (void)bo;
  65         (void)device;
  66
  67         tbm_bo_handle ut_ret_handle;
  68         ut_ret_handle.s64 = 12;
  69
  70         return ut_ret_handle;
  71 }
  72
  73 static int ut_tbm_bo_unmap(tbm_bo bo)
  74 {
  75         (void)bo;
  76
  77         ut_tbm_bo_unmap_count++;
  78
  79         return 0;
  80 }
  81
  82 static int ut_surface_get_plane_data(int width, int height,
  83                                                                          tbm_format format, int plane_idx,
  84                                                                          uint32_t * size, uint32_t * offset,
  85                                                                          uint32_t * pitch, int *bo_idx)
  86 {
  87         (void)width;
  88         (void)height;
  89         (void)format;
  90         (void)plane_idx;
  91
  92         if (size)
  93                 *size = 4000;
  94
  95         if (offset)
  96                 *offset = 0;
  97
  98         if (pitch)
  99                 *pitch = 1000;
 100
 101         if (bo_idx)
 102                 *bo_idx = 0;
 103
 104         return 1;
 105 }
 106
 107 void *ut_surface_bo_alloc(tbm_bo bo, int width, int height, int format,
 108                                                   int flags, int bo_idx)
 109 {
 110         return (void *)0xefefeffe;
 111 }
 112
 113 #define pthread_mutex_lock ut_pthread_mutex_lock
 114 #define pthread_mutex_unlock ut_pthread_mutex_unlock
 115 #define pthread_mutex_init ut_pthread_mutex_init
 116 #define calloc ut_calloc
 117 #define free ut_free
 118 #define tbm_bufmgr_init ut_tbm_bufmgr_init
 119 #define tbm_bufmgr_deinit ut_tbm_bufmgr_deinit
 120 #define tbm_bo_get_handle ut_tbm_bo_get_handle
 121 #define tbm_bo_unmap ut_tbm_bo_unmap
 122 #define tbm_bufmgr_init ut_tbm_bufmgr_init
 123
 124 #include "tbm_surface_internal.c"
 125
 126 static void _init_test()
 127 {
 128         g_surface_bufmgr = NULL;
 129         PTHREAD_MUTEX_INIT_ERROR = 0;
 130         CALLOC_ERROR = 0;
 131         FREE_CALLED = 0;
 132         FREE_PTR = NULL;
 133         FREE_TESTED_PTR = NULL;
 134         free_called_for_tested_ptr = 0;
 135         free_call_count = 0;
 136         GETENV_ERROR = 0;
 137         UT_TBM_SURFACE_INTERNAL_ERROR = 0;
 138         ut_tbm_bo_unmap_count = 0;
 139         ut_tbm_data_free_called = 0;
 140         ut_tbm_bufmgr_init_error = 0;
 141 }
 142
 143 /* tbm_surface_internal_delete_user_data() */
 144
 145 TEST(tbm_surface_internal_delete_user_data, work_flow_success_4)
 146 {
 147         int ret = 0;
 148         int expected_ret = 1;
 149         struct _tbm_surface surface;
 150         struct _tbm_bufmgr bufmgr;
 151         unsigned long key = 1;
 152         int data;
 153
 154         _init_test();
 155
 156         g_surface_bufmgr = &bufmgr;
 157         LIST_INITHEAD(&bufmgr.surf_list);
 158         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 159         LIST_INITHEAD(&surface.user_data_list);
 160
 161         tbm_user_data *old_data = (tbm_user_data *) calloc(1, sizeof(*old_data));
 162         old_data->data = &data;
 163         old_data->free_func = ut_tbm_data_free;
 164         old_data->key = key;
 165         LIST_ADD(&old_data->item_link, &surface.user_data_list);
 166         FREE_TESTED_PTR = old_data;
 167
 168         ret = tbm_surface_internal_delete_user_data(&surface, key);
 169
 170         ASSERT_EQ(ret, expected_ret);
 171         ASSERT_EQ(free_called_for_tested_ptr, 1);
 172         ASSERT_EQ(ut_tbm_data_free_called, 1);
 173 }
 174
 175 TEST(tbm_surface_internal_delete_user_data, work_flow_success_3)
 176 {
 177         int ret = 1;
 178         int expected_ret = 0;
 179         struct _tbm_surface surface;
 180         struct _tbm_bufmgr bufmgr;
 181         unsigned long key = 1;
 182         tbm_user_data old_data;
 183
 184         _init_test();
 185
 186         g_surface_bufmgr = &bufmgr;
 187         LIST_INITHEAD(&bufmgr.surf_list);
 188         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 189         LIST_INITHEAD(&surface.user_data_list);
 190
 191         old_data.key = key + 1;
 192         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 193
 194         ret = tbm_surface_internal_delete_user_data(&surface, key);
 195
 196         ASSERT_EQ(ret, expected_ret);
 197 }
 198
 199 TEST(tbm_surface_internal_delete_user_data, work_flow_success_2)
 200 {
 201         int ret = 1;
 202         int expected_ret = 0;
 203         struct _tbm_surface surface;
 204         struct _tbm_bufmgr bufmgr;
 205
 206         _init_test();
 207
 208         g_surface_bufmgr = &bufmgr;
 209         LIST_INITHEAD(&bufmgr.surf_list);
 210         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 211         LIST_INITHEAD(&surface.user_data_list);
 212
 213         ret = tbm_surface_internal_delete_user_data(&surface, 1);
 214
 215         ASSERT_EQ(ret, expected_ret);
 216 }
 217
 218 TEST(tbm_surface_internal_delete_user_data, work_flow_success_1)
 219 {
 220         int ret = 1;
 221         int expected_ret = 0;
 222         struct _tbm_surface surface;
 223         struct _tbm_bufmgr bufmgr;
 224
 225         _init_test();
 226
 227         g_surface_bufmgr = &bufmgr;
 228         LIST_INITHEAD(&bufmgr.surf_list);
 229
 230         ret = tbm_surface_internal_delete_user_data(&surface, 1);
 231
 232         ASSERT_EQ(ret, expected_ret);
 233 }
 234
 235 TEST(tbm_surface_internal_delete_user_data, null_ptr_fail_1)
 236 {
 237         int ret = 1;
 238         int expected_ret = 0;
 239
 240         _init_test();
 241
 242         ret = tbm_surface_internal_delete_user_data(NULL, 1);
 243
 244         ASSERT_EQ(ret, expected_ret);
 245 }
 246
 247 /* tbm_surface_internal_get_user_data() */
 248
 249 TEST(tbm_surface_internal_get_user_data, work_flow_success_4)
 250 {
 251         int ret = 0;
 252         int expected_ret = 1;
 253         unsigned long key = 1;
 254         void *data;
 255         struct _tbm_surface surface;
 256         struct _tbm_bufmgr bufmgr;
 257         int expected_data = 6;
 258
 259         _init_test();
 260
 261         g_surface_bufmgr = &bufmgr;
 262         LIST_INITHEAD(&bufmgr.surf_list);
 263         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 264         LIST_INITHEAD(&surface.user_data_list);
 265
 266         tbm_user_data old_data;
 267         old_data.data = &expected_data;
 268         old_data.key = key;
 269         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 270
 271         ret = tbm_surface_internal_get_user_data(&surface, key, &data);
 272
 273         ASSERT_EQ(ret, expected_ret);
 274         ASSERT_TRUE(data == &expected_data);
 275 }
 276
 277 TEST(tbm_surface_internal_get_user_data, work_flow_success_3)
 278 {
 279         int ret = 1;
 280         int expected_ret = 0;
 281         unsigned long key = 1;
 282         void *data;
 283         struct _tbm_surface surface;
 284         struct _tbm_bufmgr bufmgr;
 285         tbm_user_data old_data;
 286
 287         _init_test();
 288
 289         g_surface_bufmgr = &bufmgr;
 290         LIST_INITHEAD(&bufmgr.surf_list);
 291         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 292         LIST_INITHEAD(&surface.user_data_list);
 293
 294         old_data.key = key + 1;
 295         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 296
 297         ret = tbm_surface_internal_get_user_data(&surface, key, &data);
 298
 299         ASSERT_EQ(ret, expected_ret);
 300 }
 301
 302 TEST(tbm_surface_internal_get_user_data, work_flow_success_2)
 303 {
 304         int ret = 1;
 305         int expected_ret = 0;
 306         unsigned long key = 1;
 307         void *data;
 308         struct _tbm_surface surface;
 309         struct _tbm_bufmgr bufmgr;
 310
 311         _init_test();
 312
 313         g_surface_bufmgr = &bufmgr;
 314         LIST_INITHEAD(&bufmgr.surf_list);
 315         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 316         LIST_INITHEAD(&surface.user_data_list);
 317
 318         ret = tbm_surface_internal_get_user_data(&surface, key, &data);
 319
 320         ASSERT_EQ(ret, expected_ret);
 321 }
 322
 323 TEST(tbm_surface_internal_get_user_data, work_flow_success_1)
 324 {
 325         int ret = 1;
 326         int expected_ret = 0;
 327         unsigned long key = 1;
 328         void *data;
 329         struct _tbm_surface surface;
 330         struct _tbm_bufmgr bufmgr;
 331
 332         _init_test();
 333
 334         g_surface_bufmgr = &bufmgr;
 335         LIST_INITHEAD(&bufmgr.surf_list);
 336         LIST_INITHEAD(&surface.user_data_list);
 337
 338         ret = tbm_surface_internal_get_user_data(&surface, key, &data);
 339
 340         ASSERT_EQ(ret, expected_ret);
 341 }
 342
 343 TEST(tbm_surface_internal_get_user_data, null_ptr_fail_2)
 344 {
 345         int ret = 1;
 346         int expected_ret = 0;
 347         unsigned long key = 1;
 348         struct _tbm_surface surface;
 349         struct _tbm_bufmgr bufmgr;
 350
 351         _init_test();
 352
 353         g_surface_bufmgr = &bufmgr;
 354         LIST_INITHEAD(&bufmgr.surf_list);
 355         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 356         LIST_INITHEAD(&surface.user_data_list);
 357
 358         ret = tbm_surface_internal_get_user_data(&surface, key, NULL);
 359
 360         ASSERT_EQ(ret, expected_ret);
 361 }
 362
 363 TEST(tbm_surface_internal_get_user_data, null_ptr_fail_1)
 364 {
 365         int ret = 1;
 366         int expected_ret = 0;
 367         unsigned long key = 1;
 368         void *data;
 369
 370         _init_test();
 371
 372         ret = tbm_surface_internal_get_user_data(NULL, key, &data);
 373
 374         ASSERT_EQ(ret, expected_ret);
 375 }
 376
 377 /* tbm_surface_internal_set_user_data() */
 378
 379 TEST(tbm_surface_internal_set_user_data, work_flow_success_4)
 380 {
 381         int ret = 0;
 382         int expected_ret = 1;
 383         unsigned long key = 1;
 384         int data;
 385         struct _tbm_surface surface;
 386         struct _tbm_bufmgr bufmgr;
 387         tbm_user_data old_data;
 388
 389         _init_test();
 390
 391         g_surface_bufmgr = &bufmgr;
 392         LIST_INITHEAD(&bufmgr.surf_list);
 393         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 394
 395         old_data.data = &data;
 396         old_data.free_func = ut_tbm_data_free;
 397         old_data.key = key;
 398         LIST_INITHEAD(&surface.user_data_list);
 399         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 400
 401         ret = tbm_surface_internal_set_user_data(&surface, key, &data);
 402
 403         ASSERT_EQ(ret, expected_ret);
 404         ASSERT_TRUE(old_data.data == &data);
 405         ASSERT_EQ(ut_tbm_data_free_called, 1);
 406 }
 407
 408 TEST(tbm_surface_internal_set_user_data, work_flow_success_3)
 409 {
 410         int ret = 0;
 411         int expected_ret = 1;
 412         unsigned long key = 1;
 413         int data;
 414         struct _tbm_surface surface;
 415         struct _tbm_bufmgr bufmgr;
 416         tbm_user_data old_data;
 417
 418         _init_test();
 419
 420         g_surface_bufmgr = &bufmgr;
 421         LIST_INITHEAD(&bufmgr.surf_list);
 422         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 423
 424         old_data.data = NULL;
 425         old_data.free_func = NULL;
 426         old_data.key = key;
 427         LIST_INITHEAD(&surface.user_data_list);
 428         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 429
 430         ret = tbm_surface_internal_set_user_data(&surface, key, &data);
 431
 432         ASSERT_EQ(ret, expected_ret);
 433         ASSERT_TRUE(old_data.data == &data);
 434 }
 435
 436 TEST(tbm_surface_internal_set_user_data, work_flow_success_2)
 437 {
 438         int ret = 1;
 439         int expected_ret = 0;
 440         unsigned long key = 1;
 441         int data;
 442         struct _tbm_surface surface;
 443         struct _tbm_bufmgr bufmgr;
 444         tbm_user_data old_data;
 445
 446         _init_test();
 447
 448         g_surface_bufmgr = &bufmgr;
 449         LIST_INITHEAD(&bufmgr.surf_list);
 450         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 451
 452         old_data.key = key + 1;
 453         LIST_INITHEAD(&surface.user_data_list);
 454         LIST_ADD(&old_data.item_link, &surface.user_data_list);
 455
 456         ret = tbm_surface_internal_set_user_data(&surface, key, &data);
 457
 458         ASSERT_EQ(ret, expected_ret);
 459 }
 460
 461 TEST(tbm_surface_internal_set_user_data, work_flow_success_1)
 462 {
 463         int ret = 1;
 464         int expected_ret = 0;
 465         unsigned long key = 1;
 466         int data;
 467         struct _tbm_surface surface;
 468         struct _tbm_bufmgr bufmgr;
 469
 470         _init_test();
 471
 472         g_surface_bufmgr = &bufmgr;
 473         LIST_INITHEAD(&bufmgr.surf_list);
 474
 475         ret = tbm_surface_internal_set_user_data(&surface, key, &data);
 476
 477         ASSERT_EQ(ret, expected_ret);
 478 }
 479
 480 TEST(tbm_surface_internal_set_user_data, null_ptr_fail_1)
 481 {
 482         int ret = 1;
 483         int expected_ret = 0;
 484         unsigned long key = 1;
 485         int data;
 486
 487         _init_test();
 488
 489         ret = tbm_surface_internal_set_user_data(NULL, key, &data);
 490
 491         ASSERT_EQ(ret, expected_ret);
 492 }
 493
 494 /* tbm_surface_internal_add_user_data() */
 495
 496 TEST(tbm_surface_internal_add_user_data, work_flow_success_4)
 497 {
 498         int ret = 0;
 499         int expected_ret = 1;
 500         unsigned long key = 1;
 501         struct _tbm_surface surface;
 502         struct _tbm_bufmgr bufmgr;
 503         tbm_user_data data;
 504         tbm_user_data *added_data;
 505
 506         _init_test();
 507
 508         g_surface_bufmgr = &bufmgr;
 509         LIST_INITHEAD(&bufmgr.surf_list);
 510         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 511
 512         data.key = key + 1;
 513         LIST_INITHEAD(&surface.user_data_list);
 514         LIST_ADD(&data.item_link, &surface.user_data_list);
 515
 516         ret = tbm_surface_internal_add_user_data(&surface, key, ut_tbm_data_free);
 517
 518         ASSERT_EQ(ret, expected_ret);
 519
 520         added_data = user_data_lookup(&surface.user_data_list, key);
 521
 522         ASSERT_TRUE(added_data != NULL);
 523
 524         tbm_user_data copy_data = *added_data;
 525         free(added_data);
 526
 527         ASSERT_EQ(copy_data.key, key);
 528         ASSERT_TRUE(copy_data.free_func == ut_tbm_data_free);
 529         ASSERT_TRUE(copy_data.data == NULL);
 530 }
 531
 532 TEST(tbm_surface_internal_add_user_data, work_flow_success_3)
 533 {
 534         int ret = 0;
 535         int expected_ret = 0;
 536         unsigned long key = 1;
 537         struct _tbm_surface surface;
 538         struct _tbm_bufmgr bufmgr;
 539         tbm_user_data data;
 540
 541         _init_test();
 542
 543         g_surface_bufmgr = &bufmgr;
 544         LIST_INITHEAD(&bufmgr.surf_list);
 545         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 546
 547         data.key = key + 1;
 548         LIST_INITHEAD(&surface.user_data_list);
 549         LIST_ADD(&data.item_link, &surface.user_data_list);
 550         CALLOC_ERROR = 1;
 551
 552         ret = tbm_surface_internal_add_user_data(&surface, key, ut_tbm_data_free);
 553
 554         ASSERT_EQ(ret, expected_ret);
 555 }
 556
 557 TEST(tbm_surface_internal_add_user_data, work_flow_success_2)
 558 {
 559         int ret = 0;
 560         int expected_ret = 0;
 561         unsigned long key = 1;
 562         struct _tbm_surface surface;
 563         struct _tbm_bufmgr bufmgr;
 564         tbm_user_data data;
 565
 566         _init_test();
 567
 568         g_surface_bufmgr = &bufmgr;
 569         LIST_INITHEAD(&bufmgr.surf_list);
 570         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 571
 572         data.key = key;
 573         LIST_INITHEAD(&surface.user_data_list);
 574         LIST_ADD(&data.item_link, &surface.user_data_list);
 575
 576         ret = tbm_surface_internal_add_user_data(&surface, key, ut_tbm_data_free);
 577
 578         ASSERT_EQ(ret, expected_ret);
 579 }
 580
 581 TEST(tbm_surface_internal_add_user_data, work_flow_success_1)
 582 {
 583         int ret = 0;
 584         int expected_ret = 0;
 585         unsigned long key = 0;
 586         struct _tbm_surface surface;
 587         struct _tbm_bufmgr bufmgr;
 588
 589         _init_test();
 590
 591         g_surface_bufmgr = &bufmgr;
 592         LIST_INITHEAD(&bufmgr.surf_list);
 593
 594         ret = tbm_surface_internal_add_user_data(&surface, key, ut_tbm_data_free);
 595
 596         ASSERT_EQ(ret, expected_ret);
 597 }
 598
 599 TEST(tbm_surface_internal_add_user_data, null_ptr_fail_1)
 600 {
 601         int ret = 0;
 602         int expected_ret = 0;
 603         unsigned long key = 0;
 604
 605         _init_test();
 606
 607         ret = tbm_surface_internal_add_user_data(NULL, key, ut_tbm_data_free);
 608
 609         ASSERT_EQ(ret, expected_ret);
 610 }
 611
 612 /* tbm_surface_internal_set_debug_pid() */
 613
 614 TEST(tbm_surface_internal_set_debug_pid, work_flow_success_1)
 615 {
 616         unsigned int pid = 20;
 617         struct _tbm_surface surface;
 618         struct _tbm_bufmgr bufmgr;
 619
 620         _init_test();
 621
 622         g_surface_bufmgr = &bufmgr;
 623         LIST_INITHEAD(&bufmgr.surf_list);
 624         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 625
 626         tbm_surface_internal_set_debug_pid(&surface, pid);
 627
 628         ASSERT_EQ(pid, surface.debug_pid);
 629 }
 630
 631 /* tbm_surface_internal_get_plane_bo_idx() */
 632
 633 TEST(tbm_surface_internal_get_plane_bo_idx, work_flow_success_3)
 634 {
 635         int actual = 1;
 636         int plane_idx = 0;
 637         int expected_bo_idx = 10;
 638         struct _tbm_surface surface;
 639         struct _tbm_bufmgr bufmgr;
 640
 641         _init_test();
 642
 643         surface.planes_bo_idx[plane_idx] = expected_bo_idx;
 644         g_surface_bufmgr = &bufmgr;
 645         LIST_INITHEAD(&bufmgr.surf_list);
 646         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 647
 648         actual = tbm_surface_internal_get_plane_bo_idx(&surface, plane_idx);
 649
 650         ASSERT_EQ(actual, expected_bo_idx);
 651 }
 652
 653 TEST(tbm_surface_internal_get_plane_bo_idx, work_flow_success_2)
 654 {
 655         int actual = 1;
 656         int expected = 0;
 657         int plane_idx = -1;
 658         struct _tbm_surface surface;
 659         struct _tbm_bufmgr bufmgr;
 660
 661         _init_test();
 662
 663         g_surface_bufmgr = &bufmgr;
 664         LIST_INITHEAD(&bufmgr.surf_list);
 665         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 666
 667         actual = tbm_surface_internal_get_plane_bo_idx(&surface, plane_idx);
 668
 669         ASSERT_EQ(actual, expected);
 670 }
 671
 672 TEST(tbm_surface_internal_get_plane_bo_idx, work_flow_success_1)
 673 {
 674         int actual = 1;
 675         int expected = 0;
 676         struct _tbm_surface surface;
 677         struct _tbm_bufmgr bufmgr;
 678
 679         _init_test();
 680
 681         g_surface_bufmgr = &bufmgr;
 682         LIST_INITHEAD(&bufmgr.surf_list);
 683
 684         actual = tbm_surface_internal_get_plane_bo_idx(&surface, 0);
 685
 686         ASSERT_EQ(actual, expected);
 687 }
 688
 689 TEST(tbm_surface_internal_get_plane_bo_idx, null_ptr_fail_1)
 690 {
 691         _init_test();
 692         int actual = 1;
 693         int expected = 0;
 694
 695         actual = tbm_surface_internal_get_plane_bo_idx(NULL, 0);
 696
 697         ASSERT_EQ(actual, expected);
 698 }
 699
 700 /* tbm_surface_internal_get_format() */
 701
 702 TEST(tbm_surface_internal_get_format, work_flow_success_2)
 703 {
 704         unsigned int actual = 1;
 705         int expected_format = 768;
 706         struct _tbm_surface surface;
 707         struct _tbm_bufmgr bufmgr;
 708
 709         _init_test();
 710
 711         g_surface_bufmgr = &bufmgr;
 712         LIST_INITHEAD(&bufmgr.surf_list);
 713         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 714         surface.info.format = expected_format;
 715
 716         actual = tbm_surface_internal_get_format(&surface);
 717
 718         ASSERT_EQ(actual, expected_format);
 719 }
 720
 721 TEST(tbm_surface_internal_get_format, work_flow_success_1)
 722 {
 723         unsigned int actual = 1;
 724         unsigned int expected = 0;
 725         struct _tbm_surface surface;
 726         struct _tbm_bufmgr bufmgr;
 727
 728         _init_test();
 729
 730         g_surface_bufmgr = &bufmgr;
 731         LIST_INITHEAD(&bufmgr.surf_list);
 732
 733         actual = tbm_surface_internal_get_format(&surface);
 734
 735         ASSERT_EQ(actual, expected);
 736 }
 737
 738 TEST(tbm_surface_internal_get_format, null_ptr_fail_1)
 739 {
 740         unsigned int actual = 1;
 741         unsigned int expected = 0;
 742
 743         _init_test();
 744
 745         actual = tbm_surface_internal_get_format(NULL);
 746
 747         ASSERT_EQ(actual, expected);
 748 }
 749
 750 /* tbm_surface_internal_get_height() */
 751
 752 TEST(tbm_surface_internal_get_height, work_flow_success_2)
 753 {
 754         unsigned int actual = 1;
 755         int expected_height = 768;
 756         struct _tbm_surface surface;
 757         struct _tbm_bufmgr bufmgr;
 758
 759         _init_test();
 760
 761         g_surface_bufmgr = &bufmgr;
 762         LIST_INITHEAD(&bufmgr.surf_list);
 763         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 764         surface.info.height = expected_height;
 765
 766         actual = tbm_surface_internal_get_height(&surface);
 767
 768         ASSERT_EQ(actual, expected_height);
 769 }
 770
 771 TEST(tbm_surface_internal_get_height, work_flow_success_1)
 772 {
 773         unsigned int actual = 1;
 774         unsigned int expected = 0;
 775         struct _tbm_surface surface;
 776         struct _tbm_bufmgr bufmgr;
 777
 778         _init_test();
 779
 780         g_surface_bufmgr = &bufmgr;
 781         LIST_INITHEAD(&bufmgr.surf_list);
 782
 783         actual = tbm_surface_internal_get_height(&surface);
 784
 785         ASSERT_EQ(actual, expected);
 786 }
 787
 788 TEST(tbm_surface_internal_get_height, null_ptr_fail_1)
 789 {
 790         unsigned int actual = 1;
 791         unsigned int expected = 0;
 792
 793         _init_test();
 794
 795         actual = tbm_surface_internal_get_height(NULL);
 796
 797         ASSERT_EQ(actual, expected);
 798 }
 799
 800 /* tbm_surface_internal_get_width() */
 801
 802 TEST(tbm_surface_internal_get_width, work_flow_success_2)
 803 {
 804         unsigned int actual = 1;
 805         int expected_width = 1024;
 806         struct _tbm_surface surface;
 807         struct _tbm_bufmgr bufmgr;
 808
 809         _init_test();
 810
 811         g_surface_bufmgr = &bufmgr;
 812         LIST_INITHEAD(&bufmgr.surf_list);
 813         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 814         surface.info.width = expected_width;
 815
 816         actual = tbm_surface_internal_get_width(&surface);
 817
 818         ASSERT_EQ(actual, expected_width);
 819 }
 820
 821 TEST(tbm_surface_internal_get_width, work_flow_success_1)
 822 {
 823         unsigned int actual = 1;
 824         unsigned int expected = 0;
 825         struct _tbm_surface surface;
 826         struct _tbm_bufmgr bufmgr;
 827
 828         _init_test();
 829
 830         g_surface_bufmgr = &bufmgr;
 831         LIST_INITHEAD(&bufmgr.surf_list);
 832
 833         actual = tbm_surface_internal_get_width(&surface);
 834
 835         ASSERT_EQ(actual, expected);
 836 }
 837
 838 TEST(tbm_surface_internal_get_width, null_ptr_fail_1)
 839 {
 840         unsigned int actual = 1;
 841         unsigned int expected = 0;
 842
 843         _init_test();
 844
 845         actual = tbm_surface_internal_get_width(NULL);
 846
 847         ASSERT_EQ(actual, expected);
 848 }
 849
 850 /* tbm_surface_internal_unmap() */
 851
 852 TEST(tbm_surface_internal_unmap, work_flow_success_1)
 853 {
 854         struct _tbm_surface surface;
 855         int count = 10;
 856         struct _tbm_bufmgr bufmgr;
 857
 858         _init_test();
 859
 860         surface.num_bos = count;
 861         g_surface_bufmgr = &bufmgr;
 862         LIST_INITHEAD(&bufmgr.surf_list);
 863         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 864
 865         tbm_surface_internal_unmap(&surface);
 866
 867         ASSERT_EQ(ut_tbm_bo_unmap_count, count);
 868 }
 869
 870 /* tbm_surface_internal_get_info() */
 871
 872 TEST(tbm_surface_internal_get_info, work_flow_success_2)
 873 {
 874         int ret = 0;
 875         int expected_ret = 1;
 876         tbm_surface_info_s info;
 877         struct _tbm_surface surface;
 878         struct _tbm_bufmgr bufmgr;
 879
 880         _init_test();
 881
 882         surface.info.num_planes = 0;
 883         g_surface_bufmgr = &bufmgr;
 884         LIST_INITHEAD(&bufmgr.surf_list);
 885         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 886         uint32_t expected_width = 2;
 887         uint32_t expected_height = 3;
 888         uint32_t expected_format = 4;
 889         uint32_t expected_bpp = 5;
 890         uint32_t expected_size = 6;
 891         surface.info.width = expected_width;
 892         surface.info.height = expected_height;
 893         surface.info.format = expected_format;
 894         surface.info.bpp = expected_bpp;
 895         surface.info.size = expected_size;
 896         surface.info.num_planes = 0;
 897         surface.num_bos = 1;
 898
 899         ret = tbm_surface_internal_get_info(&surface, 1, &info, 2);
 900
 901         ASSERT_EQ(ret, expected_ret);
 902         ASSERT_EQ(info.width, expected_width);
 903         ASSERT_EQ(info.height, expected_height);
 904         ASSERT_EQ(info.format, expected_format);
 905         ASSERT_EQ(info.bpp, expected_bpp);
 906         ASSERT_EQ(info.size, expected_size);
 907 }
 908
 909 TEST(tbm_surface_internal_get_info, work_flow_success_1)
 910 {
 911         int ret = 1;
 912         int expected_ret = 0;
 913         tbm_surface_info_s info;
 914         struct _tbm_surface surface;
 915         struct _tbm_bufmgr bufmgr;
 916
 917         _init_test();
 918
 919         g_surface_bufmgr = &bufmgr;
 920         LIST_INITHEAD(&bufmgr.surf_list);
 921
 922         ret = tbm_surface_internal_get_info(&surface, 1, &info, 1);
 923
 924         ASSERT_EQ(ret, expected_ret);
 925 }
 926
 927 TEST(tbm_surface_internal_get_info, null_ptr_fail_1)
 928 {
 929         int ret = 1;
 930         int expected_ret = 0;
 931         tbm_surface_info_s info;
 932
 933         _init_test();
 934
 935         ret = tbm_surface_internal_get_info(NULL, 1, &info, 1);
 936
 937         ASSERT_EQ(ret, expected_ret);
 938 }
 939
 940 /* tbm_surface_internal_get_plane_data() */
 941
 942 TEST(tbm_surface_internal_get_plane_data, work_flow_success_4)
 943 {
 944         int ret = 0;
 945         int expected_ret = 1;
 946         int plane_idx = 0;
 947         uint32_t size = 0;
 948         uint32_t offset = 0;
 949         uint32_t pitch = 0;
 950         uint32_t expected_size = 1024;
 951         uint32_t expected_offset = 10;
 952         uint32_t expected_pitch = 20;
 953         struct _tbm_surface surface;
 954         struct _tbm_bufmgr bufmgr;
 955
 956         _init_test();
 957
 958         surface.info.planes[plane_idx].size = expected_size;
 959         surface.info.planes[plane_idx].offset = expected_offset;
 960         surface.info.planes[plane_idx].stride = expected_pitch;
 961         g_surface_bufmgr = &bufmgr;
 962         LIST_INITHEAD(&bufmgr.surf_list);
 963         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 964         surface.info.num_planes = 1;
 965
 966         ret = tbm_surface_internal_get_plane_data(&surface, plane_idx, &size,
 967                                                                                           &offset, &pitch);
 968
 969         ASSERT_EQ(ret, expected_ret);
 970         ASSERT_EQ(size, expected_size);
 971         ASSERT_EQ(offset, expected_offset);
 972         ASSERT_EQ(pitch, expected_pitch);
 973 }
 974
 975 TEST(tbm_surface_internal_get_plane_data, work_flow_success_3)
 976 {
 977         int ret = 0;
 978         int expected_ret = 0;
 979         int plane_idx = 3;
 980         uint32_t size = 0;
 981         uint32_t offset = 0;
 982         uint32_t pitch = 0;
 983         struct _tbm_surface surface;
 984         struct _tbm_bufmgr bufmgr;
 985
 986         _init_test();
 987
 988         g_surface_bufmgr = &bufmgr;
 989         LIST_INITHEAD(&bufmgr.surf_list);
 990         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
 991         surface.info.num_planes = plane_idx - 1;
 992
 993         ret = tbm_surface_internal_get_plane_data(&surface, plane_idx, &size,
 994                                                                                           &offset, &pitch);
 995
 996         ASSERT_EQ(ret, expected_ret);
 997 }
 998
 999 TEST(tbm_surface_internal_get_plane_data, work_flow_success_2)
1000 {
1001         int ret = 0;
1002         int expected_ret = 0;
1003         int plane_idx = -1;
1004         uint32_t size = 0;
1005         uint32_t offset = 0;
1006         uint32_t pitch = 0;
1007         struct _tbm_surface surface;
1008         struct _tbm_bufmgr bufmgr;
1009
1010         _init_test();
1011
1012         g_surface_bufmgr = &bufmgr;
1013         LIST_INITHEAD(&bufmgr.surf_list);
1014         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1015
1016         ret = tbm_surface_internal_get_plane_data(&surface, plane_idx, &size,
1017                                                                                           &offset, &pitch);
1018
1019         ASSERT_EQ(ret, expected_ret);
1020 }
1021
1022 TEST(tbm_surface_internal_get_plane_data, work_flow_success_1)
1023 {
1024         int ret = 0;
1025         int expected_ret = 0;
1026         uint32_t size = 0;
1027         uint32_t offset = 0;
1028         uint32_t pitch = 0;
1029         struct _tbm_surface surface;
1030         struct _tbm_bufmgr bufmgr;
1031
1032         _init_test();
1033
1034         g_surface_bufmgr = &bufmgr;
1035         LIST_INITHEAD(&bufmgr.surf_list);
1036
1037         ret = tbm_surface_internal_get_plane_data(&surface, 1, &size,
1038                                                                                           &offset, &pitch);
1039
1040         ASSERT_EQ(ret, expected_ret);
1041 }
1042
1043 TEST(tbm_surface_internal_get_plane_data, null_ptr_fail_1)
1044 {
1045         int ret = 0;
1046         int expected_ret = 0;
1047         uint32_t size = 0;
1048         uint32_t offset = 0;
1049         uint32_t pitch = 0;
1050
1051         _init_test();
1052
1053         ret = tbm_surface_internal_get_plane_data(NULL, 1, &size, &offset, &pitch);
1054
1055         ASSERT_EQ(ret, expected_ret);
1056 }
1057
1058 /* tbm_surface_internal_get_size() */
1059
1060 TEST(tbm_surface_internal_get_size, work_flow_success_2)
1061 {
1062         unsigned int actual_size = 0;
1063         unsigned int expected_size = 1024;
1064         struct _tbm_surface surface;
1065         struct _tbm_bufmgr bufmgr;
1066
1067         _init_test();
1068
1069         surface.info.size = expected_size;
1070         g_surface_bufmgr = &bufmgr;
1071         LIST_INITHEAD(&bufmgr.surf_list);
1072         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1073
1074         actual_size = tbm_surface_internal_get_size(&surface);
1075
1076         ASSERT_EQ(actual_size, expected_size);
1077         ASSERT_EQ(actual_size, expected_size);
1078 }
1079
1080 TEST(tbm_surface_internal_get_size, work_flow_success_1)
1081 {
1082         unsigned int actual_size = 0;
1083         unsigned int expected_size = 0;
1084         struct _tbm_surface surface;
1085         struct _tbm_bufmgr bufmgr;
1086
1087         _init_test();
1088
1089         g_surface_bufmgr = &bufmgr;
1090         LIST_INITHEAD(&bufmgr.surf_list);
1091
1092         actual_size = tbm_surface_internal_get_size(&surface);
1093
1094         ASSERT_EQ(actual_size, expected_size);
1095 }
1096
1097 TEST(tbm_surface_internal_get_size, null_ptr_fail_1)
1098 {
1099         unsigned int actual_size = 0;
1100         unsigned int expected_size = 0;
1101
1102         _init_test();
1103
1104         actual_size = tbm_surface_internal_get_size(NULL);
1105
1106         ASSERT_EQ(actual_size, expected_size);
1107 }
1108
1109 /* tbm_surface_internal_get_bo() */
1110
1111 TEST(tbm_surface_internal_get_bo, work_flow_success_3)
1112 {
1113         tbm_bo bo;
1114         int bo_idx = 0;
1115         struct _tbm_bo expected_bo;
1116         struct _tbm_surface surface;
1117         struct _tbm_bufmgr bufmgr;
1118
1119         _init_test();
1120
1121         surface.bos[bo_idx] = &expected_bo;
1122         g_surface_bufmgr = &bufmgr;
1123         LIST_INITHEAD(&bufmgr.surf_list);
1124         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1125
1126         bo = tbm_surface_internal_get_bo(&surface, bo_idx);
1127
1128         ASSERT_TRUE(bo == &expected_bo);
1129 }
1130
1131 TEST(tbm_surface_internal_get_bo, work_flow_success_2)
1132 {
1133         tbm_bo bo;
1134         struct _tbm_surface surface;
1135         struct _tbm_bufmgr bufmgr;
1136
1137         _init_test();
1138
1139         g_surface_bufmgr = &bufmgr;
1140         LIST_INITHEAD(&bufmgr.surf_list);
1141
1142         bo = tbm_surface_internal_get_bo(&surface, 1);
1143
1144         ASSERT_TRUE(bo == NULL);
1145 }
1146
1147 TEST(tbm_surface_internal_get_bo, work_flow_success_1)
1148 {
1149         tbm_bo bo;
1150         struct _tbm_surface surface;
1151         struct _tbm_bufmgr bufmgr;
1152
1153         _init_test();
1154
1155         g_surface_bufmgr = &bufmgr;
1156         LIST_INITHEAD(&bufmgr.surf_list);
1157         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1158
1159         bo = tbm_surface_internal_get_bo(&surface, -1);
1160
1161         ASSERT_TRUE(bo == NULL);
1162 }
1163
1164 TEST(tbm_surface_internal_get_bo, null_ptr_fail_1)
1165 {
1166         tbm_bo bo;
1167
1168         _init_test();
1169
1170         bo = tbm_surface_internal_get_bo(NULL, 1);
1171
1172         ASSERT_TRUE(bo == NULL);
1173 }
1174
1175 /* tbm_surface_internal_get_num_bos() */
1176
1177 TEST(tbm_surface_internal_get_num_bos, work_flow_success_1)
1178 {
1179         int actual_num = 0;
1180         int expected_num = 5;
1181         struct _tbm_surface surface;
1182         struct _tbm_bufmgr bufmgr;
1183
1184         _init_test();
1185
1186         surface.num_bos = expected_num;
1187         g_surface_bufmgr = &bufmgr;
1188         LIST_INITHEAD(&bufmgr.surf_list);
1189         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1190
1191         actual_num = tbm_surface_internal_get_num_bos(&surface);
1192
1193         ASSERT_EQ(actual_num, expected_num);
1194 }
1195
1196 /* tbm_surface_internal_unref() */
1197
1198 TEST(tbm_surface_internal_unref, work_flow_success_2)
1199 {
1200         tbm_surface_h surface = (tbm_surface_h) calloc(1, sizeof(*surface));
1201         surface->refcnt = 1;
1202         struct _tbm_bufmgr bufmgr;
1203
1204         _init_test();
1205
1206         g_surface_bufmgr = &bufmgr;
1207         LIST_INITHEAD(&bufmgr.surf_list);
1208         LIST_INITHEAD(&bufmgr.debug_key_list);
1209         LIST_INITHEAD(&surface->user_data_list);
1210         LIST_INITHEAD(&surface->debug_data_list);
1211         LIST_ADD(&surface->item_link, &bufmgr.surf_list);
1212         surface->num_bos = 0;
1213         FREE_TESTED_PTR = surface;
1214         surface->bufmgr = &bufmgr;
1215
1216         tbm_surface_internal_unref(surface);
1217
1218         ASSERT_EQ(free_called_for_tested_ptr, 1);
1219         ASSERT_TRUE(g_surface_bufmgr == NULL);
1220 }
1221
1222 TEST(tbm_surface_internal_unref, work_flow_success_1)
1223 {
1224         struct _tbm_surface surface;
1225         int expected_refcnt = 9;
1226         struct _tbm_bufmgr bufmgr;
1227
1228         _init_test();
1229
1230         surface.refcnt = expected_refcnt + 1;
1231         g_surface_bufmgr = &bufmgr;
1232         LIST_INITHEAD(&bufmgr.surf_list);
1233         LIST_INITHEAD(&bufmgr.debug_key_list);
1234         LIST_INITHEAD(&surface.user_data_list);
1235         LIST_INITHEAD(&surface.debug_data_list);
1236         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1237
1238         tbm_surface_internal_unref(&surface);
1239
1240         ASSERT_EQ(expected_refcnt, surface.refcnt);
1241 }
1242
1243 /* tbm_surface_internal_ref() */
1244
1245 TEST(tbm_surface_internal_ref, work_flow_success_1)
1246 {
1247         struct _tbm_surface surface;
1248         int expected_refcnt = 10;
1249         struct _tbm_bufmgr bufmgr;
1250
1251         _init_test();
1252
1253         surface.refcnt = expected_refcnt - 1;
1254         g_surface_bufmgr = &bufmgr;
1255         LIST_INITHEAD(&bufmgr.surf_list);
1256         LIST_INITHEAD(&bufmgr.debug_key_list);
1257         LIST_INITHEAD(&surface.user_data_list);
1258         LIST_INITHEAD(&surface.debug_data_list);
1259         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1260
1261         tbm_surface_internal_ref(&surface);
1262
1263         ASSERT_EQ(expected_refcnt, surface.refcnt);
1264 }
1265
1266 /* tbm_surface_internal_destroy() */
1267
1268 TEST(tbm_surface_internal_destroy, work_flow_success_2)
1269 {
1270         tbm_surface_h surface = (tbm_surface_h) calloc(1, sizeof(*surface));
1271         struct _tbm_bufmgr bufmgr;
1272
1273         _init_test();
1274
1275         surface->refcnt = 1;
1276         g_surface_bufmgr = &bufmgr;
1277         LIST_INITHEAD(&bufmgr.surf_list);
1278         LIST_INITHEAD(&bufmgr.debug_key_list);
1279         LIST_INITHEAD(&surface->user_data_list);
1280         LIST_INITHEAD(&surface->debug_data_list);
1281         LIST_ADD(&surface->item_link, &bufmgr.surf_list);
1282         surface->num_bos = 0;
1283         FREE_TESTED_PTR = surface;
1284         surface->bufmgr = &bufmgr;
1285
1286         tbm_surface_internal_destroy(surface);
1287
1288         ASSERT_EQ(free_called_for_tested_ptr, 1);
1289         ASSERT_TRUE(g_surface_bufmgr == NULL);
1290 }
1291
1292 TEST(tbm_surface_internal_destroy, work_flow_success_1)
1293 {
1294         struct _tbm_surface surface;
1295         int expected_refcnt = 9;
1296         struct _tbm_bufmgr bufmgr;
1297
1298         _init_test();
1299
1300         surface.refcnt = expected_refcnt + 1;
1301         g_surface_bufmgr = &bufmgr;
1302         LIST_INITHEAD(&bufmgr.surf_list);
1303         LIST_INITHEAD(&bufmgr.debug_key_list);
1304         LIST_INITHEAD(&surface.user_data_list);
1305         LIST_INITHEAD(&surface.debug_data_list);
1306         LIST_ADD(&surface.item_link, &bufmgr.surf_list);
1307
1308         tbm_surface_internal_destroy(&surface);
1309
1310         ASSERT_EQ(expected_refcnt, surface.refcnt);
1311 }
1312
1313 /* tbm_surface_internal_get_bpp() */
1314
1315 TEST(tbm_surface_internal_get_bpp, work_flow_success_59)
1316 {
1317         int ret = 0;
1318         int expected_ret = 24;
1319         tbm_format format = TBM_FORMAT_YVU444;
1320
1321         _init_test();
1322
1323         ret = tbm_surface_internal_get_bpp(format);
1324
1325         ASSERT_EQ(ret, expected_ret);
1326 }
1327
1328 TEST(tbm_surface_internal_get_bpp, work_flow_success_58)
1329 {
1330         int ret = 0;
1331         int expected_ret = 24;
1332         tbm_format format = TBM_FORMAT_YUV444;
1333
1334         _init_test();
1335
1336         ret = tbm_surface_internal_get_bpp(format);
1337
1338         ASSERT_EQ(ret, expected_ret);
1339 }
1340
1341 TEST(tbm_surface_internal_get_bpp, work_flow_success_57)
1342 {
1343         int ret = 0;
1344         int expected_ret = 16;
1345         tbm_format format = TBM_FORMAT_YVU422;
1346
1347         _init_test();
1348
1349         ret = tbm_surface_internal_get_bpp(format);
1350
1351         ASSERT_EQ(ret, expected_ret);
1352 }
1353
1354 TEST(tbm_surface_internal_get_bpp, work_flow_success_56)
1355 {
1356         int ret = 0;
1357         int expected_ret = 16;
1358         tbm_format format = TBM_FORMAT_YUV422;
1359
1360         _init_test();
1361
1362         ret = tbm_surface_internal_get_bpp(format);
1363
1364         ASSERT_EQ(ret, expected_ret);
1365 }
1366
1367 TEST(tbm_surface_internal_get_bpp, work_flow_success_55)
1368 {
1369         int ret = 0;
1370         int expected_ret = 12;
1371         tbm_format format = TBM_FORMAT_YVU420;
1372
1373         _init_test();
1374
1375         ret = tbm_surface_internal_get_bpp(format);
1376
1377         ASSERT_EQ(ret, expected_ret);
1378 }
1379
1380 TEST(tbm_surface_internal_get_bpp, work_flow_success_54)
1381 {
1382         int ret = 0;
1383         int expected_ret = 12;
1384         tbm_format format = TBM_FORMAT_YUV420;
1385
1386         _init_test();
1387
1388         ret = tbm_surface_internal_get_bpp(format);
1389
1390         ASSERT_EQ(ret, expected_ret);
1391 }
1392
1393 TEST(tbm_surface_internal_get_bpp, work_flow_success_53)
1394 {
1395         int ret = 0;
1396         int expected_ret = 12;
1397         tbm_format format = TBM_FORMAT_YVU411;
1398
1399         _init_test();
1400
1401         ret = tbm_surface_internal_get_bpp(format);
1402
1403         ASSERT_EQ(ret, expected_ret);
1404 }
1405
1406 TEST(tbm_surface_internal_get_bpp, work_flow_success_52)
1407 {
1408         int ret = 0;
1409         int expected_ret = 12;
1410         tbm_format format = TBM_FORMAT_YUV411;
1411
1412         _init_test();
1413
1414         ret = tbm_surface_internal_get_bpp(format);
1415
1416         ASSERT_EQ(ret, expected_ret);
1417 }
1418
1419 TEST(tbm_surface_internal_get_bpp, work_flow_success_51)
1420 {
1421         int ret = 0;
1422         int expected_ret = 9;
1423         tbm_format format = TBM_FORMAT_YVU410;
1424
1425         _init_test();
1426
1427         ret = tbm_surface_internal_get_bpp(format);
1428
1429         ASSERT_EQ(ret, expected_ret);
1430 }
1431
1432 TEST(tbm_surface_internal_get_bpp, work_flow_success_50)
1433 {
1434         int ret = 0;
1435         int expected_ret = 9;
1436         tbm_format format = TBM_FORMAT_YUV410;
1437
1438         _init_test();
1439
1440         ret = tbm_surface_internal_get_bpp(format);
1441
1442         ASSERT_EQ(ret, expected_ret);
1443 }
1444
1445 TEST(tbm_surface_internal_get_bpp, work_flow_success_49)
1446 {
1447         int ret = 0;
1448         int expected_ret = 16;
1449         tbm_format format = TBM_FORMAT_NV61;
1450
1451         _init_test();
1452
1453         ret = tbm_surface_internal_get_bpp(format);
1454
1455         ASSERT_EQ(ret, expected_ret);
1456 }
1457
1458 TEST(tbm_surface_internal_get_bpp, work_flow_success_48)
1459 {
1460         int ret = 0;
1461         int expected_ret = 16;
1462         tbm_format format = TBM_FORMAT_NV16;
1463
1464         _init_test();
1465
1466         ret = tbm_surface_internal_get_bpp(format);
1467
1468         ASSERT_EQ(ret, expected_ret);
1469 }
1470
1471 TEST(tbm_surface_internal_get_bpp, work_flow_success_47)
1472 {
1473         int ret = 0;
1474         int expected_ret = 12;
1475         tbm_format format = TBM_FORMAT_NV21;
1476
1477         _init_test();
1478
1479         ret = tbm_surface_internal_get_bpp(format);
1480
1481         ASSERT_EQ(ret, expected_ret);
1482 }
1483
1484 TEST(tbm_surface_internal_get_bpp, work_flow_success_46)
1485 {
1486         int ret = 0;
1487         int expected_ret = 12;
1488         tbm_format format = TBM_FORMAT_NV12MT;
1489
1490         _init_test();
1491
1492         ret = tbm_surface_internal_get_bpp(format);
1493
1494         ASSERT_EQ(ret, expected_ret);
1495 }
1496
1497 TEST(tbm_surface_internal_get_bpp, work_flow_success_45)
1498 {
1499         int ret = 0;
1500         int expected_ret = 12;
1501         tbm_format format = TBM_FORMAT_NV12;
1502
1503         _init_test();
1504
1505         ret = tbm_surface_internal_get_bpp(format);
1506
1507         ASSERT_EQ(ret, expected_ret);
1508 }
1509
1510 TEST(tbm_surface_internal_get_bpp, work_flow_success_44)
1511 {
1512         int ret = 0;
1513         int expected_ret = 32;
1514         tbm_format format = TBM_FORMAT_AYUV;
1515
1516         _init_test();
1517
1518         ret = tbm_surface_internal_get_bpp(format);
1519
1520         ASSERT_EQ(ret, expected_ret);
1521 }
1522
1523 TEST(tbm_surface_internal_get_bpp, work_flow_success_43)
1524 {
1525         int ret = 0;
1526         int expected_ret = 32;
1527         tbm_format format = TBM_FORMAT_VYUY;
1528
1529         _init_test();
1530
1531         ret = tbm_surface_internal_get_bpp(format);
1532
1533         ASSERT_EQ(ret, expected_ret);
1534 }
1535
1536 TEST(tbm_surface_internal_get_bpp, work_flow_success_42)
1537 {
1538         int ret = 0;
1539         int expected_ret = 32;
1540         tbm_format format = TBM_FORMAT_UYVY;
1541
1542         _init_test();
1543
1544         ret = tbm_surface_internal_get_bpp(format);
1545
1546         ASSERT_EQ(ret, expected_ret);
1547 }
1548
1549 TEST(tbm_surface_internal_get_bpp, work_flow_success_41)
1550 {
1551         int ret = 0;
1552         int expected_ret = 32;
1553         tbm_format format = TBM_FORMAT_YVYU;
1554
1555         _init_test();
1556
1557         ret = tbm_surface_internal_get_bpp(format);
1558
1559         ASSERT_EQ(ret, expected_ret);
1560 }
1561
1562 TEST(tbm_surface_internal_get_bpp, work_flow_success_40)
1563 {
1564         int ret = 0;
1565         int expected_ret = 32;
1566         tbm_format format = TBM_FORMAT_YUYV;
1567
1568         _init_test();
1569
1570         ret = tbm_surface_internal_get_bpp(format);
1571
1572         ASSERT_EQ(ret, expected_ret);
1573 }
1574
1575 TEST(tbm_surface_internal_get_bpp, work_flow_success_39)
1576 {
1577         int ret = 0;
1578         int expected_ret = 32;
1579         tbm_format format = TBM_FORMAT_BGRA1010102;
1580
1581         _init_test();
1582
1583         ret = tbm_surface_internal_get_bpp(format);
1584
1585         ASSERT_EQ(ret, expected_ret);
1586 }
1587
1588 TEST(tbm_surface_internal_get_bpp, work_flow_success_38)
1589 {
1590         int ret = 0;
1591         int expected_ret = 32;
1592         tbm_format format = TBM_FORMAT_RGBA1010102;
1593
1594         _init_test();
1595
1596         ret = tbm_surface_internal_get_bpp(format);
1597
1598         ASSERT_EQ(ret, expected_ret);
1599 }
1600
1601 TEST(tbm_surface_internal_get_bpp, work_flow_success_37)
1602 {
1603         int ret = 0;
1604         int expected_ret = 32;
1605         tbm_format format = TBM_FORMAT_ABGR2101010;
1606
1607         _init_test();
1608
1609         ret = tbm_surface_internal_get_bpp(format);
1610
1611         ASSERT_EQ(ret, expected_ret);
1612 }
1613
1614 TEST(tbm_surface_internal_get_bpp, work_flow_success_36)
1615 {
1616         int ret = 0;
1617         int expected_ret = 32;
1618         tbm_format format = TBM_FORMAT_ARGB2101010;
1619
1620         _init_test();
1621
1622         ret = tbm_surface_internal_get_bpp(format);
1623
1624         ASSERT_EQ(ret, expected_ret);
1625 }
1626
1627 TEST(tbm_surface_internal_get_bpp, work_flow_success_35)
1628 {
1629         int ret = 0;
1630         int expected_ret = 32;
1631         tbm_format format = TBM_FORMAT_BGRX1010102;
1632
1633         _init_test();
1634
1635         ret = tbm_surface_internal_get_bpp(format);
1636
1637         ASSERT_EQ(ret, expected_ret);
1638 }
1639
1640 TEST(tbm_surface_internal_get_bpp, work_flow_success_34)
1641 {
1642         int ret = 0;
1643         int expected_ret = 32;
1644         tbm_format format = TBM_FORMAT_RGBX1010102;
1645
1646         _init_test();
1647
1648         ret = tbm_surface_internal_get_bpp(format);
1649
1650         ASSERT_EQ(ret, expected_ret);
1651 }
1652
1653 TEST(tbm_surface_internal_get_bpp, work_flow_success_33)
1654 {
1655         int ret = 0;
1656         int expected_ret = 32;
1657         tbm_format format = TBM_FORMAT_XBGR2101010;
1658
1659         _init_test();
1660
1661         ret = tbm_surface_internal_get_bpp(format);
1662
1663         ASSERT_EQ(ret, expected_ret);
1664 }
1665
1666 TEST(tbm_surface_internal_get_bpp, work_flow_success_32)
1667 {
1668         int ret = 0;
1669         int expected_ret = 32;
1670         tbm_format format = TBM_FORMAT_XRGB2101010;
1671
1672         _init_test();
1673
1674         ret = tbm_surface_internal_get_bpp(format);
1675
1676         ASSERT_EQ(ret, expected_ret);
1677 }
1678
1679 TEST(tbm_surface_internal_get_bpp, work_flow_success_31)
1680 {
1681         int ret = 0;
1682         int expected_ret = 32;
1683         tbm_format format = TBM_FORMAT_BGRA8888;
1684
1685         _init_test();
1686
1687         ret = tbm_surface_internal_get_bpp(format);
1688
1689         ASSERT_EQ(ret, expected_ret);
1690 }
1691
1692 TEST(tbm_surface_internal_get_bpp, work_flow_success_30)
1693 {
1694         int ret = 0;
1695         int expected_ret = 32;
1696         tbm_format format = TBM_FORMAT_RGBA8888;
1697
1698         _init_test();
1699
1700         ret = tbm_surface_internal_get_bpp(format);
1701
1702         ASSERT_EQ(ret, expected_ret);
1703 }
1704
1705 TEST(tbm_surface_internal_get_bpp, work_flow_success_29)
1706 {
1707         int ret = 0;
1708         int expected_ret = 32;
1709         tbm_format format = TBM_FORMAT_ABGR8888;
1710
1711         _init_test();
1712
1713         ret = tbm_surface_internal_get_bpp(format);
1714
1715         ASSERT_EQ(ret, expected_ret);
1716 }
1717
1718 TEST(tbm_surface_internal_get_bpp, work_flow_success_28)
1719 {
1720         int ret = 0;
1721         int expected_ret = 32;
1722         tbm_format format = TBM_FORMAT_ARGB8888;
1723
1724         _init_test();
1725
1726         ret = tbm_surface_internal_get_bpp(format);
1727
1728         ASSERT_EQ(ret, expected_ret);
1729 }
1730
1731 TEST(tbm_surface_internal_get_bpp, work_flow_success_27)
1732 {
1733         int ret = 0;
1734         int expected_ret = 32;
1735         tbm_format format = TBM_FORMAT_BGRX8888;
1736
1737         _init_test();
1738
1739         ret = tbm_surface_internal_get_bpp(format);
1740
1741         ASSERT_EQ(ret, expected_ret);
1742 }
1743
1744 TEST(tbm_surface_internal_get_bpp, work_flow_success_26)
1745 {
1746         int ret = 0;
1747         int expected_ret = 32;
1748         tbm_format format = TBM_FORMAT_RGBX8888;
1749
1750         _init_test();
1751
1752         ret = tbm_surface_internal_get_bpp(format);
1753
1754         ASSERT_EQ(ret, expected_ret);
1755 }
1756
1757 TEST(tbm_surface_internal_get_bpp, work_flow_success_25)
1758 {
1759         int ret = 0;
1760         int expected_ret = 32;
1761         tbm_format format = TBM_FORMAT_XBGR8888;
1762
1763         _init_test();
1764
1765         ret = tbm_surface_internal_get_bpp(format);
1766
1767         ASSERT_EQ(ret, expected_ret);
1768 }
1769
1770 TEST(tbm_surface_internal_get_bpp, work_flow_success_24)
1771 {
1772         int ret = 0;
1773         int expected_ret = 32;
1774         tbm_format format = TBM_FORMAT_XRGB8888;
1775
1776         _init_test();
1777
1778         ret = tbm_surface_internal_get_bpp(format);
1779
1780         ASSERT_EQ(ret, expected_ret);
1781 }
1782
1783 TEST(tbm_surface_internal_get_bpp, work_flow_success_23)
1784 {
1785         int ret = 0;
1786         int expected_ret = 24;
1787         tbm_format format = TBM_FORMAT_BGR888;
1788
1789         _init_test();
1790
1791         ret = tbm_surface_internal_get_bpp(format);
1792
1793         ASSERT_EQ(ret, expected_ret);
1794 }
1795
1796 TEST(tbm_surface_internal_get_bpp, work_flow_success_22)
1797 {
1798         int ret = 0;
1799         int expected_ret = 24;
1800         tbm_format format = TBM_FORMAT_RGB888;
1801
1802         _init_test();
1803
1804         ret = tbm_surface_internal_get_bpp(format);
1805
1806         ASSERT_EQ(ret, expected_ret);
1807 }
1808
1809 TEST(tbm_surface_internal_get_bpp, work_flow_success_21)
1810 {
1811         int ret = 0;
1812         int expected_ret = 16;
1813         tbm_format format = TBM_FORMAT_BGR565;
1814
1815         _init_test();
1816
1817         ret = tbm_surface_internal_get_bpp(format);
1818
1819         ASSERT_EQ(ret, expected_ret);
1820 }
1821
1822 TEST(tbm_surface_internal_get_bpp, work_flow_success_20)
1823 {
1824         int ret = 0;
1825         int expected_ret = 16;
1826         tbm_format format = TBM_FORMAT_RGB565;
1827
1828         _init_test();
1829
1830         ret = tbm_surface_internal_get_bpp(format);
1831
1832         ASSERT_EQ(ret, expected_ret);
1833 }
1834
1835 TEST(tbm_surface_internal_get_bpp, work_flow_success_19)
1836 {
1837         int ret = 0;
1838         int expected_ret = 16;
1839         tbm_format format = TBM_FORMAT_BGRA5551;
1840
1841         _init_test();
1842
1843         ret = tbm_surface_internal_get_bpp(format);
1844
1845         ASSERT_EQ(ret, expected_ret);
1846 }
1847
1848 TEST(tbm_surface_internal_get_bpp, work_flow_success_18)
1849 {
1850         int ret = 0;
1851         int expected_ret = 16;
1852         tbm_format format = TBM_FORMAT_RGBA5551;
1853
1854         _init_test();
1855
1856         ret = tbm_surface_internal_get_bpp(format);
1857
1858         ASSERT_EQ(ret, expected_ret);
1859 }
1860
1861 TEST(tbm_surface_internal_get_bpp, work_flow_success_17)
1862 {
1863         int ret = 0;
1864         int expected_ret = 16;
1865         tbm_format format = TBM_FORMAT_ABGR1555;
1866
1867         _init_test();
1868
1869         ret = tbm_surface_internal_get_bpp(format);
1870
1871         ASSERT_EQ(ret, expected_ret);
1872 }
1873
1874 TEST(tbm_surface_internal_get_bpp, work_flow_success_16)
1875 {
1876         int ret = 0;
1877         int expected_ret = 16;
1878         tbm_format format = TBM_FORMAT_ARGB1555;
1879
1880         _init_test();
1881
1882         ret = tbm_surface_internal_get_bpp(format);
1883
1884         ASSERT_EQ(ret, expected_ret);
1885 }
1886
1887 TEST(tbm_surface_internal_get_bpp, work_flow_success_15)
1888 {
1889         int ret = 0;
1890         int expected_ret = 16;
1891         tbm_format format = TBM_FORMAT_BGRX5551;
1892
1893         _init_test();
1894
1895         ret = tbm_surface_internal_get_bpp(format);
1896
1897         ASSERT_EQ(ret, expected_ret);
1898 }
1899
1900 TEST(tbm_surface_internal_get_bpp, work_flow_success_14)
1901 {
1902         int ret = 0;
1903         int expected_ret = 16;
1904         tbm_format format = TBM_FORMAT_RGBX5551;
1905
1906         _init_test();
1907
1908         ret = tbm_surface_internal_get_bpp(format);
1909
1910         ASSERT_EQ(ret, expected_ret);
1911 }
1912
1913 TEST(tbm_surface_internal_get_bpp, work_flow_success_13)
1914 {
1915         int ret = 0;
1916         int expected_ret = 16;
1917         tbm_format format = TBM_FORMAT_XBGR1555;
1918
1919         _init_test();
1920
1921         ret = tbm_surface_internal_get_bpp(format);
1922
1923         ASSERT_EQ(ret, expected_ret);
1924 }
1925
1926 TEST(tbm_surface_internal_get_bpp, work_flow_success_12)
1927 {
1928         int ret = 0;
1929         int expected_ret = 16;
1930         tbm_format format = TBM_FORMAT_XRGB1555;
1931
1932         _init_test();
1933
1934         ret = tbm_surface_internal_get_bpp(format);
1935
1936         ASSERT_EQ(ret, expected_ret);
1937 }
1938
1939 TEST(tbm_surface_internal_get_bpp, work_flow_success_11)
1940 {
1941         int ret = 0;
1942         int expected_ret = 16;
1943         tbm_format format = TBM_FORMAT_BGRA4444;
1944
1945         _init_test();
1946
1947         ret = tbm_surface_internal_get_bpp(format);
1948
1949         ASSERT_EQ(ret, expected_ret);
1950 }
1951
1952 TEST(tbm_surface_internal_get_bpp, work_flow_success_10)
1953 {
1954         int ret = 0;
1955         int expected_ret = 16;
1956         tbm_format format = TBM_FORMAT_RGBA4444;
1957
1958         _init_test();
1959
1960         ret = tbm_surface_internal_get_bpp(format);
1961
1962         ASSERT_EQ(ret, expected_ret);
1963 }
1964
1965 TEST(tbm_surface_internal_get_bpp, work_flow_success_9)
1966 {
1967         int ret = 0;
1968         int expected_ret = 16;
1969         tbm_format format = TBM_FORMAT_ABGR4444;
1970
1971         _init_test();
1972
1973         ret = tbm_surface_internal_get_bpp(format);
1974
1975         ASSERT_EQ(ret, expected_ret);
1976 }
1977
1978 TEST(tbm_surface_internal_get_bpp, work_flow_success_8)
1979 {
1980         int ret = 0;
1981         int expected_ret = 16;
1982         tbm_format format = TBM_FORMAT_ARGB4444;
1983
1984         _init_test();
1985
1986         ret = tbm_surface_internal_get_bpp(format);
1987
1988         ASSERT_EQ(ret, expected_ret);
1989 }
1990
1991 TEST(tbm_surface_internal_get_bpp, work_flow_success_7)
1992 {
1993         int ret = 0;
1994         int expected_ret = 16;
1995         tbm_format format = TBM_FORMAT_BGRX4444;
1996
1997         _init_test();
1998
1999         ret = tbm_surface_internal_get_bpp(format);
2000
2001         ASSERT_EQ(ret, expected_ret);
2002 }
2003
2004 TEST(tbm_surface_internal_get_bpp, work_flow_success_6)
2005 {
2006         int ret = 0;
2007         int expected_ret = 16;
2008         tbm_format format = TBM_FORMAT_RGBX4444;
2009
2010         _init_test();
2011
2012         ret = tbm_surface_internal_get_bpp(format);
2013
2014         ASSERT_EQ(ret, expected_ret);
2015 }
2016
2017 TEST(tbm_surface_internal_get_bpp, work_flow_success_5)
2018 {
2019         int ret = 0;
2020         int expected_ret = 16;
2021         tbm_format format = TBM_FORMAT_XBGR4444;
2022
2023         _init_test();
2024
2025         ret = tbm_surface_internal_get_bpp(format);
2026
2027         ASSERT_EQ(ret, expected_ret);
2028 }
2029
2030 TEST(tbm_surface_internal_get_bpp, work_flow_success_4)
2031 {
2032         int ret = 0;
2033         int expected_ret = 16;
2034         tbm_format format = TBM_FORMAT_XRGB4444;
2035
2036         _init_test();
2037
2038         ret = tbm_surface_internal_get_bpp(format);
2039
2040         ASSERT_EQ(ret, expected_ret);
2041 }
2042
2043 TEST(tbm_surface_internal_get_bpp, work_flow_success_3)
2044 {
2045         int ret = 0;
2046         int expected_ret = 8;
2047         tbm_format format = TBM_FORMAT_BGR233;
2048
2049         _init_test();
2050
2051         ret = tbm_surface_internal_get_bpp(format);
2052
2053         ASSERT_EQ(ret, expected_ret);
2054 }
2055
2056 TEST(tbm_surface_internal_get_bpp, work_flow_success_2)
2057 {
2058         int ret = 0;
2059         int expected_ret = 8;
2060         tbm_format format = TBM_FORMAT_RGB332;
2061
2062         _init_test();
2063
2064         ret = tbm_surface_internal_get_bpp(format);
2065
2066         ASSERT_EQ(ret, expected_ret);
2067 }
2068
2069 TEST(tbm_surface_internal_get_bpp, work_flow_success_1)
2070 {
2071         int ret = 0;
2072         int expected_ret = 8;
2073         tbm_format format = TBM_FORMAT_C8;
2074
2075         _init_test();
2076
2077         ret = tbm_surface_internal_get_bpp(format);
2078
2079         ASSERT_EQ(ret, expected_ret);
2080 }
2081
2082 /* tbm_surface_internal_get_num_planes() */
2083
2084 TEST(tbm_surface_internal_get_num_planes, work_flow_success_60)
2085 {
2086         int ret = 0;
2087         int expected_ret = 3;
2088         tbm_format format = TBM_FORMAT_YVU444;
2089
2090         _init_test();
2091
2092         ret = tbm_surface_internal_get_num_planes(format);
2093
2094         ASSERT_EQ(ret, expected_ret);
2095 }
2096
2097 TEST(tbm_surface_internal_get_num_planes, work_flow_success_59)
2098 {
2099         int ret = 0;
2100         int expected_ret = 3;
2101         tbm_format format = TBM_FORMAT_YUV444;
2102
2103         _init_test();
2104
2105         ret = tbm_surface_internal_get_num_planes(format);
2106
2107         ASSERT_EQ(ret, expected_ret);
2108 }
2109
2110 TEST(tbm_surface_internal_get_num_planes, work_flow_success_58)
2111 {
2112         int ret = 0;
2113         int expected_ret = 3;
2114         tbm_format format = TBM_FORMAT_YVU422;
2115
2116         _init_test();
2117
2118         ret = tbm_surface_internal_get_num_planes(format);
2119
2120         ASSERT_EQ(ret, expected_ret);
2121 }
2122
2123 TEST(tbm_surface_internal_get_num_planes, work_flow_success_57)
2124 {
2125         int ret = 0;
2126         int expected_ret = 3;
2127         tbm_format format = TBM_FORMAT_YUV422;
2128
2129         _init_test();
2130
2131         ret = tbm_surface_internal_get_num_planes(format);
2132
2133         ASSERT_EQ(ret, expected_ret);
2134 }
2135
2136 TEST(tbm_surface_internal_get_num_planes, work_flow_success_56)
2137 {
2138         int ret = 0;
2139         int expected_ret = 3;
2140         tbm_format format = TBM_FORMAT_YVU420;
2141
2142         _init_test();
2143
2144         ret = tbm_surface_internal_get_num_planes(format);
2145
2146         ASSERT_EQ(ret, expected_ret);
2147 }
2148
2149 TEST(tbm_surface_internal_get_num_planes, work_flow_success_55)
2150 {
2151         int ret = 0;
2152         int expected_ret = 3;
2153         tbm_format format = TBM_FORMAT_YUV420;
2154
2155         _init_test();
2156
2157         ret = tbm_surface_internal_get_num_planes(format);
2158
2159         ASSERT_EQ(ret, expected_ret);
2160 }
2161
2162 TEST(tbm_surface_internal_get_num_planes, work_flow_success_54)
2163 {
2164         int ret = 0;
2165         int expected_ret = 3;
2166         tbm_format format = TBM_FORMAT_YVU411;
2167
2168         _init_test();
2169
2170         ret = tbm_surface_internal_get_num_planes(format);
2171
2172         ASSERT_EQ(ret, expected_ret);
2173 }
2174
2175 TEST(tbm_surface_internal_get_num_planes, work_flow_success_53)
2176 {
2177         int ret = 0;
2178         int expected_ret = 3;
2179         tbm_format format = TBM_FORMAT_YUV411;
2180
2181         _init_test();
2182
2183         ret = tbm_surface_internal_get_num_planes(format);
2184
2185         ASSERT_EQ(ret, expected_ret);
2186 }
2187
2188 TEST(tbm_surface_internal_get_num_planes, work_flow_success_52)
2189 {
2190         int ret = 0;
2191         int expected_ret = 3;
2192         tbm_format format = TBM_FORMAT_YVU410;
2193
2194         _init_test();
2195
2196         ret = tbm_surface_internal_get_num_planes(format);
2197
2198         ASSERT_EQ(ret, expected_ret);
2199 }
2200
2201 TEST(tbm_surface_internal_get_num_planes, work_flow_success_51)
2202 {
2203         int ret = 0;
2204         int expected_ret = 3;
2205         tbm_format format = TBM_FORMAT_YUV410;
2206
2207         _init_test();
2208
2209         ret = tbm_surface_internal_get_num_planes(format);
2210
2211         ASSERT_EQ(ret, expected_ret);
2212 }
2213
2214 TEST(tbm_surface_internal_get_num_planes, work_flow_success_50)
2215 {
2216         int ret = 0;
2217         int expected_ret = 2;
2218         tbm_format format = TBM_FORMAT_NV61;
2219
2220         _init_test();
2221
2222         ret = tbm_surface_internal_get_num_planes(format);
2223
2224         ASSERT_EQ(ret, expected_ret);
2225 }
2226
2227 TEST(tbm_surface_internal_get_num_planes, work_flow_success_49)
2228 {
2229         int ret = 0;
2230         int expected_ret = 2;
2231         tbm_format format = TBM_FORMAT_NV16;
2232
2233         _init_test();
2234
2235         ret = tbm_surface_internal_get_num_planes(format);
2236
2237         ASSERT_EQ(ret, expected_ret);
2238 }
2239
2240 TEST(tbm_surface_internal_get_num_planes, work_flow_success_48)
2241 {
2242         int ret = 0;
2243         int expected_ret = 2;
2244         tbm_format format = TBM_FORMAT_NV21;
2245
2246         _init_test();
2247
2248         ret = tbm_surface_internal_get_num_planes(format);
2249
2250         ASSERT_EQ(ret, expected_ret);
2251 }
2252
2253 TEST(tbm_surface_internal_get_num_planes, work_flow_success_47)
2254 {
2255         int ret = 0;
2256         int expected_ret = 2;
2257         tbm_format format = TBM_FORMAT_NV12MT;
2258
2259         _init_test();
2260
2261         ret = tbm_surface_internal_get_num_planes(format);
2262
2263         ASSERT_EQ(ret, expected_ret);
2264 }
2265
2266 TEST(tbm_surface_internal_get_num_planes, work_flow_success_46)
2267 {
2268         int ret = 0;
2269         int expected_ret = 2;
2270         tbm_format format = TBM_FORMAT_NV12;
2271
2272         _init_test();
2273
2274         ret = tbm_surface_internal_get_num_planes(format);
2275
2276         ASSERT_EQ(ret, expected_ret);
2277 }
2278
2279 TEST(tbm_surface_internal_get_num_planes, work_flow_success_45)
2280 {
2281         int ret = 0;
2282         int expected_ret = 1;
2283         tbm_format format = TBM_FORMAT_AYUV;
2284
2285         _init_test();
2286
2287         ret = tbm_surface_internal_get_num_planes(format);
2288
2289         ASSERT_EQ(ret, expected_ret);
2290 }
2291
2292 TEST(tbm_surface_internal_get_num_planes, work_flow_success_44)
2293 {
2294         int ret = 0;
2295         int expected_ret = 1;
2296         tbm_format format = TBM_FORMAT_VYUY;
2297
2298         _init_test();
2299
2300         ret = tbm_surface_internal_get_num_planes(format);
2301
2302         ASSERT_EQ(ret, expected_ret);
2303 }
2304
2305 TEST(tbm_surface_internal_get_num_planes, work_flow_success_43)
2306 {
2307         int ret = 0;
2308         int expected_ret = 1;
2309         tbm_format format = TBM_FORMAT_UYVY;
2310
2311         _init_test();
2312
2313         ret = tbm_surface_internal_get_num_planes(format);
2314
2315         ASSERT_EQ(ret, expected_ret);
2316 }
2317
2318 TEST(tbm_surface_internal_get_num_planes, work_flow_success_42)
2319 {
2320         int ret = 0;
2321         int expected_ret = 1;
2322         tbm_format format = TBM_FORMAT_YVYU;
2323
2324         _init_test();
2325
2326         ret = tbm_surface_internal_get_num_planes(format);
2327
2328         ASSERT_EQ(ret, expected_ret);
2329 }
2330
2331 TEST(tbm_surface_internal_get_num_planes, work_flow_success_41)
2332 {
2333         int ret = 0;
2334         int expected_ret = 1;
2335         tbm_format format = TBM_FORMAT_YUYV;
2336
2337         _init_test();
2338
2339         ret = tbm_surface_internal_get_num_planes(format);
2340
2341         ASSERT_EQ(ret, expected_ret);
2342 }
2343
2344 TEST(tbm_surface_internal_get_num_planes, work_flow_success_40)
2345 {
2346         int ret = 0;
2347         int expected_ret = 1;
2348         tbm_format format = TBM_FORMAT_BGRA1010102;
2349
2350         _init_test();
2351
2352         ret = tbm_surface_internal_get_num_planes(format);
2353
2354         ASSERT_EQ(ret, expected_ret);
2355 }
2356
2357 TEST(tbm_surface_internal_get_num_planes, work_flow_success_39)
2358 {
2359         int ret = 0;
2360         int expected_ret = 1;
2361         tbm_format format = TBM_FORMAT_RGBA1010102;
2362
2363         _init_test();
2364
2365         ret = tbm_surface_internal_get_num_planes(format);
2366
2367         ASSERT_EQ(ret, expected_ret);
2368 }
2369
2370 TEST(tbm_surface_internal_get_num_planes, work_flow_success_38)
2371 {
2372         int ret = 0;
2373         int expected_ret = 1;
2374         tbm_format format = TBM_FORMAT_ABGR2101010;
2375
2376         _init_test();
2377
2378         ret = tbm_surface_internal_get_num_planes(format);
2379
2380         ASSERT_EQ(ret, expected_ret);
2381 }
2382
2383 TEST(tbm_surface_internal_get_num_planes, work_flow_success_37)
2384 {
2385         int ret = 0;
2386         int expected_ret = 1;
2387         tbm_format format = TBM_FORMAT_ARGB2101010;
2388
2389         _init_test();
2390
2391         ret = tbm_surface_internal_get_num_planes(format);
2392
2393         ASSERT_EQ(ret, expected_ret);
2394 }
2395
2396 TEST(tbm_surface_internal_get_num_planes, work_flow_success_36)
2397 {
2398         int ret = 0;
2399         int expected_ret = 1;
2400         tbm_format format = TBM_FORMAT_BGRX1010102;
2401
2402         _init_test();
2403
2404         ret = tbm_surface_internal_get_num_planes(format);
2405
2406         ASSERT_EQ(ret, expected_ret);
2407 }
2408
2409 TEST(tbm_surface_internal_get_num_planes, work_flow_success_35)
2410 {
2411         int ret = 0;
2412         int expected_ret = 1;
2413         tbm_format format = TBM_FORMAT_RGBX1010102;
2414
2415         _init_test();
2416
2417         ret = tbm_surface_internal_get_num_planes(format);
2418
2419         ASSERT_EQ(ret, expected_ret);
2420 }
2421
2422 TEST(tbm_surface_internal_get_num_planes, work_flow_success_34)
2423 {
2424         int ret = 0;
2425         int expected_ret = 1;
2426         tbm_format format = TBM_FORMAT_XBGR2101010;
2427
2428         _init_test();
2429
2430         ret = tbm_surface_internal_get_num_planes(format);
2431
2432         ASSERT_EQ(ret, expected_ret);
2433 }
2434
2435 TEST(tbm_surface_internal_get_num_planes, work_flow_success_33)
2436 {
2437         int ret = 0;
2438         int expected_ret = 1;
2439         tbm_format format = TBM_FORMAT_XRGB2101010;
2440
2441         _init_test();
2442
2443         ret = tbm_surface_internal_get_num_planes(format);
2444
2445         ASSERT_EQ(ret, expected_ret);
2446 }
2447
2448 TEST(tbm_surface_internal_get_num_planes, work_flow_success_32)
2449 {
2450         int ret = 0;
2451         int expected_ret = 1;
2452         tbm_format format = TBM_FORMAT_BGRA8888;
2453
2454         _init_test();
2455
2456         ret = tbm_surface_internal_get_num_planes(format);
2457
2458         ASSERT_EQ(ret, expected_ret);
2459 }
2460
2461 TEST(tbm_surface_internal_get_num_planes, work_flow_success_31)
2462 {
2463         int ret = 0;
2464         int expected_ret = 1;
2465         tbm_format format = TBM_FORMAT_RGBA8888;
2466
2467         _init_test();
2468
2469         ret = tbm_surface_internal_get_num_planes(format);
2470
2471         ASSERT_EQ(ret, expected_ret);
2472 }
2473
2474 TEST(tbm_surface_internal_get_num_planes, work_flow_success_30)
2475 {
2476         int ret = 0;
2477         int expected_ret = 1;
2478         tbm_format format = TBM_FORMAT_ABGR8888;
2479
2480         _init_test();
2481
2482         ret = tbm_surface_internal_get_num_planes(format);
2483
2484         ASSERT_EQ(ret, expected_ret);
2485 }
2486
2487 TEST(tbm_surface_internal_get_num_planes, work_flow_success_29)
2488 {
2489         int ret = 0;
2490         int expected_ret = 1;
2491         tbm_format format = TBM_FORMAT_ABGR8888;
2492
2493         _init_test();
2494
2495         ret = tbm_surface_internal_get_num_planes(format);
2496
2497         ASSERT_EQ(ret, expected_ret);
2498 }
2499
2500 TEST(tbm_surface_internal_get_num_planes, work_flow_success_28)
2501 {
2502         int ret = 0;
2503         int expected_ret = 1;
2504         tbm_format format = TBM_FORMAT_ARGB8888;
2505
2506         _init_test();
2507
2508         ret = tbm_surface_internal_get_num_planes(format);
2509
2510         ASSERT_EQ(ret, expected_ret);
2511 }
2512
2513 TEST(tbm_surface_internal_get_num_planes, work_flow_success_27)
2514 {
2515         int ret = 0;
2516         int expected_ret = 1;
2517         tbm_format format = TBM_FORMAT_BGRX8888;
2518
2519         _init_test();
2520
2521         ret = tbm_surface_internal_get_num_planes(format);
2522
2523         ASSERT_EQ(ret, expected_ret);
2524 }
2525
2526 TEST(tbm_surface_internal_get_num_planes, work_flow_success_26)
2527 {
2528         int ret = 0;
2529         int expected_ret = 1;
2530         tbm_format format = TBM_FORMAT_RGBX8888;
2531
2532         _init_test();
2533
2534         ret = tbm_surface_internal_get_num_planes(format);
2535
2536         ASSERT_EQ(ret, expected_ret);
2537 }
2538
2539 TEST(tbm_surface_internal_get_num_planes, work_flow_success_25)
2540 {
2541         int ret = 0;
2542         int expected_ret = 1;
2543         tbm_format format = TBM_FORMAT_XBGR8888;
2544
2545         _init_test();
2546
2547         ret = tbm_surface_internal_get_num_planes(format);
2548
2549         ASSERT_EQ(ret, expected_ret);
2550 }
2551
2552 TEST(tbm_surface_internal_get_num_planes, work_flow_success_24)
2553 {
2554         int ret = 0;
2555         int expected_ret = 1;
2556         tbm_format format = TBM_FORMAT_XRGB8888;
2557
2558         _init_test();
2559
2560         ret = tbm_surface_internal_get_num_planes(format);
2561
2562         ASSERT_EQ(ret, expected_ret);
2563 }
2564
2565 TEST(tbm_surface_internal_get_num_planes, work_flow_success_23)
2566 {
2567         int ret = 0;
2568         int expected_ret = 1;
2569         tbm_format format = TBM_FORMAT_BGR888;
2570
2571         _init_test();
2572
2573         ret = tbm_surface_internal_get_num_planes(format);
2574
2575         ASSERT_EQ(ret, expected_ret);
2576 }
2577
2578 TEST(tbm_surface_internal_get_num_planes, work_flow_success_22)
2579 {
2580         int ret = 0;
2581         int expected_ret = 1;
2582         tbm_format format = TBM_FORMAT_RGB888;
2583
2584         _init_test();
2585
2586         ret = tbm_surface_internal_get_num_planes(format);
2587
2588         ASSERT_EQ(ret, expected_ret);
2589 }
2590
2591 TEST(tbm_surface_internal_get_num_planes, work_flow_success_21)
2592 {
2593         int ret = 0;
2594         int expected_ret = 1;
2595         tbm_format format = TBM_FORMAT_BGR565;
2596
2597         _init_test();
2598
2599         ret = tbm_surface_internal_get_num_planes(format);
2600
2601         ASSERT_EQ(ret, expected_ret);
2602 }
2603
2604 TEST(tbm_surface_internal_get_num_planes, work_flow_success_20)
2605 {
2606         int ret = 0;
2607         int expected_ret = 1;
2608         tbm_format format = TBM_FORMAT_RGB565;
2609
2610         _init_test();
2611
2612         ret = tbm_surface_internal_get_num_planes(format);
2613
2614         ASSERT_EQ(ret, expected_ret);
2615 }
2616
2617 TEST(tbm_surface_internal_get_num_planes, work_flow_success_19)
2618 {
2619         int ret = 0;
2620         int expected_ret = 1;
2621         tbm_format format = TBM_FORMAT_BGRA5551;
2622
2623         _init_test();
2624
2625         ret = tbm_surface_internal_get_num_planes(format);
2626
2627         ASSERT_EQ(ret, expected_ret);
2628 }
2629
2630 TEST(tbm_surface_internal_get_num_planes, work_flow_success_18)
2631 {
2632         int ret = 0;
2633         int expected_ret = 1;
2634         tbm_format format = TBM_FORMAT_RGBA5551;
2635
2636         _init_test();
2637
2638         ret = tbm_surface_internal_get_num_planes(format);
2639
2640         ASSERT_EQ(ret, expected_ret);
2641 }
2642
2643 TEST(tbm_surface_internal_get_num_planes, work_flow_success_17)
2644 {
2645         int ret = 0;
2646         int expected_ret = 1;
2647         tbm_format format = TBM_FORMAT_ABGR1555;
2648
2649         _init_test();
2650
2651         ret = tbm_surface_internal_get_num_planes(format);
2652
2653         ASSERT_EQ(ret, expected_ret);
2654 }
2655
2656 TEST(tbm_surface_internal_get_num_planes, work_flow_success_16)
2657 {
2658         int ret = 0;
2659         int expected_ret = 1;
2660         tbm_format format = TBM_FORMAT_ARGB1555;
2661
2662         _init_test();
2663
2664         ret = tbm_surface_internal_get_num_planes(format);
2665
2666         ASSERT_EQ(ret, expected_ret);
2667 }
2668
2669 TEST(tbm_surface_internal_get_num_planes, work_flow_success_15)
2670 {
2671         int ret = 0;
2672         int expected_ret = 1;
2673         tbm_format format = TBM_FORMAT_BGRX5551;
2674
2675         _init_test();
2676
2677         ret = tbm_surface_internal_get_num_planes(format);
2678
2679         ASSERT_EQ(ret, expected_ret);
2680 }
2681
2682 TEST(tbm_surface_internal_get_num_planes, work_flow_success_14)
2683 {
2684         int ret = 0;
2685         int expected_ret = 1;
2686         tbm_format format = TBM_FORMAT_RGBX5551;
2687
2688         _init_test();
2689
2690         ret = tbm_surface_internal_get_num_planes(format);
2691
2692         ASSERT_EQ(ret, expected_ret);
2693 }
2694
2695 TEST(tbm_surface_internal_get_num_planes, work_flow_success_13)
2696 {
2697         int ret = 0;
2698         int expected_ret = 1;
2699         tbm_format format = TBM_FORMAT_XBGR1555;
2700
2701         _init_test();
2702
2703         ret = tbm_surface_internal_get_num_planes(format);
2704
2705         ASSERT_EQ(ret, expected_ret);
2706 }
2707
2708 TEST(tbm_surface_internal_get_num_planes, work_flow_success_12)
2709 {
2710         int ret = 0;
2711         int expected_ret = 1;
2712         tbm_format format = TBM_FORMAT_XRGB1555;
2713
2714         _init_test();
2715
2716         ret = tbm_surface_internal_get_num_planes(format);
2717
2718         ASSERT_EQ(ret, expected_ret);
2719 }
2720
2721 TEST(tbm_surface_internal_get_num_planes, work_flow_success_11)
2722 {
2723         int ret = 0;
2724         int expected_ret = 1;
2725         tbm_format format = TBM_FORMAT_BGRA4444;
2726
2727         _init_test();
2728
2729         ret = tbm_surface_internal_get_num_planes(format);
2730
2731         ASSERT_EQ(ret, expected_ret);
2732 }
2733
2734 TEST(tbm_surface_internal_get_num_planes, work_flow_success_10)
2735 {
2736         int ret = 0;
2737         int expected_ret = 1;
2738         tbm_format format = TBM_FORMAT_RGBA4444;
2739
2740         _init_test();
2741
2742         ret = tbm_surface_internal_get_num_planes(format);
2743
2744         ASSERT_EQ(ret, expected_ret);
2745 }
2746
2747 TEST(tbm_surface_internal_get_num_planes, work_flow_success_9)
2748 {
2749         int ret = 0;
2750         int expected_ret = 1;
2751         tbm_format format = TBM_FORMAT_ABGR4444;
2752
2753         _init_test();
2754
2755         ret = tbm_surface_internal_get_num_planes(format);
2756
2757         ASSERT_EQ(ret, expected_ret);
2758 }
2759
2760 TEST(tbm_surface_internal_get_num_planes, work_flow_success_8)
2761 {
2762         int ret = 0;
2763         int expected_ret = 1;
2764         tbm_format format = TBM_FORMAT_ARGB4444;
2765
2766         _init_test();
2767
2768         ret = tbm_surface_internal_get_num_planes(format);
2769
2770         ASSERT_EQ(ret, expected_ret);
2771 }
2772
2773 TEST(tbm_surface_internal_get_num_planes, work_flow_success_7)
2774 {
2775         int ret = 0;
2776         int expected_ret = 1;
2777         tbm_format format = TBM_FORMAT_BGRX4444;
2778
2779         _init_test();
2780
2781         ret = tbm_surface_internal_get_num_planes(format);
2782
2783         ASSERT_EQ(ret, expected_ret);
2784 }
2785
2786 TEST(tbm_surface_internal_get_num_planes, work_flow_success_6)
2787 {
2788         int ret = 0;
2789         int expected_ret = 1;
2790         tbm_format format = TBM_FORMAT_RGBX4444;
2791
2792         _init_test();
2793
2794         ret = tbm_surface_internal_get_num_planes(format);
2795
2796         ASSERT_EQ(ret, expected_ret);
2797 }
2798
2799 TEST(tbm_surface_internal_get_num_planes, work_flow_success_5)
2800 {
2801         int ret = 0;
2802         int expected_ret = 1;
2803         tbm_format format = TBM_FORMAT_XBGR4444;
2804
2805         _init_test();
2806
2807         ret = tbm_surface_internal_get_num_planes(format);
2808
2809         ASSERT_EQ(ret, expected_ret);
2810 }
2811
2812 TEST(tbm_surface_internal_get_num_planes, work_flow_success_4)
2813 {
2814         int ret = 0;
2815         int expected_ret = 1;
2816         tbm_format format = TBM_FORMAT_XRGB4444;
2817
2818         _init_test();
2819
2820         ret = tbm_surface_internal_get_num_planes(format);
2821
2822         ASSERT_EQ(ret, expected_ret);
2823 }
2824
2825 TEST(tbm_surface_internal_get_num_planes, work_flow_success_3)
2826 {
2827         int ret = 0;
2828         int expected_ret = 1;
2829         tbm_format format = TBM_FORMAT_BGR233;
2830
2831         _init_test();
2832
2833         ret = tbm_surface_internal_get_num_planes(format);
2834
2835         ASSERT_EQ(ret, expected_ret);
2836 }
2837
2838 TEST(tbm_surface_internal_get_num_planes, work_flow_success_2)
2839 {
2840         int ret = 0;
2841         int expected_ret = 1;
2842         tbm_format format = TBM_FORMAT_RGB332;
2843
2844         _init_test();
2845
2846         ret = tbm_surface_internal_get_num_planes(format);
2847
2848         ASSERT_EQ(ret, expected_ret);
2849 }
2850
2851 TEST(tbm_surface_internal_get_num_planes, work_flow_success_1)
2852 {
2853         int ret = 0;
2854         int expected_ret = 1;
2855         tbm_format format = TBM_FORMAT_C8;
2856
2857         _init_test();
2858
2859         ret = tbm_surface_internal_get_num_planes(format);
2860
2861         ASSERT_EQ(ret, expected_ret);
2862 }
2863
2864 /* tbm_surface_internal_query_supported_formats() */
2865
2866 TEST(tbm_surface_internal_query_supported_formats, work_flow_success_3)
2867 {
2868         int ret = 0;
2869         int expecte_ret = 1;
2870         uint32_t *formats, num = 0;
2871         struct _tbm_bufmgr bufmgr;
2872         struct _tbm_bufmgr_backend backend;
2873
2874         _init_test();
2875
2876         g_surface_bufmgr = &bufmgr;
2877         bufmgr.backend = &backend;
2878         ut_ret_bufmgr.backend = &backend;
2879         backend.surface_supported_format = ut_surface_supported_format;
2880
2881         ret = tbm_surface_internal_query_supported_formats(&formats, &num);
2882
2883         ASSERT_EQ(ret, expecte_ret);
2884 }
2885
2886 TEST(tbm_surface_internal_query_supported_formats, work_flow_success_2)
2887 {
2888         int ret = 0;
2889         int expecte_ret = 0;
2890         uint32_t *formats, num = 0;
2891         struct _tbm_bufmgr bufmgr;
2892         struct _tbm_bufmgr_backend backend;
2893
2894         _init_test();
2895
2896         g_surface_bufmgr = &bufmgr;
2897         bufmgr.backend = &backend;
2898         ut_ret_bufmgr.backend = &backend;
2899         backend.surface_supported_format = ut_surface_supported_format;
2900         UT_TBM_SURFACE_INTERNAL_ERROR = 1;
2901
2902         ret = tbm_surface_internal_query_supported_formats(&formats, &num);
2903
2904         ASSERT_EQ(ret, expecte_ret);
2905 }
2906
2907 TEST(tbm_surface_internal_query_supported_formats, work_flow_success_1)
2908 {
2909         int ret = 0;
2910         int expecte_ret = 0;
2911         uint32_t *formats, num = 0;
2912         struct _tbm_bufmgr bufmgr;
2913         struct _tbm_bufmgr_backend backend;
2914
2915         _init_test();
2916
2917         g_surface_bufmgr = &bufmgr;
2918         bufmgr.backend = &backend;
2919         ut_ret_bufmgr.backend = &backend;
2920         backend.surface_supported_format = NULL;
2921
2922         ret = tbm_surface_internal_query_supported_formats(&formats, &num);
2923
2924         ASSERT_EQ(ret, expecte_ret);
2925 }
2926
2927 /* tbm_surface_internal_create_with_flags() */
2928
2929 TEST(tbm_surface_internal_create_with_flags, error_calloc)
2930 {
2931         tbm_surface_h surface_ret;
2932
2933         _init_test();
2934
2935         CALLOC_ERROR = 1;
2936
2937         surface_ret = tbm_surface_internal_create_with_flags(10, 10, 10, 10);
2938
2939         ASSERT_TRUE(surface_ret == NULL);
2940 }
2941
2942 TEST(tbm_surface_internal_create_with_flags, success)
2943 {
2944         tbm_surface_h surface_ret;
2945         int width = 1080;
2946         int height = 1920;
2947         int format = TBM_FORMAT_ARGB8888;
2948         int flags = 1;
2949         struct _tbm_bufmgr mgr;
2950         struct _tbm_bufmgr_backend backend;
2951
2952         _init_test();
2953
2954         g_surface_bufmgr = &mgr;
2955         mgr.backend = &backend;
2956         backend.surface_get_plane_data = ut_surface_get_plane_data;
2957         backend.surface_bo_alloc = ut_surface_bo_alloc;
2958
2959         LIST_INITHEAD(&mgr.bo_list);
2960         LIST_INITHEAD(&mgr.surf_list);
2961
2962         surface_ret =
2963                 tbm_surface_internal_create_with_flags(width, height, format, flags);
2964
2965         ASSERT_TRUE(surface_ret != NULL);
2966         ASSERT_FALSE(LIST_IS_EMPTY(&mgr.bo_list));
2967         ASSERT_FALSE(LIST_IS_EMPTY(&mgr.surf_list));
2968 }