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();
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;
69 TEST_F(TBMBo, BoAllocUnref)
73 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
80 TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
84 bo = tbm_bo_alloc(NULL, TBM_UT_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));
88 bo = tbm_bo_alloc(invalid_bufmgr, TBM_UT_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));
93 TEST_F(TBMBo, BoAllocWithSizeParamTest)
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));
102 TEST_F(TBMBo, BoAllocWithFlagsParamTest)
106 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
111 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
116 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
121 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
133 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
138 EXPECT_NE(bo, nullptr);
139 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
145 TEST_F(TBMBo, BoRefWithBoParamTest)
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));
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));
160 TEST_F(TBMBo, BoUnrefWithBoParamTest)
163 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
165 tbm_bo_unref(invalid_bo);
166 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
171 TEST_F(TBMBo, BoMapUnmap)
174 tbm_bo_handle bo_handle;
177 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
185 ret = tbm_bo_unmap(bo);
187 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
192 TEST_F(TBMBo, BoMapWithBoParamTest)
194 tbm_bo_handle bo_handle;
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));
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));
205 // TODO:: Use Value-Parameterized??
206 TEST_F(TBMBo, BoMapWithDeviceParamTest)
209 tbm_bo_handle bo_handle;
212 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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);
221 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
228 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
235 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
242 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
245 bo_handle = tbm_bo_map(bo, TBM_DEVICE_MM, TBM_OPTION_READ);
247 EXPECT_NE(bo_handle.ptr, nullptr);
248 ret = tbm_bo_unmap(bo);
255 // TODO:: Use Value-Parameterized??
256 TEST_F(TBMBo, BoMapWithOptParamTest)
259 tbm_bo_handle bo_handle;
262 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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);
271 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
278 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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);
285 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
292 TEST_F(TBMBo, BoUnmapWithBoParamTest)
297 ret = tbm_bo_unmap(NULL);
299 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
301 ret = tbm_bo_unmap(invalid_bo);
303 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
305 bo = tbm_bo_alloc(bufmgr, TBM_UT_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);
310 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
315 /* tbm_bo_get_handle() */
317 TEST_F(TBMBo, BoGetHandle)
320 tbm_bo_handle bo_handle;
322 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
331 TEST_F(TBMBo, BoGetHandleWithBoParamTest)
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));
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));
343 TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
346 tbm_bo_handle bo_handle;
348 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
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));
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));
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));
369 bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_MM);
370 EXPECT_NE(bo_handle.ptr, nullptr);
376 /* tbm_bo_export() */
378 TEST_F(TBMBo, BoExport)
383 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
386 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
395 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
398 TEST_F(TBMBo, BoExportWithBoParamTest)
402 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
414 /* tbm_bo_export_fd() */
416 TEST_F(TBMBo, BoExportFd)
421 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
424 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
433 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
436 TEST_F(TBMBo, BoExportFdWithBoParamTest)
440 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
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));
452 /* tbm_bo_import() */
454 TEST_F(TBMBo, BoImport)
459 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
462 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
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));
475 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
478 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
481 TEST_F(TBMBo, BoImportWithBufmgrParamTest)
484 tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
486 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
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));
498 TEST_F(TBMBo, BoImportWithKeyParamTest)
501 tbm_key bo_key_invalid;
503 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
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));
512 TEST_F(TBMBo, BoImportTwice)
514 tbm_bo bo1, bo2, bo3;
517 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
520 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
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));
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));
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));
537 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
540 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
543 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
546 /* tbm_bo_import_fd() */
548 TEST_F(TBMBo, BoImportFd)
553 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
556 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
560 bo_fd = tbm_bo_export_fd(bo1);
562 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
569 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
572 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
575 TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
578 tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
580 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
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));
592 TEST_F(TBMBo, BoImportFdWithFdParamTest)
595 tbm_fd bo_fd_invalid;
597 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
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));
606 TEST_F(TBMBo, BoImportFdTwice)
608 tbm_bo bo1, bo2, bo3;
611 if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
614 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
618 bo_fd = tbm_bo_export_fd(bo1);
620 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
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));
631 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
634 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
637 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
642 TEST_F(TBMBo, BoSize)
647 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
651 size = tbm_bo_size(bo);
653 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
656 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
659 TEST_F(TBMBo, BoSizeWithBoParamTest)
663 size = tbm_bo_size(NULL);
665 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
667 size = tbm_bo_size(invalid_bo);
669 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
672 /* tbm_bo_locked() */
674 TEST_F(TBMBo, BoLocked)
677 tbm_bo_handle bo_handle;
680 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
685 ret = tbm_bo_locked(bo);
687 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
694 ret = tbm_bo_locked(bo);
696 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
698 ret = tbm_bo_unmap(bo);
700 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
703 ret = tbm_bo_locked(bo);
705 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
708 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
711 TEST_F(TBMBo, BoLockedWithBoParamTest)
715 ret = tbm_bo_locked(NULL);
717 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
719 ret = tbm_bo_locked(invalid_bo);
721 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
725 TEST_F(TBMBo, BoLockedOnce)
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;
732 setenv("BUFMGR_LOCK_TYPE", "once", 1);
734 bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
735 EXPECT_NE(nullptr, bo);
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);
744 ret_locked = tbm_bo_locked(bo);
748 EXPECT_EQ(ret_locked, 0);
751 TEST_F(TBMBo, BoLockedAlways)
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;
758 setenv("BUFMGR_LOCK_TYPE", "always", 1);
760 bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
761 EXPECT_NE(nullptr, bo);
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);
770 ret_locked = tbm_bo_locked(bo);
774 EXPECT_EQ(ret_locked, 1);
777 TEST_F(TBMBo, BoLockedNone)
779 // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
780 tbm_bo_handle bo_handle1;
784 setenv("BUFMGR_LOCK_TYPE", "none", 1);
786 bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
787 EXPECT_NE(nullptr, bo);
789 bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
792 ret_locked = tbm_bo_locked(bo);
796 EXPECT_EQ(ret_locked, 0);
802 TEST_F(TBMBo, BoSwap)
807 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
811 bo2 = tbm_bo_alloc(bufmgr, TBM_UT_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));
815 ret = tbm_bo_swap(bo1, bo2);
817 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
820 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
823 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
826 TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
831 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
835 ret = tbm_bo_swap(NULL, NULL);
837 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
838 ret = tbm_bo_swap(bo, NULL);
840 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
841 ret = tbm_bo_swap(NULL, bo);
843 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
845 ret = tbm_bo_swap(invalid_bo, invalid_bo2);
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);
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);
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);
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);
859 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
862 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
865 TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
870 bo1 = tbm_bo_alloc(bufmgr, TBM_UT_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));
874 bo2 = tbm_bo_alloc(bufmgr, TBM_UT_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));
878 ret = tbm_bo_swap(bo1, bo2);
880 EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
883 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
886 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
889 /* tbm_bo_add_user_data() */
891 TEST_F(TBMBo, BoAddUserData)
896 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
900 ret = tbm_bo_add_user_data(bo, 4887, NULL);
902 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
905 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
908 TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
912 ret = tbm_bo_add_user_data(NULL, 4887, NULL);
914 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
916 ret = tbm_bo_add_user_data(invalid_bo, 4887, NULL);
918 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
921 TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
926 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
930 ret = tbm_bo_add_user_data(bo, 4887, NULL);
932 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
934 ret = tbm_bo_add_user_data(bo, 4887, NULL);
936 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
939 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
942 /* tbm_bo_delete_user_data() */
944 TEST_F(TBMBo, BoDeleteUserData)
949 bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
950 EXPECT_NE(bo, nullptr);
952 ret = tbm_bo_add_user_data(bo, 4887, NULL);
954 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
956 ret = tbm_bo_delete_user_data(bo, 4887);
958 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
961 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
964 TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
968 ret = tbm_bo_delete_user_data(NULL, 4887);
970 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
972 ret = tbm_bo_delete_user_data(invalid_bo, 4887);
974 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
977 TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
982 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
986 /* no use_data in bo */
987 ret = tbm_bo_delete_user_data(bo, 4887);
989 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
991 /* delete the data with the wrong key */
992 ret = tbm_bo_add_user_data(bo, 4887, NULL);
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);
997 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1000 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1003 /* tbm_bo_set_user_data() */
1006 _tc_tbm_bo_user_data_free(void *user_data)
1008 int *i = (int *)user_data;
1012 TEST_F(TBMBo, BoSetUserData)
1015 unsigned long key = 4887;
1016 int data1 = 0, data2 = 0;
1019 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
1023 ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1025 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1027 ret = tbm_bo_set_user_data(bo, key, &data1);
1029 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1031 ret = tbm_bo_set_user_data(bo, key, &data2);
1033 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1035 ret = tbm_bo_delete_user_data(bo, key);
1037 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1039 EXPECT_TRUE(data1 == 1);
1042 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1045 TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
1047 unsigned long key = 4887;
1048 int data1 = 0, data2 = 0;
1051 ret = tbm_bo_set_user_data(NULL, key, &data1);
1053 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1055 ret = tbm_bo_set_user_data(invalid_bo, key, &data2);
1057 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1060 TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
1063 unsigned long key = 4887;
1067 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
1071 /* no add_user_data */
1072 ret = tbm_bo_set_user_data(bo, 4887, &data);
1074 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1076 ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1078 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1080 /* with non-existed key */
1081 ret = tbm_bo_set_user_data(bo, key + 10, &data);
1083 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1085 ret = tbm_bo_delete_user_data(bo, key);
1087 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1090 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1093 /* tbm_bo_get_user_data() */
1095 TEST_F(TBMBo, BoGetUserData)
1098 unsigned long key = 4887;
1103 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
1107 ret = tbm_bo_add_user_data(bo, key, NULL);
1109 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1111 ret = tbm_bo_set_user_data(bo, key, &data1);
1113 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1116 ret = tbm_bo_get_user_data(bo, key, (void **)&data2);
1118 EXPECT_TRUE(data2 == &data1);
1119 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1121 ret = tbm_bo_delete_user_data(bo, key);
1123 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1126 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1129 TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
1131 unsigned long key = 4887;
1136 ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
1138 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1140 ret = tbm_bo_get_user_data(invalid_bo, key, (void **)&data2);
1142 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1145 TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
1148 unsigned long key = 4887;
1152 bo = tbm_bo_alloc(bufmgr, TBM_UT_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));
1156 /* no add_user_data/set_user_data */
1157 ret = tbm_bo_get_user_data(bo, 4887, (void **)&data);
1159 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1161 ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
1163 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1165 /* with non-existed key */
1166 ret = tbm_bo_get_user_data(bo, key + 10, (void **)&data);
1168 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1170 ret = tbm_bo_delete_user_data(bo, key);
1172 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1175 ret = tbm_bo_get_user_data(bo, key, (void **)&data);
1177 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
1180 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1183 /* tbm_bo_get_flags() */
1185 TEST_F(TBMBo, BoGetFlags)
1188 int flags1 = TBM_BO_DEFAULT, flags2 = -1;
1190 bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, flags1);
1191 EXPECT_NE(bo, nullptr);
1192 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
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));
1199 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
1202 TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
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));
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));
1215 INSTANTIATE_TEST_CASE_P(TBMBoParams,
1217 Combine(Bool(), Bool(), Values("none")));