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(