utests/ut_tbm_surface_internal.cpp

   1 #include <gtest/gtest.h>
   2 #include <stdlib.h>
   3
   4 #include <tbm_bufmgr.h>
   5 #include <tbm_surface.h>
   6 #include <tbm_surface_internal.h>
   7 #include <climits>
   8 #include "ut.h"
   9
  10 /* int tbm_surface_internal_query_supported_formats(uint32_t **formats, uint32_t *num) */
  11 TEST_F(UtInit, SurfaceInternalQueryFormatsFailNull)
  12 {
  13         uint32_t num = 0;
  14         tbm_format *formats = NULL;
  15
  16         ut_set_default_tbm_env();
  17
  18         ASSERT_FALSE(tbm_surface_internal_query_supported_formats(&formats, NULL));
  19
  20         ASSERT_FALSE(tbm_surface_internal_query_supported_formats(NULL, &num));
  21 }
  22
  23 TEST_F(UtInit, SurfaceInternalQueryFormatsSuccess)
  24 {
  25         uint32_t num = 0;
  26         tbm_format *formats = NULL;
  27
  28         ut_set_default_tbm_env();
  29
  30         ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num));
  31         ASSERT_NE(0, num);
  32         ASSERT_NE((tbm_format *)NULL, formats);
  33         for (uint32_t i = 0; i < num; i++)
  34                 ASSERT_NE(0, formats[i]);
  35
  36         if (formats)
  37                 free(formats);
  38 }
  39
  40
  41 /* tbm_surface_h tbm_surface_internal_create_with_flags(int width, int height, int format, int flags) */
  42 TEST_F(UtInit, SurfaceInternalCeatewithFlagsFailInvalidInput)
  43 {
  44         tbm_surface_h surface = NULL;
  45
  46         ut_set_default_tbm_env();
  47
  48         surface = tbm_surface_internal_create_with_flags(-1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  49         ASSERT_EQ(nullptr, surface); // Expected Value: NULL
  50
  51         surface = tbm_surface_internal_create_with_flags(720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  52         ASSERT_EQ(nullptr, surface);
  53
  54         surface = tbm_surface_internal_create_with_flags(720, 1024, 0, TBM_BO_DEFAULT);
  55         ASSERT_EQ(nullptr, surface);
  56
  57         surface = tbm_surface_internal_create_with_flags(720, 1024, 0, (TBM_BO_WC << 1));
  58         ASSERT_EQ(nullptr, surface);
  59 }
  60
  61 TEST_F(UtInit, SurfaceInternalCeatewithFlagsSuccess)
  62 {
  63         tbm_surface_h surface = NULL;
  64         uint32_t num = 0;
  65         tbm_format *formats = NULL;
  66
  67         ut_set_default_tbm_env();
  68
  69         ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num));
  70
  71         for (uint32_t i = 0; i < num; i++) {
  72                 surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
  73                 ASSERT_NE(nullptr, surface);
  74                 tbm_surface_internal_destroy(surface);
  75         }
  76
  77         if (formats)
  78                 free(formats);
  79 }
  80
  81
  82 /* void tbm_surface_internal_destroy(tbm_surface_h surface) */
  83 TEST_F(UtInit, SurfaceInternalSurfaceInteranlDestroyFailNULL)
  84 {
  85         ut_set_default_tbm_env();
  86
  87         tbm_surface_internal_destroy(NULL);
  88 }
  89
  90 TEST_F(UtInit, SurfaceInteranlDestroyFailTwice)
  91 {
  92         tbm_surface_h surface = NULL;
  93         uint32_t num = 0;
  94         tbm_format *formats = NULL;
  95
  96         ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num));
  97         ASSERT_TRUE(formats != NULL);
  98         ASSERT_TRUE(num > 0);
  99
 100         surface = tbm_surface_internal_create_with_flags(720, 1024, formats[0], TBM_BO_DEFAULT);
 101
 102         tbm_surface_internal_destroy(surface);
 103
 104         tbm_surface_internal_destroy(surface);
 105
 106         free(formats);
 107 }
 108
 109
 110 /* tbm_surface_internal_is_valid(tbm_surface_h surface) */
 111 TEST_F(SurfaceInternalTest, IsValid)
 112 {
 113         int invalid_surf;
 114
 115         ASSERT_FALSE(tbm_surface_internal_is_valid(NULL));
 116         ASSERT_FALSE(tbm_surface_internal_is_valid((tbm_surface_h)&invalid_surf));
 117         ASSERT_TRUE(tbm_surface_internal_is_valid(surface));;
 118 }
 119
 120
 121 /* int tbm_surface_internal_get_num_bos(tbm_surface_h surface) */
 122 TEST_F(SurfaceInternalTest, GetNumBosFailNULL)
 123 {
 124         int num = tbm_surface_internal_get_num_bos(NULL);
 125         ASSERT_EQ(0, num);
 126 }
 127
 128 TEST_F(SurfaceInternalTest, GetNumBosSuccess)
 129 {
 130         int num = tbm_surface_internal_get_num_bos(surface);
 131         ASSERT_TRUE(num > 0);
 132 }
 133
 134 /* tbm_bo tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx) */
 135 TEST_F(SurfaceInternalTest, GetBoFailNULL)
 136 {
 137         tbm_bo bo = tbm_surface_internal_get_bo(NULL, 0);
 138         ASSERT_EQ(nullptr, bo);
 139 }
 140
 141 TEST_F(SurfaceInternalTest, GetBoFailInvalideInput)
 142 {
 143         tbm_surface_h invalide_surface = (tbm_surface_h)1;
 144         tbm_bo bo = NULL;
 145         int num = 0;
 146
 147         /* invalid surface */
 148         bo = tbm_surface_internal_get_bo(invalide_surface, 0);
 149         ASSERT_EQ(nullptr, bo);
 150
 151         num = tbm_surface_internal_get_num_bos(surface);
 152         ASSERT_TRUE(num > 0);
 153
 154         /* invalid index of bo */
 155         bo = tbm_surface_internal_get_bo(surface, -1);
 156         ASSERT_EQ(nullptr, bo);
 157         bo = tbm_surface_internal_get_bo(surface, num);
 158         ASSERT_EQ(nullptr, bo);
 159 }
 160
 161 TEST_F(SurfaceInternalTest, GetBoSuccess)
 162 {
 163         tbm_bo bo = NULL;
 164         int num = 0;
 165
 166         num = tbm_surface_internal_get_num_bos(surface);
 167         ASSERT_TRUE(num > 0);
 168
 169         for (int i = 0; i < num; i++) {
 170                 bo = tbm_surface_internal_get_bo(surface, i);
 171                 ASSERT_NE((tbm_bo)NULL, bo);
 172         }
 173 }
 174
 175 /* tbm_surface_h tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, tbm_bo *bos, int num) */
 176 TEST_F(SurfaceInternalTest, CreateWithBosNullInput)
 177 {
 178         tbm_surface_h surf = NULL;
 179         tbm_surface_info_s info = { 0 };
 180         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 181         tbm_bo bos[1];
 182
 183         result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
 184         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 185
 186         surf = tbm_surface_internal_create_with_bos(NULL, NULL, 1);
 187
 188         surf = tbm_surface_internal_create_with_bos(&info, NULL, 1);
 189         ASSERT_EQ(nullptr, surf);
 190
 191         surf = tbm_surface_internal_create_with_bos(NULL, bos, 1);
 192         ASSERT_EQ(nullptr, surf);
 193 }
 194
 195 TEST_F(SurfaceInternalTest, CreateWithBosFailInvalidInput)
 196 {
 197         tbm_surface_h surf = NULL;
 198         tbm_surface_info_s info;
 199         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 200         tbm_bo bos[4] = { NULL };
 201         int num;
 202
 203         result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
 204         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 205
 206         num = tbm_surface_internal_get_num_bos(surface);
 207         ASSERT_TRUE(num > 0);
 208
 209         for (int i = 0; i < num; i++) {
 210                 bos[i] = tbm_surface_internal_get_bo(surface, i);
 211                 ASSERT_NE(nullptr, bos[i]);
 212         }
 213
 214
 215         /* wrong number of bo */
 216         surf = tbm_surface_internal_create_with_bos(&info, bos, num + 1);
 217         ASSERT_EQ(nullptr, surf);
 218         surf = tbm_surface_internal_create_with_bos(&info, bos, num - 1);
 219         ASSERT_EQ(nullptr, surf);
 220
 221         /* invalid bo */
 222         bos[num-1] = NULL;
 223         surf = tbm_surface_internal_create_with_bos(&info, bos, num);
 224         ASSERT_EQ(nullptr, surf);
 225 }
 226
 227 TEST_F(SurfaceInternalTest, CreateWithBosSuccess)
 228 {
 229         tbm_surface_h surf = NULL;
 230         tbm_surface_info_s info;
 231         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 232         tbm_bo bos[4] = { NULL };
 233         int num = 0;
 234
 235         result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
 236         ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
 237
 238         num = tbm_surface_internal_get_num_bos(surface);
 239         ASSERT_TRUE(num > 0);
 240
 241         for (int i = 0; i < num; i++) {
 242                 bos[i] = tbm_surface_internal_get_bo(surface, i);
 243                 ASSERT_NE(nullptr, bos[i]);
 244         }
 245
 246         surf = tbm_surface_internal_create_with_bos(&info, bos, num);
 247         ASSERT_NE(nullptr, surf);
 248         tbm_surface_internal_destroy(surf);
 249
 250         /* set size plane to zero*/
 251         info.planes[0].size = 0;
 252         surf = tbm_surface_internal_create_with_bos(&info, bos, num);
 253         ASSERT_NE(nullptr, surf);
 254         tbm_surface_internal_destroy(surf);
 255
 256         /* set bpp to zero*/
 257         info.bpp = 0;
 258         surf = tbm_surface_internal_create_with_bos(&info, bos, num);
 259         ASSERT_NE(nullptr, surf);
 260         tbm_surface_internal_destroy(surf);
 261
 262         /* set size to zero*/
 263         info.size = 0;
 264         surf = tbm_surface_internal_create_with_bos(&info, bos, num);
 265         ASSERT_NE(nullptr, surf);
 266         tbm_surface_internal_destroy(surf);
 267 }
 268
 269 /* void tbm_surface_internal_unref(tbm_surface_h surface) */
 270 TEST_F(SurfaceInternalTest, UnrefFailNull)
 271 {
 272         tbm_surface_internal_unref(NULL);
 273 }
 274
 275 TEST_F(SurfaceInternalTest, UnrefFailInvaildInput)
 276 {
 277         int surf;
 278         tbm_surface_internal_unref((tbm_surface_h)&surf);
 279 }
 280
 281 TEST_F(SurfaceInternalTest, UnrefSuccess)
 282 {
 283         tbm_surface_internal_unref(surface);
 284
 285         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) ;
 286
 287         surface = NULL;
 288 }
 289
 290 /* void tbm_surface_internal_ref(tbm_surface_h surface) */
 291 TEST_F(UtInit, RefFailNull)
 292 {
 293         tbm_surface_internal_ref(NULL);
 294 }
 295
 296 TEST_F(UtInit, RefFailInvaildInput)
 297 {
 298         int surf;
 299         tbm_surface_internal_ref((tbm_surface_h)&surf);
 300 }
 301
 302 TEST_F(SurfaceInternalTest, RefSuccess)
 303 {
 304         tbm_surface_internal_ref(surface);
 305         tbm_surface_internal_unref(surface);
 306         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) ;
 307 }
 308
 309 /* tbm_surface_internal_get_num_planes() */
 310 TEST_F(UtInit, GetNumPlanes)
 311 {
 312         int num = 0;
 313         num = tbm_surface_internal_get_num_planes(0);
 314         ASSERT_EQ(0, num);
 315
 316         num = tbm_surface_internal_get_num_planes(TBM_FORMAT_ARGB8888);
 317         ASSERT_EQ(1, num);
 318
 319         num = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
 320         ASSERT_EQ(2, num);
 321
 322         num = tbm_surface_internal_get_num_planes(TBM_FORMAT_YUV410);
 323         ASSERT_EQ(3, num);
 324 }
 325
 326 /* tbm_surface_internal_get_size() */
 327 TEST_F(SurfaceInternalTest, GetSizeFailNull)
 328 {
 329         int size = tbm_surface_internal_get_size(NULL);
 330         ASSERT_EQ(0, size);
 331 }
 332
 333 TEST_F(SurfaceInternalTest, GetSizeFailInvaildInput)
 334 {
 335         int surf;
 336         int size = tbm_surface_internal_get_size((tbm_surface_h)&surf);
 337         ASSERT_EQ(0, size);
 338 }
 339
 340 TEST_F(SurfaceInternalTest, GetSizeSuccess)
 341 {
 342         int size = tbm_surface_internal_get_size(surface);
 343         ASSERT_GT(size, 0);
 344 }
 345
 346 /* tbm_surface_internal_get_plane_data(tbm_surface_h surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch) */
 347 TEST_F(SurfaceInternalTest, GetPlaneDataFailNull)
 348 {
 349         ASSERT_FALSE(tbm_surface_internal_get_plane_data(NULL, 0, NULL, NULL, NULL));
 350 }
 351
 352 TEST_F(SurfaceInternalTest, GetPlaneDataFailInvaildInput)
 353 {
 354         int surf;
 355
 356         ASSERT_FALSE(tbm_surface_internal_get_plane_data((tbm_surface_h)&surf, 0, NULL, NULL, NULL));
 357         ASSERT_FALSE(tbm_surface_internal_get_plane_data(surface, -1, NULL, NULL, NULL));
 358         ASSERT_FALSE(tbm_surface_internal_get_plane_data(surface, 3, NULL, NULL, NULL));
 359 }
 360
 361 TEST_F(SurfaceInternalTest, GetPlaneDataSuccess)
 362 {
 363         uint32_t size = 0, offset = 0, pitch = 0;
 364
 365         ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, &size, NULL, NULL));
 366         ASSERT_GT(size, 0);
 367
 368         ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, &offset, NULL));
 369
 370         ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, NULL, &pitch));
 371         ASSERT_GT(pitch, 0);
 372 }
 373
 374 /* tbm_surface_internal_get_bpp(tbm_format format) */
 375 TEST_F(UtInit, GetBpp)
 376 {
 377         int bpp = 0;
 378         bpp = tbm_surface_internal_get_bpp(0);
 379         ASSERT_EQ(0, bpp);
 380
 381         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB332);
 382         ASSERT_EQ(8, bpp);
 383
 384         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB565);
 385         ASSERT_EQ(16, bpp);
 386
 387         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB888);
 388         ASSERT_EQ(24, bpp);
 389
 390         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_ARGB8888);
 391         ASSERT_EQ(32, bpp);
 392
 393         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
 394         ASSERT_EQ(12, bpp);
 395
 396         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV16);
 397         ASSERT_EQ(16, bpp);
 398
 399         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV410);
 400         ASSERT_EQ(9, bpp);
 401
 402         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV411);
 403         ASSERT_EQ(12, bpp);
 404
 405         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV422);
 406         ASSERT_EQ(16, bpp);
 407
 408         bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV444);
 409         ASSERT_EQ(24, bpp);
 410 }
 411 /* tbm_surface_internal_get_plane_bo_idx(tbm_surface_h surface, int plane_idx) */
 412 TEST_F(SurfaceInternalTest, GetPlaneBoIndexFailNull)
 413 {
 414         int idx = tbm_surface_internal_get_plane_bo_idx(NULL, 0);
 415         ASSERT_EQ(0, idx);
 416 }
 417
 418 TEST_F(SurfaceInternalTest, GetPlaneBoIndexFailInvaildInput)
 419 {
 420         int surf;
 421         int idx;
 422
 423         idx = tbm_surface_internal_get_plane_bo_idx((tbm_surface_h)&surf, 0);
 424         ASSERT_EQ(0, idx);
 425
 426         idx = tbm_surface_internal_get_plane_bo_idx(surface, -1);
 427         ASSERT_EQ(0, idx);
 428 }
 429
 430 TEST_F(SurfaceInternalTest, GetPlaneBoIndexSuccess)
 431 {
 432         int idx;
 433
 434         idx = tbm_surface_internal_get_plane_bo_idx(surface, 0);
 435         ASSERT_EQ(0, idx);
 436 }
 437
 438 static int tbm_data_free_is_called = 0;
 439 void data_free_handle(void *user_data)
 440 {
 441         ASSERT_TRUE(user_data == &tbm_data_free_is_called);
 442         int *is_called = (int *)user_data;
 443         *is_called = 1;
 444 }
 445
 446 /* tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key, tbm_data_free data_free_func) */
 447 TEST_F(SurfaceInternalTest, AddUserDataFailNull)
 448 {
 449         static const unsigned long key_ud = 0;
 450         ASSERT_FALSE(tbm_surface_internal_add_user_data(NULL, key_ud, NULL));
 451 }
 452
 453 TEST_F(SurfaceInternalTest, AddUserDataFailInvaildInput)
 454 {
 455         static const unsigned long key_ud = 0;
 456         int surf;
 457         ASSERT_FALSE(tbm_surface_internal_add_user_data((tbm_surface_h)&surf, key_ud, NULL));
 458 }
 459
 460 TEST_F(SurfaceInternalTest, AddUserDataSuccess)
 461 {
 462         unsigned long key_ud = 157;
 463         ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
 464 }
 465
 466 TEST_F(SurfaceInternalTest, AddUserDataFailDoubleKey)
 467 {
 468         unsigned long key_ud = 5487;
 469         ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
 470
 471         ASSERT_FALSE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
 472 }
 473
 474 /* tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key, void *data) */
 475 TEST_F(SurfaceInternalTest, SetUserDataFailNull)
 476 {
 477         static const unsigned long key_ud = 0;
 478         ASSERT_FALSE(tbm_surface_internal_set_user_data(NULL, key_ud, &tbm_data_free_is_called));
 479 }
 480
 481 TEST_F(SurfaceInternalTest, SetUserDataFailInvaildInput)
 482 {
 483         static const unsigned long key_ud = 0;
 484         int surf;
 485
 486         ASSERT_FALSE(tbm_surface_internal_set_user_data(surface,
 487                         key_ud, &tbm_data_free_is_called)) << "invalid key";
 488
 489         ASSERT_FALSE(tbm_surface_internal_set_user_data((tbm_surface_h)&surf,
 490                         key_ud, &tbm_data_free_is_called)) << "invalid surface";
 491
 492 }
 493
 494 TEST_F(SurfaceInternalTest, SetUserDataSuccess)
 495 {
 496         unsigned long key_ud = 87947;
 497         ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
 498
 499         /*the first call*/
 500         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
 501
 502         /*the second call: previous data has to be released*/
 503         tbm_data_free_is_called = 0;
 504         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
 505         ASSERT_TRUE(tbm_data_free_is_called);
 506
 507         /*the third call: previous data(NULL) hasn't to be released*/
 508         tbm_data_free_is_called = 0;
 509         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
 510         ASSERT_FALSE(tbm_data_free_is_called);
 511 }
 512
 513 /* tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key, void **data) */
 514 TEST_F(SurfaceInternalTest, GetUserDataFailNull)
 515 {
 516         static const unsigned long key_ud = 0;
 517         int *data = NULL;
 518         ASSERT_FALSE(tbm_surface_internal_get_user_data(NULL, key_ud, (void **)&data));
 519
 520         ASSERT_FALSE(tbm_surface_internal_get_user_data(surface, key_ud, NULL));
 521 }
 522
 523 TEST_F(SurfaceInternalTest, GetUserDataFailInvaildInput)
 524 {
 525         static const unsigned long key_ud = 0;
 526         int surf;
 527         int *data = NULL;
 528
 529         ASSERT_FALSE(tbm_surface_internal_get_user_data(surface,
 530                         key_ud, (void **)&data)) << "invalid key" << std::endl;
 531
 532         ASSERT_FALSE(tbm_surface_internal_get_user_data((tbm_surface_h)&surf,
 533                         key_ud, (void **)&data)) << "invalid surface" << std::endl;
 534
 535 }
 536
 537 TEST_F(SurfaceInternalTest, GetUserDataSuccess)
 538 {
 539         unsigned long key_ud = 97456789;
 540         int *data = NULL;
 541
 542         ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
 543         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
 544
 545         /* check set data */
 546         ASSERT_TRUE(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data));
 547         ASSERT_TRUE(data == &tbm_data_free_is_called);
 548
 549         /* check if data is NULL */
 550         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
 551         ASSERT_TRUE(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data));
 552         ASSERT_TRUE(data == NULL);
 553 }
 554
 555 /* tbm_surface_internal_delete_user_data(tbm_surface_h surface, unsigned long key) */
 556 TEST_F(SurfaceInternalTest, DeleteUserDataFailNull)
 557 {
 558         static const int key_ud = 0;
 559         ASSERT_FALSE(tbm_surface_internal_delete_user_data(NULL, key_ud));
 560 }
 561
 562 TEST_F(SurfaceInternalTest, DeleteUserDataFailInvaildInput)
 563 {
 564         static const int key_ud = 0;
 565         int surf;
 566         ASSERT_FALSE(tbm_surface_internal_delete_user_data(surface, key_ud)) << "invalid key";
 567
 568         ASSERT_FALSE(tbm_surface_internal_delete_user_data((tbm_surface_h)&surf, key_ud)) << "invalid surface";
 569 }
 570
 571 TEST_F(SurfaceInternalTest, DeleteUserDataSuccess)
 572 {
 573         unsigned long key_ud = UINT_MAX;
 574
 575         ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
 576         ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
 577
 578         tbm_data_free_is_called = 0;
 579         ASSERT_TRUE(tbm_surface_internal_delete_user_data(surface, key_ud));
 580         ASSERT_TRUE(tbm_data_free_is_called);
 581         ASSERT_FALSE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
 582 }