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