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