haltests/tc_tbm_bo.cpp

   1
   2 /**************************************************************************
   3  *
   4  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   5  *
   6  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   7  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   8  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the
  12  * "Software"), to deal in the Software without restriction, including
  13  * without limitation the rights to use, copy, modify, merge, publish,
  14  * distribute, sub license, and/or sell copies of the Software, and to
  15  * permit persons to whom the Software is furnished to do so, subject to
  16  * the following conditions:
  17  *
  18  * The above copyright notice and this permission notice (including the
  19  * next paragraph) shall be included in all copies or substantial portions
  20  * of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  25  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  26  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29  *
  30 **************************************************************************/
  31
  32 #include "tc_tbm.h"
  33
  34 class TBMBo : public TBMBufmgr
  35 {
  36 public:
  37         TBMBo();
  38         void SetUp(void);
  39         void TearDown(void);
  40
  41         unsigned int bufmgr_capability;
  42 };
  43
  44 TBMBo::TBMBo()
  45 {
  46         bufmgr_capability = TBM_BUFMGR_CAPABILITY_NONE;
  47 }
  48
  49 void TBMBo::SetUp()
  50 {
  51         TBMBufmgr::SetUp();
  52
  53         bufmgr_capability = tbm_bufmgr_get_capability(bufmgr);
  54         EXPECT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
  55 }
  56
  57 void TBMBo::TearDown()
  58 {
  59         TBMBufmgr::TearDown();
  60 }
  61
  62 /* tbm_bo_alloc() */
  63
  64 TEST_F(TBMBo, BoAllocUnref)
  65 {
  66         tbm_bo bo;
  67
  68         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
  69         EXPECT_NE(bo, nullptr);
  70         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
  71
  72         tbm_bo_unref(bo);
  73 }
  74
  75 TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
  76 {
  77         tbm_bo bo;
  78         tbm_bufmgr invalid_bufmgr;
  79
  80         invalid_bufmgr = NULL;
  81         bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
  82         EXPECT_EQ(bo, nullptr);
  83         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
  84
  85         invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
  86         bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
  87         EXPECT_EQ(bo, nullptr);
  88         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
  89 }
  90
  91 TEST_F(TBMBo, BoAllocWithSizeParamTest)
  92 {
  93         tbm_bo bo;
  94
  95         bo = tbm_bo_alloc(bufmgr, -1, TBM_BO_DEFAULT);
  96         EXPECT_EQ(bo, nullptr);
  97         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
  98 }
  99
 100 TEST_F(TBMBo, BoAllocWithFlagsParamTest)
 101 {
 102         tbm_bo bo;
 103
 104         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 105         EXPECT_NE(bo, nullptr);
 106         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 107         tbm_bo_unref(bo);
 108
 109         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_SCANOUT);
 110         EXPECT_NE(bo, nullptr);
 111         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 112         tbm_bo_unref(bo);
 113
 114         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_NONCACHABLE);
 115         EXPECT_NE(bo, nullptr);
 116         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 117         tbm_bo_unref(bo);
 118
 119         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_WC);
 120         EXPECT_NE(bo, nullptr);
 121         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 122         tbm_bo_unref(bo);
 123 }
 124
 125 /* tbm_bo_ref() */
 126
 127 TEST_F(TBMBo, BoRef)
 128 {
 129         tbm_bo bo;
 130
 131         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 132         EXPECT_NE(bo, nullptr);
 133         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 134
 135         bo = tbm_bo_ref(bo);
 136         EXPECT_NE(bo, nullptr);
 137         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 138
 139         tbm_bo_unref(bo);
 140         tbm_bo_unref(bo);
 141 }
 142
 143 TEST_F(TBMBo, BoRefWithBoParamTest)
 144 {
 145         tbm_bo bo, invalid_bo;
 146
 147         bo = tbm_bo_ref(NULL);
 148         EXPECT_EQ(bo, nullptr);
 149         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 150
 151         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 152         bo = tbm_bo_ref(invalid_bo);
 153         EXPECT_EQ(bo, nullptr);
 154         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 155 }
 156
 157 /* tbm_bo_unref() */
 158
 159 TEST_F(TBMBo, BoUnrefWithBoParamTest)
 160 {
 161         tbm_bo invalid_bo;
 162
 163         tbm_bo_unref(NULL);
 164         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 165
 166         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 167         tbm_bo_unref(invalid_bo);
 168         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 169 }
 170
 171 /* tbm_bo_map() */
 172
 173 TEST_F(TBMBo, BoMapUnmap)
 174 {
 175         tbm_bo bo;
 176         tbm_bo_handle bo_handle;
 177         int ret;
 178
 179         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 180         EXPECT_NE(bo, nullptr);
 181         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 182
 183         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 184         EXPECT_NE(bo_handle.ptr, nullptr);
 185         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 186
 187         ret = tbm_bo_unmap(bo);
 188         EXPECT_EQ(ret, 1);
 189         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 190
 191         tbm_bo_unref(bo);
 192 }
 193
 194 TEST_F(TBMBo, BoMapWithBoParamTest)
 195 {
 196         tbm_bo invalid_bo;
 197         tbm_bo_handle bo_handle;
 198
 199         bo_handle = tbm_bo_map(NULL, TBM_DEVICE_CPU, TBM_OPTION_READ);
 200         EXPECT_EQ(bo_handle.ptr, nullptr);
 201         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 202
 203         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 204         bo_handle = tbm_bo_map(invalid_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 205         EXPECT_EQ(bo_handle.ptr, nullptr);
 206         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 207 }
 208
 209 // TODO:: Use Value-Parameterized??
 210 TEST_F(TBMBo, BoMapWithDeviceParamTest)
 211 {
 212         tbm_bo bo;
 213         tbm_bo_handle bo_handle;
 214         int ret;
 215
 216         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 217         EXPECT_NE(bo, nullptr);
 218         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 219
 220         bo_handle = tbm_bo_map(bo, TBM_DEVICE_DEFAULT, TBM_OPTION_READ);
 221         EXPECT_NE(bo_handle.ptr, nullptr);
 222         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 223         ret = tbm_bo_unmap(bo);
 224         EXPECT_EQ(ret, 1);
 225         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 226
 227         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 228         EXPECT_NE(bo_handle.ptr, nullptr);
 229         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 230         ret = tbm_bo_unmap(bo);
 231         EXPECT_EQ(ret, 1);
 232         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 233
 234         bo_handle = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ);
 235         EXPECT_NE(bo_handle.ptr, nullptr);
 236         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 237         ret = tbm_bo_unmap(bo);
 238         EXPECT_EQ(ret, 1);
 239         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 240
 241         bo_handle = tbm_bo_map(bo, TBM_DEVICE_3D, TBM_OPTION_READ);
 242         EXPECT_NE(bo_handle.ptr, nullptr);
 243         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 244         ret = tbm_bo_unmap(bo);
 245         EXPECT_EQ(ret, 1);
 246         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 247
 248 #if 0
 249         bo_handle = tbm_bo_map(bo, TBM_DEVICE_MM, TBM_OPTION_READ);
 250         if (!bo_handle.ptr)
 251         EXPECT_NE(bo_handle.ptr, nullptr);
 252         ret = tbm_bo_unmap(bo);
 253         EXPECT_EQ(ret, 1);
 254 #endif
 255
 256         tbm_bo_unref(bo);
 257 }
 258
 259 // TODO:: Use Value-Parameterized??
 260 TEST_F(TBMBo, BoMapWithOptParamTest)
 261 {
 262         tbm_bo bo;
 263         tbm_bo_handle bo_handle;
 264         int ret;
 265
 266         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 267         EXPECT_NE(bo, nullptr);
 268         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 269
 270         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 271         EXPECT_NE(bo_handle.ptr, nullptr);
 272         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 273         ret = tbm_bo_unmap(bo);
 274         EXPECT_EQ(ret, 1);
 275         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 276
 277         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
 278         EXPECT_NE(bo_handle.ptr, nullptr);
 279         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 280         ret = tbm_bo_unmap(bo);
 281         EXPECT_EQ(ret, 1);
 282         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 283
 284         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ|TBM_OPTION_WRITE);
 285         EXPECT_NE(bo_handle.ptr, nullptr);
 286         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 287         ret = tbm_bo_unmap(bo);
 288         EXPECT_EQ(ret, 1);
 289         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 290
 291         tbm_bo_unref(bo);
 292 }
 293
 294 /* tbm_bo_unmap() */
 295
 296 TEST_F(TBMBo, BoUnmapWithBoParamTest)
 297 {
 298         tbm_bo bo;
 299         tbm_bo invalid_bo;
 300         int ret;
 301
 302         ret = tbm_bo_unmap(NULL);
 303         EXPECT_EQ(ret, 0);
 304         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 305
 306         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 307         ret = tbm_bo_unmap(invalid_bo);
 308         EXPECT_EQ(ret, 0);
 309         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 310
 311         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 312         EXPECT_NE(bo, nullptr);
 313         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 314         ret = tbm_bo_unmap(invalid_bo);
 315         EXPECT_EQ(ret, 0);
 316         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 317
 318         tbm_bo_unref(bo);
 319 }
 320
 321 /* tbm_bo_get_handle() */
 322
 323 TEST_F(TBMBo, BoGetHandle)
 324 {
 325         tbm_bo bo;
 326         tbm_bo_handle bo_handle;
 327
 328         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 329         EXPECT_NE(bo, nullptr);
 330         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 331         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
 332         EXPECT_NE(bo_handle.ptr, nullptr);
 333         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 334         tbm_bo_unref(bo);
 335 }
 336
 337 TEST_F(TBMBo, BoGetHandleWithBoParamTest)
 338 {
 339         tbm_bo_handle bo_handle;
 340         tbm_bo invalid_bo;
 341
 342         bo_handle = tbm_bo_get_handle(NULL, TBM_DEVICE_DEFAULT);
 343         EXPECT_EQ(bo_handle.ptr, nullptr);
 344         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 345
 346         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 347         bo_handle = tbm_bo_get_handle(invalid_bo, TBM_DEVICE_DEFAULT);
 348         EXPECT_EQ(bo_handle.ptr, nullptr);
 349         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 350 }
 351
 352 TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
 353 {
 354         tbm_bo bo;
 355         tbm_bo_handle bo_handle;
 356
 357         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 358         EXPECT_NE(bo, nullptr);
 359         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 360
 361         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_DEFAULT);
 362         EXPECT_NE(bo_handle.ptr, nullptr);
 363         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 364
 365         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
 366         EXPECT_NE(bo_handle.ptr, nullptr);
 367         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 368
 369         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_2D);
 370         EXPECT_NE(bo_handle.ptr, nullptr);
 371         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 372
 373         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_3D);
 374         EXPECT_NE(bo_handle.ptr, nullptr);
 375         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 376
 377 #if 0
 378         bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_MM);
 379         EXPECT_NE(bo_handle.ptr, nullptr);
 380 #endif
 381
 382         tbm_bo_unref(bo);
 383 }
 384
 385 /* tbm_bo_export() */
 386
 387 TEST_F(TBMBo, BoExport)
 388 {
 389         tbm_bo bo;
 390         tbm_key bo_key;
 391
 392         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 393                 return;
 394
 395         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 396         EXPECT_NE(bo, nullptr);
 397         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 398
 399         bo_key = tbm_bo_export(bo);
 400         EXPECT_GT(bo_key, 0);
 401         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 402
 403         tbm_bo_unref(bo);
 404         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 405 }
 406
 407 TEST_F(TBMBo, BoExportWithBoParamTest)
 408 {
 409         tbm_bo invalid_bo;
 410         tbm_key bo_key;
 411
 412         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 413                 return;
 414
 415         bo_key = tbm_bo_export(NULL);
 416         EXPECT_EQ(bo_key, 0);
 417         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 418
 419         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 420         bo_key = tbm_bo_export(invalid_bo);
 421         EXPECT_EQ(bo_key, 0);
 422         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 423 }
 424
 425 /* tbm_bo_export_fd() */
 426
 427 TEST_F(TBMBo, BoExportFd)
 428 {
 429         tbm_bo bo;
 430         tbm_fd bo_fd;
 431
 432         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 433                 return;
 434
 435         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 436         EXPECT_NE(bo, nullptr);
 437         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 438
 439         bo_fd = tbm_bo_export_fd(bo);
 440         EXPECT_GT(bo_fd, -1);
 441         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 442
 443         tbm_bo_unref(bo);
 444         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 445 }
 446
 447 TEST_F(TBMBo, BoExportFdWithBoParamTest)
 448 {
 449         tbm_bo invalid_bo;
 450         tbm_fd bo_fd;
 451
 452         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 453                 return;
 454
 455         bo_fd = tbm_bo_export_fd(NULL);
 456         EXPECT_EQ(bo_fd, -1);
 457         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 458
 459         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 460         bo_fd = tbm_bo_export_fd(invalid_bo);
 461         EXPECT_EQ(bo_fd, -1);
 462         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 463 }
 464
 465 /* tbm_bo_import() */
 466
 467 TEST_F(TBMBo, BoImport)
 468 {
 469         tbm_bo bo1, bo2;
 470         tbm_key bo_key;
 471
 472         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 473                 return;
 474
 475         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 476         EXPECT_NE(bo1, nullptr);
 477         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 478
 479         bo_key = tbm_bo_export(bo1);
 480         EXPECT_GT(bo_key, 0);
 481         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 482
 483         bo2 = tbm_bo_import(bufmgr, bo_key);
 484         EXPECT_NE(bo2, nullptr);
 485         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 486
 487         tbm_bo_unref(bo2);
 488         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 489
 490         tbm_bo_unref(bo1);
 491         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 492 }
 493
 494 TEST_F(TBMBo, BoImportWithBufmgrParamTest)
 495 {
 496         tbm_bufmgr invalid_bufmgr;
 497         tbm_bo bo;
 498         tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
 499
 500         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 501                 return;
 502
 503         bo = tbm_bo_import(NULL, bo_key);
 504         EXPECT_EQ(bo, nullptr);
 505         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 506
 507         invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
 508         bo = tbm_bo_import(invalid_bufmgr, bo_key);
 509         EXPECT_EQ(bo, nullptr);
 510         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 511 }
 512
 513 TEST_F(TBMBo, BoImportWithKeyParamTest)
 514 {
 515         tbm_bo bo;
 516         tbm_key bo_key_invalid;
 517
 518         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 519                 return;
 520
 521         bo_key_invalid = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
 522         bo = tbm_bo_import(bufmgr, bo_key_invalid);
 523         EXPECT_EQ(bo, nullptr);
 524         EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 525 }
 526
 527 TEST_F(TBMBo, BoImportTwice)
 528 {
 529         tbm_bo bo1, bo2, bo3;
 530         tbm_key bo_key;
 531
 532         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
 533                 return;
 534
 535         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 536         EXPECT_NE(bo1, nullptr);
 537         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 538
 539         bo_key = tbm_bo_export(bo1);
 540         EXPECT_GT(bo_key, 0);
 541         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 542
 543         bo2 = tbm_bo_import(bufmgr, bo_key);
 544         EXPECT_NE(bo2, nullptr);
 545         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 546
 547         bo3 = tbm_bo_import(bufmgr, bo_key);
 548         EXPECT_NE(bo3, nullptr);
 549         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 550
 551         tbm_bo_unref(bo3);
 552         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 553
 554         tbm_bo_unref(bo2);
 555         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 556
 557         tbm_bo_unref(bo1);
 558         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 559 }
 560
 561 /* tbm_bo_import_fd() */
 562
 563 TEST_F(TBMBo, BoImportFd)
 564 {
 565         tbm_bo bo1, bo2;
 566         tbm_fd bo_fd;
 567
 568         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 569                 return;
 570
 571         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 572         EXPECT_NE(bo1, nullptr);
 573         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 574
 575         bo_fd = tbm_bo_export_fd(bo1);
 576         EXPECT_GT(bo_fd, 0);
 577         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 578
 579         bo2 = tbm_bo_import_fd(bufmgr, bo_fd);
 580         EXPECT_NE(bo2, nullptr);
 581         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 582
 583         tbm_bo_unref(bo2);
 584         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 585
 586         tbm_bo_unref(bo1);
 587         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 588 }
 589
 590 TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
 591 {
 592         tbm_bufmgr invalid_bufmgr;
 593         tbm_bo bo;
 594         tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
 595
 596         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 597                 return;
 598
 599         bo = tbm_bo_import_fd(NULL, bo_fd);
 600         EXPECT_EQ(bo, nullptr);
 601         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 602
 603         invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
 604         bo = tbm_bo_import_fd(invalid_bufmgr, bo_fd);
 605         EXPECT_EQ(bo, nullptr);
 606         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 607 }
 608
 609 TEST_F(TBMBo, BoImportFdWithFdParamTest)
 610 {
 611         tbm_bo bo;
 612         tbm_fd bo_fd_invalid;
 613
 614         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 615                 return;
 616
 617         bo_fd_invalid = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
 618         bo = tbm_bo_import_fd(bufmgr, bo_fd_invalid);
 619         EXPECT_EQ(bo, nullptr);
 620         EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 621 }
 622
 623 TEST_F(TBMBo, BoImportFdTwice)
 624 {
 625         tbm_bo bo1, bo2, bo3;
 626         tbm_fd bo_fd;
 627
 628         if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
 629                 return;
 630
 631         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 632         EXPECT_NE(bo1, nullptr);
 633         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 634
 635         bo_fd = tbm_bo_export_fd(bo1);
 636         EXPECT_GT(bo_fd, 0);
 637         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 638
 639         bo2 = tbm_bo_import_fd(bufmgr, bo_fd);
 640         EXPECT_NE(bo2, nullptr);
 641         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 642
 643         bo3 = tbm_bo_import_fd(bufmgr, bo_fd);
 644         EXPECT_NE(bo3, nullptr);
 645         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 646
 647         tbm_bo_unref(bo3);
 648         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 649
 650         tbm_bo_unref(bo2);
 651         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 652
 653         tbm_bo_unref(bo1);
 654         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 655 }
 656
 657 /* tbm_bo_size() */
 658
 659 TEST_F(TBMBo, BoSize)
 660 {
 661         tbm_bo bo;
 662         int size = 0;
 663
 664         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 665         EXPECT_NE(bo, nullptr);
 666         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 667
 668         size = tbm_bo_size(bo);
 669         EXPECT_GT(size, 0);
 670         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 671
 672         tbm_bo_unref(bo);
 673         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 674 }
 675
 676 TEST_F(TBMBo, BoSizeWithBoParamTest)
 677 {
 678         tbm_bo invalid_bo;
 679         int size = 0;
 680
 681         size = tbm_bo_size(NULL);
 682         EXPECT_EQ(size, 0);
 683         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 684
 685         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 686         size = tbm_bo_size(invalid_bo);
 687         EXPECT_EQ(size, 0);
 688         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 689 }
 690
 691 /* tbm_bo_locked() */
 692
 693 TEST_F(TBMBo, BoLocked)
 694 {
 695         tbm_bo bo;
 696         tbm_bo_handle bo_handle;
 697         int ret;
 698
 699         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 700         EXPECT_NE(bo, nullptr);
 701         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 702
 703         /* unlocked */
 704         ret = tbm_bo_locked(bo);
 705         EXPECT_EQ(ret, 0);
 706         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 707
 708         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 709         EXPECT_NE(bo_handle.ptr, nullptr);
 710         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 711
 712         /* locked */
 713         ret = tbm_bo_locked(bo);
 714         EXPECT_EQ(ret, 1);
 715         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 716
 717         ret = tbm_bo_unmap(bo);
 718         EXPECT_EQ(ret, 1);
 719         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 720
 721         /* unlocked */
 722         ret = tbm_bo_locked(bo);
 723         EXPECT_EQ(ret, 0);
 724         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 725
 726         tbm_bo_unref(bo);
 727         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 728 }
 729
 730 TEST_F(TBMBo, BoLockedWithBoParamTest)
 731 {
 732         tbm_bo invalid_bo;
 733         int ret;
 734
 735         ret = tbm_bo_locked(NULL);
 736         EXPECT_EQ(ret, 0);
 737         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 738
 739         invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 740         ret = tbm_bo_locked(invalid_bo);
 741         EXPECT_EQ(ret, 0);
 742         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 743 }
 744
 745 #if 0
 746 TEST_F(TBMBo, BoLockedOnce)
 747 {
 748         // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
 749         tbm_bo_handle bo_handle1, bo_handle2;
 750         tbm_bo bo;
 751         int ret_locked;
 752
 753         setenv("BUFMGR_LOCK_TYPE", "once", 1);
 754
 755         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 756         EXPECT_NE(nullptr, bo);
 757
 758         bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
 759         bo_handle2 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
 760         (void) bo_handle1;
 761         (void) bo_handle2;
 762
 763         tbm_bo_unmap(bo);
 764
 765         ret_locked = tbm_bo_locked(bo);
 766
 767         tbm_bo_unmap(bo);
 768
 769         EXPECT_EQ(ret_locked, 0);
 770 }
 771
 772 TEST_F(TBMBo, BoLockedAlways)
 773 {
 774         // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
 775         tbm_bo_handle bo_handle1, bo_handle2;
 776         tbm_bo bo;
 777         int ret_locked;
 778
 779         setenv("BUFMGR_LOCK_TYPE", "always", 1);
 780
 781         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 782         EXPECT_NE(nullptr, bo);
 783
 784         bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
 785         bo_handle2 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
 786         (void) bo_handle1;
 787         (void) bo_handle2;
 788
 789         tbm_bo_unmap(bo);
 790
 791         ret_locked = tbm_bo_locked(bo);
 792
 793         tbm_bo_unmap(bo);
 794
 795         EXPECT_EQ(ret_locked, 1);
 796 }
 797
 798 TEST_F(TBMBo, BoLockedNone)
 799 {
 800         // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
 801         tbm_bo_handle bo_handle1;
 802         tbm_bo bo;
 803         int ret_locked;
 804
 805         setenv("BUFMGR_LOCK_TYPE", "none", 1);
 806
 807         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 808         EXPECT_NE(nullptr, bo);
 809
 810         bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
 811         (void) bo_handle1;
 812
 813         ret_locked = tbm_bo_locked(bo);
 814
 815         tbm_bo_unmap(bo);
 816
 817         EXPECT_EQ(ret_locked, 0);
 818 }
 819 #endif
 820
 821 /* tbm_bo_swap() */
 822
 823 TEST_F(TBMBo, BoSwap)
 824 {
 825         tbm_bo bo1, bo2;
 826         int ret;
 827
 828         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 829         EXPECT_NE(bo1, nullptr);
 830         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 831
 832         bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 833         EXPECT_NE(bo2, nullptr);
 834         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 835
 836         ret = tbm_bo_swap(bo1, bo2);
 837         EXPECT_EQ(ret, 1);
 838         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 839
 840         tbm_bo_unref(bo1);
 841         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 842
 843         tbm_bo_unref(bo2);
 844         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 845 }
 846
 847 TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
 848 {
 849         tbm_bo bo, invalid_bo1, invalid_bo2;
 850         int ret;
 851
 852         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 853         EXPECT_NE(bo, nullptr);
 854         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 855
 856         invalid_bo1 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 857         invalid_bo2 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
 858
 859         ret = tbm_bo_swap(NULL, NULL);
 860         EXPECT_EQ(ret, 0);
 861         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 862         ret = tbm_bo_swap(bo, NULL);
 863         EXPECT_EQ(ret, 0);
 864         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 865         ret = tbm_bo_swap(NULL, bo);
 866         EXPECT_EQ(ret, 0);
 867         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 868
 869         ret = tbm_bo_swap(invalid_bo1, invalid_bo2);
 870         EXPECT_EQ(ret, 0);
 871         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 872         ret = tbm_bo_swap(bo, invalid_bo2);
 873         EXPECT_EQ(ret, 0);
 874         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 875         ret = tbm_bo_swap(invalid_bo1, bo);
 876         EXPECT_EQ(ret, 0);
 877         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 878         ret = tbm_bo_swap(invalid_bo1, NULL);
 879         EXPECT_EQ(ret, 0);
 880         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 881         ret = tbm_bo_swap(NULL, invalid_bo2);
 882         EXPECT_EQ(ret, 0);
 883         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 884
 885         tbm_bo_unref(bo);
 886         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 887 }
 888
 889 TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
 890 {
 891         tbm_bo bo1, bo2;
 892         int ret;
 893
 894         bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 895         EXPECT_NE(nullptr, bo1);
 896         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 897
 898         bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE + 256, TBM_BO_DEFAULT);
 899         EXPECT_NE(nullptr, bo2);
 900         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 901
 902         ret = tbm_bo_swap(bo1, bo2);
 903         EXPECT_EQ(ret, 0);
 904         EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 905
 906         tbm_bo_unref(bo2);
 907         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 908
 909         tbm_bo_unref(bo1);
 910         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 911 }
 912
 913 /* tbm_bo_add_user_data() */
 914
 915 TEST_F(TBMBo, BoAddUserData)
 916 {
 917         tbm_bo bo;
 918         int ret;
 919
 920         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 921         EXPECT_NE(bo, nullptr);
 922         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 923
 924         ret = tbm_bo_add_user_data(bo, 4887, NULL);
 925         EXPECT_EQ(ret, 1);
 926         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 927
 928         tbm_bo_unref(bo);
 929         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 930 }
 931
 932 TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
 933 {
 934         tbm_bo invalid_bo;
 935         int ret;
 936
 937         ret = tbm_bo_add_user_data(NULL, 4887, NULL);
 938         EXPECT_EQ(ret, 0);
 939         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 940
 941         invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
 942         ret = tbm_bo_add_user_data(invalid_bo, 4887, NULL);
 943         EXPECT_EQ(ret, 0);
 944         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 945 }
 946
 947 TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
 948 {
 949         tbm_bo bo;
 950         int ret;
 951
 952         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 953         EXPECT_NE(bo, nullptr);
 954         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 955
 956         ret = tbm_bo_add_user_data(bo, 4887, NULL);
 957         EXPECT_EQ(ret, 1);
 958         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 959
 960         ret = tbm_bo_add_user_data(bo, 4887, NULL);
 961         EXPECT_EQ(ret, 0);
 962         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 963
 964         tbm_bo_unref(bo);
 965         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 966 }
 967
 968 /* tbm_bo_delete_user_data() */
 969
 970 TEST_F(TBMBo, BoDeleteUserData)
 971 {
 972         tbm_bo bo;
 973         int ret;
 974
 975         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
 976         EXPECT_NE(bo, nullptr);
 977
 978         ret = tbm_bo_add_user_data(bo, 4887, NULL);
 979         EXPECT_EQ(ret, 1);
 980         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 981
 982         ret = tbm_bo_delete_user_data(bo, 4887);
 983         EXPECT_EQ(ret, 1);
 984         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 985
 986         tbm_bo_unref(bo);
 987         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 988 }
 989
 990 TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
 991 {
 992         tbm_bo invalid_bo;
 993         int ret;
 994
 995         ret = tbm_bo_delete_user_data(NULL, 4887);
 996         EXPECT_EQ(ret, 0);
 997         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 998
 999         invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1000         ret = tbm_bo_delete_user_data(invalid_bo, 4887);
1001         EXPECT_EQ(ret, 0);
1002         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1003 }
1004
1005 TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
1006 {
1007         tbm_bo bo;
1008         int ret;
1009
1010         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
1011         EXPECT_NE(bo, nullptr);
1012         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1013
1014         /* no use_data in bo */
1015         ret = tbm_bo_delete_user_data(bo, 4887);
1016         EXPECT_EQ(ret, 0);
1017         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1018
1019         /* delete the data with the wrong key */
1020         ret = tbm_bo_add_user_data(bo, 4887, NULL);
1021         EXPECT_EQ(ret, 1);
1022         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1023         ret = tbm_bo_delete_user_data(bo, 4887 + 10);
1024         EXPECT_EQ(ret, 0);
1025         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1026
1027         tbm_bo_unref(bo);
1028         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1029 }
1030
1031 /* tbm_bo_set_user_data() */
1032
1033 static void
1034 _tc_tbm_bo_user_data_free(void *user_data)
1035 {
1036         int *i = (int *)user_data;
1037         *i = 1;
1038 }
1039
1040 TEST_F(TBMBo, BoSetUserData)
1041 {
1042         tbm_bo bo;
1043         unsigned long key = 4887;
1044         int data1 = 0, data2 = 0;
1045         int ret;
1046
1047         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
1048         EXPECT_NE(bo, nullptr);
1049         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1050
1051         ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1052         EXPECT_EQ(ret, 1);
1053         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1054
1055         ret = tbm_bo_set_user_data(bo, key, &data1);
1056         EXPECT_EQ(ret, 1);
1057         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1058
1059         ret = tbm_bo_set_user_data(bo, key, &data2);
1060         EXPECT_EQ(ret, 1);
1061         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1062
1063         ret = tbm_bo_delete_user_data(bo, key);
1064         EXPECT_EQ(ret, 1);
1065         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1066
1067         EXPECT_TRUE(data1 == 1);
1068
1069         tbm_bo_unref(bo);
1070         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1071 }
1072
1073 TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
1074 {
1075         tbm_bo invalid_bo;
1076         unsigned long key = 4887;
1077         int data1 = 0, data2 = 0;
1078         int ret;
1079
1080         ret = tbm_bo_set_user_data(NULL, key, &data1);
1081         EXPECT_EQ(ret, 0);
1082         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1083
1084         invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1085         ret = tbm_bo_set_user_data(invalid_bo, key, &data2);
1086         EXPECT_EQ(ret, 0);
1087         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1088 }
1089
1090 TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
1091 {
1092         tbm_bo bo;
1093         unsigned long key = 4887;
1094         int data = 0;
1095         int ret;
1096
1097         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
1098         EXPECT_NE(bo, nullptr);
1099         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1100
1101         /* no add_user_data */
1102         ret = tbm_bo_set_user_data(bo, 4887, &data);
1103         EXPECT_EQ(ret, 0);
1104         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1105
1106         ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1107         EXPECT_EQ(ret, 1);
1108         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1109
1110         /* with non-existed key */
1111         ret = tbm_bo_set_user_data(bo, key + 10, &data);
1112         EXPECT_EQ(ret, 0);
1113         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1114
1115         ret = tbm_bo_delete_user_data(bo, key);
1116         EXPECT_EQ(ret, 1);
1117         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1118
1119         tbm_bo_unref(bo);
1120         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1121 }
1122
1123 /* tbm_bo_get_user_data() */
1124
1125 TEST_F(TBMBo, BoGetUserData)
1126 {
1127         tbm_bo bo;
1128         unsigned long key = 4887;
1129         int data1 = 0;
1130         int *data2;
1131         int ret;
1132
1133         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
1134         EXPECT_NE(bo, nullptr);
1135         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1136
1137         ret = tbm_bo_add_user_data(bo, key, NULL);
1138         EXPECT_EQ(ret, 1);
1139         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1140
1141         ret = tbm_bo_set_user_data(bo, key, &data1);
1142         EXPECT_EQ(ret, 1);
1143         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1144
1145         /* success */
1146         ret = tbm_bo_get_user_data(bo, key, (void **)&data2);
1147         EXPECT_EQ(ret, 1);
1148         EXPECT_TRUE(data2 == &data1);
1149         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1150
1151         ret = tbm_bo_delete_user_data(bo, key);
1152         EXPECT_EQ(ret, 1);
1153         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1154
1155         tbm_bo_unref(bo);
1156         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1157 }
1158
1159 TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
1160 {
1161         tbm_bo invalid_bo;
1162         unsigned long key = 4887;
1163         int *data1;
1164         int *data2;
1165         int ret;
1166
1167         ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
1168         EXPECT_EQ(ret, 0);
1169         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1170
1171         invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1172         ret = tbm_bo_get_user_data(invalid_bo, key, (void **)&data2);
1173         EXPECT_EQ(ret, 0);
1174         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1175 }
1176
1177 TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
1178 {
1179         tbm_bo bo;
1180         unsigned long key = 4887;
1181         int *data;
1182         int ret;
1183
1184         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
1185         EXPECT_NE(bo, nullptr);
1186         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1187
1188         /* no add_user_data/set_user_data */
1189         ret = tbm_bo_get_user_data(bo, 4887, (void **)&data);
1190         EXPECT_EQ(ret, 0);
1191         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1192
1193         ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1194         EXPECT_EQ(ret, 1);
1195         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1196
1197         /* with non-existed key */
1198         ret = tbm_bo_get_user_data(bo, key + 10, (void **)&data);
1199         EXPECT_EQ(ret, 0);
1200         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1201
1202         ret = tbm_bo_delete_user_data(bo, key);
1203         EXPECT_EQ(ret, 1);
1204         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1205
1206         /* removed data */
1207         ret = tbm_bo_get_user_data(bo, key, (void **)&data);
1208         EXPECT_EQ(ret, 0);
1209         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1210
1211         tbm_bo_unref(bo);
1212         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1213 }
1214
1215 /* tbm_bo_get_flags() */
1216
1217 TEST_F(TBMBo, BoGetFlags)
1218 {
1219         tbm_bo bo;
1220         int flags1 = TBM_BO_DEFAULT, flags2 = -1;
1221
1222         bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
1223         EXPECT_NE(bo, nullptr);
1224         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1225
1226         flags2 = tbm_bo_get_flags(bo);
1227         EXPECT_TRUE(flags1 == flags2);
1228         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1229
1230         tbm_bo_unref(bo);
1231         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1232 }
1233
1234 TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
1235 {
1236         tbm_bo invalid_bo;
1237         int flags = -1;
1238
1239         flags = tbm_bo_get_flags(NULL);
1240         EXPECT_TRUE(flags == 0);
1241         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1242
1243         invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1244         flags = tbm_bo_get_flags(invalid_bo);
1245         EXPECT_TRUE(flags == 0);
1246         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1247 }
1248
1249 INSTANTIATE_TEST_CASE_P(TBMBoParams,
1250                                                 TBMBo,
1251                                                 Combine(Bool(), Bool(), Values("none")));