{
tbm_bo bo;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
{
tbm_bo bo;
- bo = tbm_bo_alloc(NULL, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(NULL, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_EQ(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(invalid_bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_EQ(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
}
{
tbm_bo bo;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_unref(bo);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_SCANOUT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_SCANOUT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_unref(bo);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_NONCACHABLE);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_NONCACHABLE);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_unref(bo);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_WC);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_WC);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_unref(bo);
{
tbm_bo bo;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_handle bo_handle;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_handle bo_handle;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_handle bo_handle;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
EXPECT_EQ(ret, 0);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
ret = tbm_bo_unmap(invalid_bo);
tbm_bo bo;
tbm_bo_handle bo_handle;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
tbm_bo bo;
tbm_bo_handle bo_handle;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
return;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
return;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
return;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo1, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
return;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo1, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
return;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo1, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
return;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo1, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int size = 0;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo_handle bo_handle;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
setenv("BUFMGR_LOCK_TYPE", "once", 1);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, bo);
bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
setenv("BUFMGR_LOCK_TYPE", "always", 1);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, bo);
bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
setenv("BUFMGR_LOCK_TYPE", "none", 1);
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, bo);
bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
tbm_bo bo1, bo2;
int ret;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo1, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo2 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo2, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo1, bo2;
int ret;
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, bo1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE + 256, TBM_BO_DEFAULT);
+ bo2 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE + 256, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, bo2);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
ret = tbm_bo_add_user_data(bo, 4887, NULL);
tbm_bo bo;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
int data1 = 0, data2 = 0;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
int data = 0;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
int *data2;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
int *data;
int ret;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
tbm_bo bo;
int flags1 = TBM_BO_DEFAULT, flags2 = -1;
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
+ bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, flags1);
EXPECT_NE(bo, nullptr);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
alien_surface = tbm_surface_create(width, height, format);
EXPECT_NE((tbm_surface_h)NULL, alien_surface);
- queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ queue = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
EXPECT_NE((tbm_surface_queue_h)NULL, queue);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
}
{
tbm_surface_queue_h queue1 = NULL;
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
EXPECT_NE(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
}
-/* tbm_surface_queue_h tbm_surface_queue_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
+/* tbm_surface_queue_h tbm_surface_queue_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
int height, int format, int flags); */
TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
{
EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
}
-/* tbm_surface_queue_h tbm_surface_queue_sequence_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
+/* tbm_surface_queue_h tbm_surface_queue_sequence_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
int height, int format, int flags); */
TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
{
EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
EXPECT_EQ(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
}
{
tbm_surface_queue_h queue1 = NULL;
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
+ queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
EXPECT_NE(nullptr, queue1);
EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
TEST_F(TBMSurfaceQueue, DequeueSuccess)
{
/* do dequeue three times */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
EXPECT_NE((tbm_surface_h)NULL, surface);
tbm_surface_h *surfaces, int *num); */
TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
int num;
result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
int num;
result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
int num = 0;
/* test: empty queue*/
EXPECT_EQ(0, num);
/* do dequeue three times */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
EXPECT_NE(nullptr, surface);
/* test */
result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, num);
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
EXPECT_NE(nullptr, surfaces[i]);
/* test: get only number of surfaces */
result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+ EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, num);
}
/* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
{
tbm_surface_h last_surface = NULL;
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
EXPECT_NE(nullptr, surface);
TEST_F(TBMSurfaceQueue, EnqueueSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
/* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_enqueue(queue, surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
TEST_F(TBMSurfaceQueue, AcquireSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
tbm_surface_h acquired_surface = NULL;
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_enqueue(queue, surfaces[i]);
}
/* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_acquire(queue, &acquired_surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
EXPECT_EQ(surfaces[i], acquired_surface);
{
tbm_surface_h last_surface = NULL;
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_enqueue(queue, surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_acquire(queue, &surface);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
TEST_F(TBMSurfaceQueue, ReleaseSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_enqueue(queue, surfaces[i]);
}
/* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_release(queue, surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
/* create a sequence queue instead of a default one*/
tbm_surface_queue_destroy(queue);
- queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ queue = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(tbm_get_last_error()));
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_enqueue(queue, surfaces[i]);
}
/* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_release(queue, surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
TEST_F(TBMSurfaceQueue, GetSizeSuccess)
{
int q_size = tbm_surface_queue_get_size(queue);
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, q_size);
+ EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, q_size);
EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
}
/* create a sequence queue instead of a default one*/
tbm_surface_queue_destroy(queue);
- queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ queue = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
ASSERT_TRUE(queue != NULL);
result = tbm_surface_queue_dequeue(queue, &surface);
}
/* tbm_surface_queue_error_e tbm_surface_queue_set_size(
- tbm_surface_queue_h surface_queue, int UT_TBM_SURFACE_QUEUE_SIZE, int flush); */
+ tbm_surface_queue_h surface_queue, int TBM_UT_SURFACE_QUEUE_SIZE, int flush); */
TEST_F(TBMSurfaceQueue, SetSizeFailNull)
{
- result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ result = tbm_surface_queue_set_size(NULL, TBM_UT_SURFACE_QUEUE_SIZE, 0);
EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
}
TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
{
- result = tbm_surface_queue_set_size(invalid_queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ result = tbm_surface_queue_set_size(invalid_queue, TBM_UT_SURFACE_QUEUE_SIZE, 0);
EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_set_size(NULL, 0, 0);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
/*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE, 0);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
/*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 1);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE, 1);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
}
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
/*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+1, 0);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE+1, 0);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
/*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+2, 1);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE+2, 1);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
}
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
/*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-1, 0);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE-1, 0);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
/*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-2, 1);
+ result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE-2, 1);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
}
TEST_F(TBMSurfaceQueue, FlushSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
/*test: flushing not initialized queue*/
result = tbm_surface_queue_flush(queue);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_enqueue(queue, surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
/* extra check */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
}
TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
/*test: flushing not initialized queue*/
result = tbm_surface_queue_free_flush(queue);
/* init queue */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
/* extra check */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
}
EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
dq_count++;
}
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
+ EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, dq_count);
}
TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
acq_count++;
}
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
+ EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, acq_count);
}
/* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(