2 /**************************************************************************
4 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
6 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
7 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
8 * Contact: Roman Marchenko <r.marchenko@samsung.com>
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:
18 * The above copyright notice and this permission notice (including the
19 * next paragraph) shall be included in all copies or substantial portions
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.
30 **************************************************************************/
34 class TBMBo : public TBMBufmgr
41 unsigned int bufmgr_capability;
46 bufmgr_capability = TBM_BUFMGR_CAPABILITY_NONE;
53 bufmgr_capability = tbm_bufmgr_get_capability(bufmgr);
54 EXPECT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
57 void TBMBo::TearDown()
59 TBMBufmgr::TearDown();
64 TEST_F(TBMBo, BoAllocUnref)
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));
75 TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
78 tbm_bufmgr invalid_bufmgr;
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));
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));
91 TEST_F(TBMBo, BoAllocWithSizeParamTest)
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));
100 TEST_F(TBMBo, BoAllocWithFlagsParamTest)
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));
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));
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));
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));
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));
136 EXPECT_NE(bo, nullptr);
137 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
143 TEST_F(TBMBo, BoRefWithBoParamTest)
145 tbm_bo bo, invalid_bo;
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));
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));
159 TEST_F(TBMBo, BoUnrefWithBoParamTest)
164 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
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));
173 TEST_F(TBMBo, BoMapUnmap)
176 tbm_bo_handle bo_handle;
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));
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));
187 ret = tbm_bo_unmap(bo);
189 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
194 TEST_F(TBMBo, BoMapWithBoParamTest)
197 tbm_bo_handle bo_handle;
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));
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));
209 // TODO:: Use Value-Parameterized??
210 TEST_F(TBMBo, BoMapWithDeviceParamTest)
213 tbm_bo_handle bo_handle;
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));
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);
225 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
232 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
239 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
246 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
249 bo_handle = tbm_bo_map(bo, TBM_DEVICE_MM, TBM_OPTION_READ);
251 EXPECT_NE(bo_handle.ptr, nullptr);
252 ret = tbm_bo_unmap(bo);
259 // TODO:: Use Value-Parameterized??
260 TEST_F(TBMBo, BoMapWithOptParamTest)
263 tbm_bo_handle bo_handle;
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));
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);
275 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
282 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
289 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
296 TEST_F(TBMBo, BoUnmapWithBoParamTest)
302 ret = tbm_bo_unmap(NULL);
304 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
306 invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
307 ret = tbm_bo_unmap(invalid_bo);
309 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
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);
316 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
321 /* tbm_bo_get_handle() */
323 TEST_F(TBMBo, BoGetHandle)
326 tbm_bo_handle bo_handle;
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));
337 TEST_F(TBMBo, BoGetHandleWithBoParamTest)
339 tbm_bo_handle bo_handle;
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));
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));
352 TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
355 tbm_bo_handle bo_handle;
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));
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));
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));
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));
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));
378 bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_MM);
379 EXPECT_NE(bo_handle.ptr, nullptr);
385 /* tbm_bo_export() */
387 TEST_F(TBMBo, BoExport)
392 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
404 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
407 TEST_F(TBMBo, BoExportWithBoParamTest)
412 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
425 /* tbm_bo_export_fd() */
427 TEST_F(TBMBo, BoExportFd)
432 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
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));
444 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
447 TEST_F(TBMBo, BoExportFdWithBoParamTest)
452 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
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));
465 /* tbm_bo_import() */
467 TEST_F(TBMBo, BoImport)
472 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
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));
488 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
491 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
494 TEST_F(TBMBo, BoImportWithBufmgrParamTest)
496 tbm_bufmgr invalid_bufmgr;
498 tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
500 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
513 TEST_F(TBMBo, BoImportWithKeyParamTest)
516 tbm_key bo_key_invalid;
518 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
527 TEST_F(TBMBo, BoImportTwice)
529 tbm_bo bo1, bo2, bo3;
532 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
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));
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));
552 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
555 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
558 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
561 /* tbm_bo_import_fd() */
563 TEST_F(TBMBo, BoImportFd)
568 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
575 bo_fd = tbm_bo_export_fd(bo1);
577 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
584 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
587 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
590 TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
592 tbm_bufmgr invalid_bufmgr;
594 tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
596 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
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));
609 TEST_F(TBMBo, BoImportFdWithFdParamTest)
612 tbm_fd bo_fd_invalid;
614 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
623 TEST_F(TBMBo, BoImportFdTwice)
625 tbm_bo bo1, bo2, bo3;
628 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
635 bo_fd = tbm_bo_export_fd(bo1);
637 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
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));
648 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
651 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
654 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
659 TEST_F(TBMBo, BoSize)
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));
668 size = tbm_bo_size(bo);
670 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
673 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
676 TEST_F(TBMBo, BoSizeWithBoParamTest)
681 size = tbm_bo_size(NULL);
683 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
685 invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
686 size = tbm_bo_size(invalid_bo);
688 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
691 /* tbm_bo_locked() */
693 TEST_F(TBMBo, BoLocked)
696 tbm_bo_handle bo_handle;
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));
704 ret = tbm_bo_locked(bo);
706 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
713 ret = tbm_bo_locked(bo);
715 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
717 ret = tbm_bo_unmap(bo);
719 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
722 ret = tbm_bo_locked(bo);
724 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
727 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
730 TEST_F(TBMBo, BoLockedWithBoParamTest)
735 ret = tbm_bo_locked(NULL);
737 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
739 invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
740 ret = tbm_bo_locked(invalid_bo);
742 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
746 TEST_F(TBMBo, BoLockedOnce)
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;
753 setenv("BUFMGR_LOCK_TYPE", "once", 1);
755 bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
756 EXPECT_NE(nullptr, bo);
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);
765 ret_locked = tbm_bo_locked(bo);
769 EXPECT_EQ(ret_locked, 0);
772 TEST_F(TBMBo, BoLockedAlways)
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;
779 setenv("BUFMGR_LOCK_TYPE", "always", 1);
781 bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
782 EXPECT_NE(nullptr, bo);
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);
791 ret_locked = tbm_bo_locked(bo);
795 EXPECT_EQ(ret_locked, 1);
798 TEST_F(TBMBo, BoLockedNone)
800 // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
801 tbm_bo_handle bo_handle1;
805 setenv("BUFMGR_LOCK_TYPE", "none", 1);
807 bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
808 EXPECT_NE(nullptr, bo);
810 bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
813 ret_locked = tbm_bo_locked(bo);
817 EXPECT_EQ(ret_locked, 0);
823 TEST_F(TBMBo, BoSwap)
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));
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));
836 ret = tbm_bo_swap(bo1, bo2);
838 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
841 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
844 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
847 TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
849 tbm_bo bo, invalid_bo1, invalid_bo2;
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));
856 invalid_bo1 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
857 invalid_bo2 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
859 ret = tbm_bo_swap(NULL, NULL);
861 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
862 ret = tbm_bo_swap(bo, NULL);
864 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
865 ret = tbm_bo_swap(NULL, bo);
867 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
869 ret = tbm_bo_swap(invalid_bo1, invalid_bo2);
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);
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);
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);
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);
883 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
886 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
889 TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
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));
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));
902 ret = tbm_bo_swap(bo1, bo2);
904 EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
907 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
910 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
913 /* tbm_bo_add_user_data() */
915 TEST_F(TBMBo, BoAddUserData)
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));
924 ret = tbm_bo_add_user_data(bo, 4887, NULL);
926 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
929 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
932 TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
937 ret = tbm_bo_add_user_data(NULL, 4887, NULL);
939 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
941 invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
942 ret = tbm_bo_add_user_data(invalid_bo, 4887, NULL);
944 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
947 TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
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));
956 ret = tbm_bo_add_user_data(bo, 4887, NULL);
958 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
960 ret = tbm_bo_add_user_data(bo, 4887, NULL);
962 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
965 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
968 /* tbm_bo_delete_user_data() */
970 TEST_F(TBMBo, BoDeleteUserData)
975 bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
976 EXPECT_NE(bo, nullptr);
978 ret = tbm_bo_add_user_data(bo, 4887, NULL);
980 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
982 ret = tbm_bo_delete_user_data(bo, 4887);
984 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
987 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
990 TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
995 ret = tbm_bo_delete_user_data(NULL, 4887);
997 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
999 invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1000 ret = tbm_bo_delete_user_data(invalid_bo, 4887);
1002 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1005 TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
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));
1014 /* no use_data in bo */
1015 ret = tbm_bo_delete_user_data(bo, 4887);
1017 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1019 /* delete the data with the wrong key */
1020 ret = tbm_bo_add_user_data(bo, 4887, NULL);
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);
1025 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1028 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1031 /* tbm_bo_set_user_data() */
1034 _ut_tbm_bo_user_data_free(void *user_data)
1036 int *i = (int *)user_data;
1040 TEST_F(TBMBo, BoSetUserData)
1043 unsigned long key = 4887;
1044 int data1 = 0, data2 = 0;
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));
1051 ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
1053 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1055 ret = tbm_bo_set_user_data(bo, key, &data1);
1057 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1059 ret = tbm_bo_set_user_data(bo, key, &data2);
1061 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1063 ret = tbm_bo_delete_user_data(bo, key);
1065 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1067 EXPECT_TRUE(data1 == 1);
1070 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1073 TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
1076 unsigned long key = 4887;
1077 int data1 = 0, data2 = 0;
1080 ret = tbm_bo_set_user_data(NULL, key, &data1);
1082 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1084 invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1085 ret = tbm_bo_set_user_data(invalid_bo, key, &data2);
1087 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1090 TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
1093 unsigned long key = 4887;
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));
1101 /* no add_user_data */
1102 ret = tbm_bo_set_user_data(bo, 4887, &data);
1104 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1106 ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
1108 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1110 /* with non-existed key */
1111 ret = tbm_bo_set_user_data(bo, key + 10, &data);
1113 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1115 ret = tbm_bo_delete_user_data(bo, key);
1117 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1120 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1123 /* tbm_bo_get_user_data() */
1125 TEST_F(TBMBo, BoGetUserData)
1128 unsigned long key = 4887;
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));
1137 ret = tbm_bo_add_user_data(bo, key, NULL);
1139 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1141 ret = tbm_bo_set_user_data(bo, key, &data1);
1143 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1146 ret = tbm_bo_get_user_data(bo, key, (void **)&data2);
1148 EXPECT_TRUE(data2 == &data1);
1149 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1151 ret = tbm_bo_delete_user_data(bo, key);
1153 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1156 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1159 TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
1162 unsigned long key = 4887;
1167 ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
1169 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1171 invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
1172 ret = tbm_bo_get_user_data(invalid_bo, key, (void **)&data2);
1174 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1177 TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
1180 unsigned long key = 4887;
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));
1188 /* no add_user_data/set_user_data */
1189 ret = tbm_bo_get_user_data(bo, 4887, (void **)&data);
1191 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1193 ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
1195 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1197 /* with non-existed key */
1198 ret = tbm_bo_get_user_data(bo, key + 10, (void **)&data);
1200 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1202 ret = tbm_bo_delete_user_data(bo, key);
1204 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1207 ret = tbm_bo_get_user_data(bo, key, (void **)&data);
1209 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1212 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1215 /* tbm_bo_get_flags() */
1217 TEST_F(TBMBo, BoGetFlags)
1220 int flags1 = TBM_BO_DEFAULT, flags2 = -1;
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));
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));
1231 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1234 TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
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));
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));
1249 INSTANTIATE_TEST_CASE_P(TBMBoParams,
1251 Combine(Bool(), Bool(), Values("none")));