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 **************************************************************************/
33 class TBMSurfaceQueue : public TBMBufmgr
46 tbm_surface_h alien_surface;
47 tbm_surface_queue_h queue;
49 tbm_surface_queue_error_e result;
50 tbm_surface_h surface;
53 void TBMSurfaceQueue::SetUp()
55 tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
59 result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
60 EXPECT_STREQ(tbm_error_str(TBM_ERROR_NONE), tbm_error_str(result));
62 for (uint32_t i = 0; i < num_formats; i++)
63 if (formats[i] == TBM_FORMAT_ARGB8888)
64 format = TBM_FORMAT_ARGB8888;
66 /* fail if there is no TBM_FORMAT_ARGB8888 format */
67 ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
71 alien_surface = tbm_surface_create(width, height, format);
72 EXPECT_NE((tbm_surface_h)NULL, alien_surface);
74 queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
75 EXPECT_NE((tbm_surface_queue_h)NULL, queue);
76 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
79 void TBMSurfaceQueue::TearDown()
82 tbm_surface_destroy(alien_surface);
85 tbm_surface_queue_destroy(queue);
90 TBMBufmgr::TearDown();
93 static int memory_for_invalid_param;
94 static tbm_surface_queue_h invalid_queue = (tbm_surface_queue_h)&memory_for_invalid_param;
95 static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
98 static void tbm_surface_queue_event_handler(tbm_surface_queue_h surface_queue, void *data)
100 if (data == &cb_data)
104 static tbm_surface_queue_trace trace_cb_data;
105 static void tbm_surface_queue_trace_event_handler(tbm_surface_queue_h surface_queue,
106 tbm_surface_h surface, tbm_surface_queue_trace trace, void *data)
108 if (data == &trace_cb_data)
109 trace_cb_data = trace;
112 static tbm_surface_h tbm_surface_alloc_cb_handler(tbm_surface_queue_h surface_queue, void *data)
114 return (tbm_surface_h)data;
117 void tbm_surface_free_cb_handler(tbm_surface_queue_h surface_queue, void *data, tbm_surface_h surface)
120 tbm_surface_destroy(surface);
123 TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
125 tbm_surface_queue_h queue1 = NULL;
127 queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
128 EXPECT_NE(nullptr, queue1);
129 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
131 tbm_surface_queue_destroy(queue1);
132 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
135 /* tbm_surface_queue_h tbm_surface_queue_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
136 int height, int format, int flags); */
137 TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
139 tbm_surface_queue_h queue1 = NULL;
141 queue1 = tbm_surface_queue_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
142 EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
143 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
145 queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
146 EXPECT_EQ(nullptr, queue1);
147 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
149 queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
150 EXPECT_EQ(nullptr, queue1);
151 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
153 queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
154 EXPECT_EQ(nullptr, queue1);
155 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
158 /* tbm_surface_queue_h tbm_surface_queue_sequence_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
159 int height, int format, int flags); */
160 TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
162 tbm_surface_queue_h queue1 = NULL;
164 queue1 = tbm_surface_queue_sequence_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
165 EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
166 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
168 queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
169 EXPECT_EQ(nullptr, queue1);
170 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
172 queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
173 EXPECT_EQ(nullptr, queue1);
174 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
176 queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
177 EXPECT_EQ(nullptr, queue1);
178 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
181 TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
183 tbm_surface_queue_h queue1 = NULL;
185 queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
186 EXPECT_NE(nullptr, queue1);
187 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
189 tbm_surface_queue_destroy(queue1);
190 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
194 /* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */
195 TEST_F(TBMSurfaceQueue, DestroyNULL)
197 tbm_surface_queue_destroy(NULL);
198 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
201 TEST_F(TBMSurfaceQueue, DestroyTwice)
203 tbm_surface_queue_destroy(queue);
204 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
206 tbm_surface_queue_destroy(queue);
207 EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
209 /* to prevent destroy in TearDown */
213 /* tbm_surface_queue_error_e tbm_surface_queue_dequeue(
214 tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
215 TEST_F(TBMSurfaceQueue, DequeueFailNull)
218 result = tbm_surface_queue_dequeue(NULL, &surface);
219 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
221 result = tbm_surface_queue_dequeue(queue, NULL);
222 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
225 }, ::testing::ExitedWithCode(0), "");
228 TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
230 result = tbm_surface_queue_dequeue(invalid_queue, &surface);
231 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
234 TEST_F(TBMSurfaceQueue, DequeueSuccess)
236 /* do dequeue three times */
237 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
238 result = tbm_surface_queue_dequeue(queue, &surface);
239 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
240 EXPECT_NE((tbm_surface_h)NULL, surface);
243 result = tbm_surface_queue_dequeue(queue, &surface);
244 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
245 EXPECT_EQ(nullptr, surface);
248 /* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue,
249 tbm_surface_h *surfaces, int *num); */
250 TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
252 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
255 result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
256 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
258 result = tbm_surface_queue_get_surfaces(queue, surfaces, NULL);
259 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
262 TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
264 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
267 result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
268 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
271 TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
273 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
276 /* test: empty queue*/
277 result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
278 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
281 /* do dequeue three times */
282 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
283 result = tbm_surface_queue_dequeue(queue, &surface);
284 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
285 EXPECT_NE(nullptr, surface);
289 result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
290 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
291 EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
292 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
293 EXPECT_NE(nullptr, surfaces[i]);
295 /* test: get only number of surfaces */
296 result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
297 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
298 EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
301 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
302 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
303 TEST_F(TBMSurfaceQueue, CancelDequeueFailNull)
305 result = tbm_surface_queue_dequeue(queue, &surface);
306 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
308 result = tbm_surface_queue_cancel_dequeue(NULL, surface);
309 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
311 result = tbm_surface_queue_cancel_dequeue(queue, NULL);
312 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
315 TEST_F(TBMSurfaceQueue, CancelDequeueFailInvaildInput)
317 result = tbm_surface_queue_dequeue(queue, &surface);
318 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
321 result = tbm_surface_queue_cancel_dequeue(invalid_queue, surface);
322 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
324 result = tbm_surface_queue_cancel_dequeue(queue, invalid_surface);
325 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
327 result = tbm_surface_queue_cancel_dequeue(queue, alien_surface);
328 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
331 TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
333 tbm_surface_h last_surface = NULL;
335 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
336 result = tbm_surface_queue_dequeue(queue, &surface);
337 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
338 EXPECT_NE(nullptr, surface);
341 last_surface = surface;
342 result = tbm_surface_queue_dequeue(queue, &surface);
343 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
344 EXPECT_EQ(nullptr, surface);
347 result = tbm_surface_queue_cancel_dequeue(queue, last_surface);
348 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
351 result = tbm_surface_queue_dequeue(queue, &surface);
352 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
353 EXPECT_EQ(last_surface, surface);
356 /* tbm_surface_queue_error_e tbm_surface_queue_enqueue(
357 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
358 TEST_F(TBMSurfaceQueue, EnqueueFailNull)
360 result = tbm_surface_queue_dequeue(queue, &surface);
361 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
364 result = tbm_surface_queue_enqueue(NULL, surface);
365 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
367 result = tbm_surface_queue_enqueue(this->queue, NULL);
368 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
371 TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
373 result = tbm_surface_queue_dequeue(queue, &surface);
374 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
377 result = tbm_surface_queue_enqueue(invalid_queue, surface);
378 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
380 result = tbm_surface_queue_enqueue(queue, invalid_surface);
381 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
383 result = tbm_surface_queue_enqueue(queue, alien_surface);
384 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
387 TEST_F(TBMSurfaceQueue, EnqueueSuccess)
389 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
392 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
393 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
394 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
398 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
399 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
400 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
404 TEST_F(TBMSurfaceQueue, EnqueueFailTwice)
406 result = tbm_surface_queue_dequeue(queue, &surface);
407 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
410 result = tbm_surface_queue_enqueue(queue, surface);
411 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
413 result = tbm_surface_queue_enqueue(queue, surface);
414 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
417 /* tbm_surface_queue_error_e tbm_surface_queue_acquire(
418 tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
419 TEST_F(TBMSurfaceQueue, AcquireFailNull)
422 result = tbm_surface_queue_acquire(NULL, &surface);
423 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
425 result = tbm_surface_queue_acquire(queue, &surface);
426 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
429 TEST_F(TBMSurfaceQueue, AcquireFailInvaildInput)
431 result = tbm_surface_queue_acquire(invalid_queue, &surface);
432 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
435 TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
437 result = tbm_surface_queue_acquire(invalid_queue, &surface);
438 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
441 TEST_F(TBMSurfaceQueue, AcquireSuccess)
443 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
444 tbm_surface_h acquired_surface = NULL;
447 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
448 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
449 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
450 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
451 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
455 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
456 result = tbm_surface_queue_acquire(queue, &acquired_surface);
457 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
458 EXPECT_EQ(surfaces[i], acquired_surface);
461 /* test: acquire empty queue*/
462 result = tbm_surface_queue_acquire(queue, &acquired_surface);
463 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
464 EXPECT_EQ(nullptr, acquired_surface);
467 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
468 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
469 TEST_F(TBMSurfaceQueue, CancelAcquireFailNull)
471 result = tbm_surface_queue_dequeue(queue, &surface);
472 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
473 result = tbm_surface_queue_enqueue(queue, surface);
476 result = tbm_surface_queue_cancel_acquire(NULL, surface);
477 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
479 result = tbm_surface_queue_cancel_acquire(queue, NULL);
480 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
483 TEST_F(TBMSurfaceQueue, CancelAcquireFailInvaildInput)
485 result = tbm_surface_queue_dequeue(queue, &surface);
486 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
487 result = tbm_surface_queue_enqueue(queue, surface);
488 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
491 result = tbm_surface_queue_cancel_acquire(invalid_queue, surface);
492 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
494 result = tbm_surface_queue_cancel_acquire(queue, invalid_surface);
495 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
497 result = tbm_surface_queue_cancel_acquire(queue, alien_surface);
498 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
501 TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
503 tbm_surface_h last_surface = NULL;
505 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
506 result = tbm_surface_queue_dequeue(queue, &surface);
507 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
508 result = tbm_surface_queue_enqueue(queue, surface);
509 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
512 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
513 result = tbm_surface_queue_acquire(queue, &surface);
514 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
517 last_surface = surface;
518 result = tbm_surface_queue_acquire(queue, &surface);
519 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
520 EXPECT_EQ(nullptr, surface);
523 result = tbm_surface_queue_cancel_acquire(queue, last_surface);
524 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
527 result = tbm_surface_queue_acquire(queue, &surface);
528 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
529 EXPECT_EQ(last_surface, surface);
532 /* tbm_surface_queue_error_e tbm_surface_queue_release(
533 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
534 TEST_F(TBMSurfaceQueue, ReleaseFailNull)
536 result = tbm_surface_queue_dequeue(queue, &surface);
537 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
538 result = tbm_surface_queue_enqueue(queue, surface);
539 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
540 result = tbm_surface_queue_acquire(queue, &surface);
541 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
544 result = tbm_surface_queue_release(NULL, surface);
545 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
547 result = tbm_surface_queue_release(this->queue, NULL);
548 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
551 TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
553 result = tbm_surface_queue_dequeue(queue, &surface);
554 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
555 result = tbm_surface_queue_enqueue(queue, surface);
556 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
557 result = tbm_surface_queue_acquire(queue, &surface);
558 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
561 result = tbm_surface_queue_release(invalid_queue, surface);
562 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
564 result = tbm_surface_queue_release(queue, invalid_surface);
565 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
567 result = tbm_surface_queue_release(queue, alien_surface);
568 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
571 TEST_F(TBMSurfaceQueue, ReleaseSuccess)
573 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
575 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
576 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
577 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
578 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
579 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
580 result = tbm_surface_queue_acquire(queue, &surfaces[i]);
581 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
585 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
586 result = tbm_surface_queue_release(queue, surfaces[i]);
587 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
591 TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
593 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
595 /* create a sequence queue instead of a default one*/
596 tbm_surface_queue_destroy(queue);
597 queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
598 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(tbm_get_last_error()));
600 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
601 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
602 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
603 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
604 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
605 result = tbm_surface_queue_acquire(queue, &surfaces[i]);
606 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
610 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
611 result = tbm_surface_queue_release(queue, surfaces[i]);
612 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
616 TEST_F(TBMSurfaceQueue, ReleaseFailTwice)
618 result = tbm_surface_queue_dequeue(queue, &surface);
619 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
620 result = tbm_surface_queue_enqueue(queue, surface);
621 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
622 result = tbm_surface_queue_acquire(queue, &surface);
623 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
626 result = tbm_surface_queue_release(queue, surface);
627 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
629 result = tbm_surface_queue_release(queue, surface);
630 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
633 /* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
634 TEST_F(TBMSurfaceQueue, GetWidthFailNull)
636 int width = tbm_surface_queue_get_width(NULL);
638 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
641 TEST_F(TBMSurfaceQueue, GetWidthFailInvalidInput)
643 int width = tbm_surface_queue_get_width(invalid_queue);
645 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
648 TEST_F(TBMSurfaceQueue, GetWidthSuccess)
650 int width = tbm_surface_queue_get_width(queue);
651 EXPECT_EQ(this->width, width);
652 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
655 /* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
656 TEST_F(TBMSurfaceQueue, GetHeightFailNull)
658 int height = tbm_surface_queue_get_height(NULL);
659 EXPECT_EQ(0, height);
660 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
663 TEST_F(TBMSurfaceQueue, GetHeightFailInvalidInput)
665 int height = tbm_surface_queue_get_height(invalid_queue);
666 EXPECT_EQ(0, height);
667 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
670 TEST_F(TBMSurfaceQueue, GetHeightSuccess)
672 int height = tbm_surface_queue_get_height(queue);
673 EXPECT_EQ(this->height, height);
674 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
677 /* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
678 TEST_F(TBMSurfaceQueue, GetFormatFailNull)
680 int format = tbm_surface_queue_get_format(NULL);
681 EXPECT_EQ(0, format);
682 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
685 TEST_F(TBMSurfaceQueue, GetFormatFailInvalidInput)
687 int format = tbm_surface_queue_get_format(invalid_queue);
688 EXPECT_EQ(0, format);
689 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
692 TEST_F(TBMSurfaceQueue, GetFormatSuccess)
694 int format = tbm_surface_queue_get_format(queue);
695 EXPECT_EQ((int)this->format, format);
696 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
699 /* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
700 TEST_F(TBMSurfaceQueue, GetSizeFailNull)
702 int q_size = tbm_surface_queue_get_size(NULL);
703 EXPECT_EQ(0, q_size);
704 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
707 TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
709 int q_size = tbm_surface_queue_get_size(invalid_queue);
710 EXPECT_EQ(0, q_size);
711 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
714 TEST_F(TBMSurfaceQueue, GetSizeSuccess)
716 int q_size = tbm_surface_queue_get_size(queue);
717 EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, q_size);
718 EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
721 /* tbm_surface_queue_error_e tbm_surface_queue_reset(
722 tbm_surface_queue_h surface_queue, int width, int height, int format); */
723 TEST_F(TBMSurfaceQueue, ResetFailNull)
725 result = tbm_surface_queue_reset(NULL, width, height, format);
726 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
729 TEST_F(TBMSurfaceQueue, ResetFailInvalidInput)
731 result = tbm_surface_queue_reset(invalid_queue, width, height, format);
732 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
734 result = tbm_surface_queue_reset(invalid_queue, -1, height, format);
735 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
737 result = tbm_surface_queue_reset(invalid_queue, width, -1, format);
738 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
740 result = tbm_surface_queue_reset(invalid_queue, width, height, 0);
741 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
744 TEST_F(TBMSurfaceQueue, ResetSuccessEmptyQueue)
746 result = tbm_surface_queue_reset(queue, width-10, height-10, format);
747 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
750 TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
752 tbm_surface_h surface = NULL;
755 result = tbm_surface_queue_dequeue(queue, &surface);
756 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
759 result = tbm_surface_queue_reset(queue, width, height, format);
760 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
763 ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
766 TEST_F(TBMSurfaceQueue, ResetSuccess)
768 tbm_surface_h surface = NULL;
771 result = tbm_surface_queue_dequeue(queue, &surface);
772 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
775 result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
776 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
779 ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
782 TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
784 tbm_surface_h surface = NULL;
786 /* create a sequence queue instead of a default one*/
787 tbm_surface_queue_destroy(queue);
788 queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
789 ASSERT_TRUE(queue != NULL);
791 result = tbm_surface_queue_dequeue(queue, &surface);
792 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
795 result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
796 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
799 ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
802 /* tbm_surface_queue_error_e tbm_surface_queue_set_size(
803 tbm_surface_queue_h surface_queue, int UT_TBM_SURFACE_QUEUE_SIZE, int flush); */
804 TEST_F(TBMSurfaceQueue, SetSizeFailNull)
806 result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
807 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
810 TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
812 result = tbm_surface_queue_set_size(invalid_queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
813 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
815 result = tbm_surface_queue_set_size(NULL, 0, 0);
816 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
819 TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
821 tbm_surface_h surface = NULL;
823 result = tbm_surface_queue_dequeue(queue, &surface);
824 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
827 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
828 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
829 ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
832 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 1);
833 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
834 ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
837 TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
839 tbm_surface_h surface = NULL;
841 result = tbm_surface_queue_dequeue(queue, &surface);
842 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
845 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+1, 0);
846 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
847 ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
850 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+2, 1);
851 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
852 ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
855 TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
857 tbm_surface_h surface = NULL;
859 result = tbm_surface_queue_dequeue(queue, &surface);
860 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
863 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-1, 0);
864 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
865 ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
868 result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-2, 1);
869 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
870 ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
873 /* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */
874 TEST_F(TBMSurfaceQueue, FlushFailNull)
876 result = tbm_surface_queue_flush(NULL);
877 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
880 TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
882 result = tbm_surface_queue_flush(invalid_queue);
883 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
886 TEST_F(TBMSurfaceQueue, FlushSuccess)
888 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
890 /*test: flushing not initialized queue*/
891 result = tbm_surface_queue_flush(queue);
892 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
895 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
896 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
897 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
898 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
899 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
903 result = tbm_surface_queue_flush(queue);
904 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
907 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
908 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
911 /* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */
912 TEST_F(TBMSurfaceQueue, FreeFlushFailNull)
914 result = tbm_surface_queue_free_flush(NULL);
915 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
918 TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
920 result = tbm_surface_queue_free_flush(invalid_queue);
921 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
924 TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
926 tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
928 /*test: flushing not initialized queue*/
929 result = tbm_surface_queue_free_flush(queue);
930 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
934 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
935 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
936 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
937 result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
938 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
942 result = tbm_surface_queue_free_flush(queue);
943 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
946 for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
947 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
950 /* tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb(
951 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
952 TEST_F(TBMSurfaceQueue, AddResetCbFailNull)
954 result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
955 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
957 result = tbm_surface_queue_add_reset_cb(queue, NULL, &cb_data);
958 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
961 TEST_F(TBMSurfaceQueue, AddResetCbFailInvalidInput)
963 result = tbm_surface_queue_add_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
964 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
967 TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
969 result = tbm_surface_queue_dequeue(queue, &surface);
970 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
971 result = tbm_surface_queue_enqueue(queue, surface);
972 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
975 result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
976 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
978 /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
980 result = tbm_surface_queue_flush(queue);
981 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
982 ASSERT_TRUE(cb_data == 1);
985 /* tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb(
986 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
987 TEST_F(TBMSurfaceQueue, RemoveResetCbFailNull)
989 result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
990 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
993 TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
995 result = tbm_surface_queue_dequeue(queue, &surface);
996 result = tbm_surface_queue_enqueue(queue, surface);
997 result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1000 result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1001 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1003 /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
1005 result = tbm_surface_queue_flush(queue);
1006 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1007 ASSERT_TRUE(cb_data == 0);
1010 TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
1012 result = tbm_surface_queue_dequeue(queue, &surface);
1013 result = tbm_surface_queue_enqueue(queue, surface);
1014 result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1016 /* test: invalid queue*/
1017 result = tbm_surface_queue_remove_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1018 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1020 /* test: invalid data */
1021 result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, NULL);
1022 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1024 /* test: invalid cb function */
1025 result = tbm_surface_queue_remove_reset_cb(queue, (tbm_surface_queue_notify_cb)1, &cb_data);
1026 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1028 /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
1030 result = tbm_surface_queue_flush(queue);
1031 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1032 ASSERT_TRUE(cb_data == 1);
1035 /* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */
1036 TEST_F(TBMSurfaceQueue, NotifyResetFailNull)
1038 result = tbm_surface_queue_notify_reset(NULL);
1039 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1042 TEST_F(TBMSurfaceQueue, NotifyResetFailInvalidInput)
1044 result = tbm_surface_queue_notify_reset(invalid_queue);
1045 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1048 TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
1050 result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1051 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1055 result = tbm_surface_queue_notify_reset(queue);
1056 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1057 ASSERT_TRUE(cb_data == 1);
1060 /* tbm_surface_queue_error_e tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue); */
1061 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailNull)
1063 result = tbm_surface_queue_notify_dequeuable(NULL);
1064 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1067 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailInvalidInput)
1069 result = tbm_surface_queue_notify_dequeuable(invalid_queue);
1070 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1073 TEST_F(TBMSurfaceQueue, NotifyDequeuableCbSuccess)
1076 result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1077 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1080 result = tbm_surface_queue_notify_dequeuable(queue);
1081 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1082 ASSERT_TRUE(cb_data == 1);
1085 /* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */
1086 TEST_F(TBMSurfaceQueue, CanDequeueFailNull)
1088 ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0));
1091 TEST_F(TBMSurfaceQueue, CanDequeueFailInvalidInput)
1093 ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0));
1096 TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
1100 /* test: dequeue all*/
1101 while (tbm_surface_queue_can_dequeue(queue, 0)) {
1102 result = tbm_surface_queue_dequeue(queue, &surface);
1103 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1106 EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
1109 TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
1112 while (tbm_surface_queue_can_dequeue(queue, 0)) {
1113 result = tbm_surface_queue_dequeue(queue, &surface);
1114 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1118 ASSERT_FALSE(tbm_surface_queue_can_dequeue(queue, 0));
1122 /* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */
1123 TEST_F(TBMSurfaceQueue, CanAcquireFailNull)
1125 ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0));
1128 TEST_F(TBMSurfaceQueue, CanAcquireFailInvalidInput)
1130 ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0));
1133 TEST_F(TBMSurfaceQueue, CanAcquireFailEmptyQueue)
1135 ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0));
1138 TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
1142 while (tbm_surface_queue_can_dequeue(queue, 0)) {
1143 result = tbm_surface_queue_dequeue(queue, &surface);
1144 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1145 result = tbm_surface_queue_enqueue(queue, surface);
1149 while (tbm_surface_queue_can_acquire(queue, 0)) {
1150 result = tbm_surface_queue_acquire(queue, &surface);
1151 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1155 EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
1158 /* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
1159 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
1160 TEST_F(TBMSurfaceQueue, AddDestroyCbFailNull)
1162 result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1163 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1165 result = tbm_surface_queue_add_destroy_cb(queue, NULL, &cb_data);
1166 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1169 TEST_F(TBMSurfaceQueue, AddDestroyCbFailInvalidInput)
1171 result = tbm_surface_queue_add_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1172 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1175 TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
1178 result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1179 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1182 tbm_surface_queue_destroy(queue);
1183 ASSERT_TRUE(cb_data == 1);
1185 /* to avoid destroying queue in TearDown*/
1189 /* tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
1190 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
1191 TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailNull)
1193 result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1194 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1197 TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailInvalidInput)
1199 result = tbm_surface_queue_remove_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1200 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1203 TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
1205 result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1206 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1207 result = tbm_surface_queue_remove_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1208 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1211 tbm_surface_queue_destroy(queue);
1212 ASSERT_TRUE(cb_data == 0);
1214 /* to avoid destroying queue in TearDown*/
1218 /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb(
1219 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
1220 TEST_F(TBMSurfaceQueue, AddDequeuableCbFailNull)
1222 result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1223 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1225 result = tbm_surface_queue_add_dequeuable_cb(queue, NULL, &cb_data);
1226 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1229 TEST_F(TBMSurfaceQueue, AddDequeuableCbFailInvalidInput)
1231 result = tbm_surface_queue_add_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1232 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1235 TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
1237 result = tbm_surface_queue_dequeue(queue, &surface);
1238 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1239 result = tbm_surface_queue_enqueue(queue, surface);
1240 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1241 result = tbm_surface_queue_acquire(queue, &surface);
1242 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1245 result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1246 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1249 result = tbm_surface_queue_release(queue, surface);
1250 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1251 ASSERT_TRUE(cb_data == 1);
1255 /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb(
1256 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
1257 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailNull)
1259 result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1260 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1263 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailInvalidInput)
1265 /* test: invalid queue */
1266 result = tbm_surface_queue_remove_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1267 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1270 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
1272 result = tbm_surface_queue_dequeue(queue, &surface);
1273 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1274 result = tbm_surface_queue_enqueue(queue, surface);
1275 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1276 result = tbm_surface_queue_acquire(queue, &surface);
1277 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1278 result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1279 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1282 result = tbm_surface_queue_remove_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1283 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1286 result = tbm_surface_queue_release(queue, surface);
1287 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1288 ASSERT_TRUE(cb_data == 0);
1291 /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb(
1292 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
1293 TEST_F(TBMSurfaceQueue, AddDequeueCbFailNull)
1295 result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1296 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1298 result = tbm_surface_queue_add_dequeue_cb(queue, NULL, &cb_data);
1299 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1302 TEST_F(TBMSurfaceQueue, AddDequeueCbFailInvalidInput)
1304 result = tbm_surface_queue_add_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1305 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1308 TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
1311 result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1312 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1315 result = tbm_surface_queue_dequeue(queue, &surface);
1316 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1317 ASSERT_TRUE(cb_data == 1);
1320 /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb(
1321 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
1322 TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailNull)
1324 result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1325 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1328 TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailInvalidInput)
1330 /* test: invalid queue */
1331 result = tbm_surface_queue_remove_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1332 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1335 TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
1338 result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1339 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1342 result = tbm_surface_queue_dequeue(queue, &surface);
1343 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1344 ASSERT_TRUE(cb_data == 1);
1346 result = tbm_surface_queue_remove_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1347 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1350 result = tbm_surface_queue_dequeue(queue, &surface);
1351 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1352 ASSERT_TRUE(cb_data == 0);
1355 /* tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb(
1356 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
1357 TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailNull)
1359 result = tbm_surface_queue_add_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1360 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1362 result = tbm_surface_queue_add_can_dequeue_cb(queue, NULL, &cb_data);
1363 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1366 TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailInvalidInput)
1368 result = tbm_surface_queue_add_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1369 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1372 TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
1375 result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1376 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1379 ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1380 ASSERT_TRUE(cb_data == 1);
1383 /* tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb(
1384 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
1385 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailNull)
1387 result = tbm_surface_queue_remove_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1388 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1391 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailInvalidInput)
1393 /* test: invalid queue */
1394 result = tbm_surface_queue_remove_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1395 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1398 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
1400 result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1401 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1404 result = tbm_surface_queue_remove_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1405 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1408 ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1409 ASSERT_TRUE(cb_data == 0);
1412 /* tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
1413 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
1414 TEST_F(TBMSurfaceQueue, AddAcquirableCbFailNull)
1416 result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1417 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1419 result = tbm_surface_queue_add_acquirable_cb(queue, NULL, &cb_data);
1420 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1423 TEST_F(TBMSurfaceQueue, AddAcquirableCbFailInvalidInput)
1425 result = tbm_surface_queue_add_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1426 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1429 TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
1431 tbm_surface_queue_dequeue(queue, &surface);
1434 result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1435 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1438 result = tbm_surface_queue_enqueue(queue, surface);
1439 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1440 ASSERT_TRUE(cb_data == 1);
1443 /* tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
1444 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
1445 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailNull)
1447 result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1448 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1451 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailInvalidInput)
1453 /* test: invalid queue */
1454 result = tbm_surface_queue_remove_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1455 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1458 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
1460 result = tbm_surface_queue_dequeue(queue, &surface);
1461 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1462 result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1463 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1466 result = tbm_surface_queue_remove_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1467 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1470 result = tbm_surface_queue_enqueue(queue, surface);
1471 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1472 ASSERT_TRUE(cb_data == 0);
1475 /* tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb(
1476 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
1477 TEST_F(TBMSurfaceQueue, AddTraceCbFailNull)
1479 result = tbm_surface_queue_add_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1480 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1482 result = tbm_surface_queue_add_trace_cb(queue, NULL, &trace_cb_data);
1483 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1486 TEST_F(TBMSurfaceQueue, AddTraceCbFailInvalidInput)
1488 result = tbm_surface_queue_add_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1489 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1492 TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
1494 trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1497 result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1498 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1500 result = tbm_surface_queue_dequeue(queue, &surface);
1501 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1502 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
1504 result = tbm_surface_queue_cancel_dequeue(queue, surface);
1505 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1506 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE);
1508 result = tbm_surface_queue_dequeue(queue, &surface);
1509 result = tbm_surface_queue_enqueue(queue, surface);
1510 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1511 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
1513 result = tbm_surface_queue_acquire(queue, &surface);
1514 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1515 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
1517 result = tbm_surface_queue_cancel_acquire(queue, surface);
1518 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1519 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE);
1521 result = tbm_surface_queue_acquire(queue, &surface);
1522 result = tbm_surface_queue_release(queue, surface);
1523 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1524 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_RELEASE);
1527 /* tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb(
1528 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
1529 TEST_F(TBMSurfaceQueue, RemoveTraceCbFailNull)
1531 result = tbm_surface_queue_remove_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1532 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1535 TEST_F(TBMSurfaceQueue, RemoveTraceCbFailInvalidInput)
1537 /* test: invalid queue */
1538 result = tbm_surface_queue_remove_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1539 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1542 TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
1544 trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1546 result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1547 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1550 result = tbm_surface_queue_remove_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1551 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1553 result = tbm_surface_queue_dequeue(queue, &surface);
1554 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1555 ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_NONE);
1558 /* tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb( tbm_surface_queue_h surface_queue,
1559 tbm_surface_alloc_cb alloc_cb, tbm_surface_free_cb free_cb, void *data); */
1560 TEST_F(TBMSurfaceQueue, SetAllocCbFailNull)
1562 result = tbm_surface_queue_set_alloc_cb(NULL, tbm_surface_alloc_cb_handler,
1563 tbm_surface_free_cb_handler, alien_surface);
1564 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1567 TEST_F(TBMSurfaceQueue, SetAllocCbFailInvalidInput)
1569 result = tbm_surface_queue_set_alloc_cb(invalid_queue, tbm_surface_alloc_cb_handler,
1570 tbm_surface_free_cb_handler, alien_surface);
1571 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1574 TEST_F(TBMSurfaceQueue, SetAllocCbSuccess)
1576 result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler,
1577 tbm_surface_free_cb_handler, alien_surface);
1578 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1580 /* test: allocate */
1581 result = tbm_surface_queue_dequeue(queue, &surface);
1582 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1583 EXPECT_EQ(alien_surface, surface);
1585 /* test: alien_surface has to be deleted*/
1586 tbm_surface_queue_destroy(queue);
1587 ASSERT_FALSE(tbm_surface_internal_is_valid(alien_surface));
1589 alien_surface = NULL;
1592 /* tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num(
1593 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num); */
1594 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailNull)
1600 result = tbm_surface_queue_get_trace_surface_num(NULL, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1601 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1603 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, NULL);
1604 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1607 }, ::testing::ExitedWithCode(0), "");
1611 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailInvalidInput)
1615 result = tbm_surface_queue_get_trace_surface_num(invalid_queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1616 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1619 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
1623 result = tbm_surface_queue_set_size(queue, 4, 0);
1626 result = tbm_surface_queue_dequeue(queue, &surface);
1627 result = tbm_surface_queue_enqueue(queue, surface);
1628 result = tbm_surface_queue_acquire(queue, &surface);
1631 result = tbm_surface_queue_dequeue(queue, &surface);
1632 result = tbm_surface_queue_enqueue(queue, surface);
1635 result = tbm_surface_queue_dequeue(queue, &surface);
1638 result = tbm_surface_queue_dequeue(queue, &surface);
1639 result = tbm_surface_queue_cancel_dequeue(queue, surface);
1643 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1644 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1647 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
1648 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1651 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ENQUEUE, &num);
1652 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1655 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ACQUIRE, &num);
1656 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1659 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_RELEASE, &num);
1660 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1663 /* tbm_surface_queue_error_e tbm_surface_queue_set_modes(
1664 tbm_surface_queue_h surface_queue, int modes); */
1665 TEST_F(TBMSurfaceQueue, SetModesFailNull)
1667 result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1668 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1671 TEST_F(TBMSurfaceQueue, SetModesFailInvalidInput)
1673 result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1674 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1677 TEST_F(TBMSurfaceQueue, SetModesSuccess)
1679 result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1680 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1683 /* tbm_surface_queue_set_sync_count() */
1684 TEST_F(TBMSurfaceQueue, SetSyncCountFailNull)
1686 result = tbm_surface_queue_set_sync_count(NULL, 1);
1687 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1690 TEST_F(TBMSurfaceQueue, SetSyncCountFailInvalidInput)
1692 result = tbm_surface_queue_set_sync_count(invalid_queue, 1);
1693 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1696 TEST_F(TBMSurfaceQueue, SetSyncCountSuccess)
1698 result = tbm_surface_queue_dequeue(queue, &surface);
1699 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1701 /* test: map after enqueue */
1702 result = tbm_surface_queue_set_sync_count(queue, 0);
1703 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1705 result = tbm_surface_queue_enqueue(queue, surface);
1706 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1708 /* test: map after acquire */
1709 result = tbm_surface_queue_set_sync_count(queue, 0);
1710 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1712 result = tbm_surface_queue_acquire(queue, &surface);
1713 EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));