haltests/tc_tbm_surface_queue.cpp

   1
   2 /**************************************************************************
   3  *
   4  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   5  *
   6  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   7  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   8  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   9  *
  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:
  17  *
  18  * The above copyright notice and this permission notice (including the
  19  * next paragraph) shall be included in all copies or substantial portions
  20  * of the Software.
  21  *
  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.
  29  *
  30 **************************************************************************/
  31
  32 #include "tc_tbm.h"
  33 class TBMSurfaceQueue : public TBMBufmgr
  34 {
  35 protected:
  36         void SetUp();
  37         void TearDown();
  38 public:
  39         int width;
  40         int height;
  41         int format;
  42
  43         uint32_t num_formats;
  44         tbm_format *formats;
  45
  46         tbm_surface_h alien_surface;
  47         tbm_surface_queue_h queue;
  48
  49         tbm_surface_queue_error_e result;
  50         tbm_surface_h surface;
  51 };
  52
  53 void TBMSurfaceQueue::SetUp()
  54 {
  55         tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
  56
  57         TBMBufmgr::SetUp();
  58
  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));
  61
  62         for (uint32_t i = 0; i < num_formats; i++)
  63                 if (formats[i] == TBM_FORMAT_ARGB8888)
  64                         format = TBM_FORMAT_ARGB8888;
  65
  66         /* fail if there is no TBM_FORMAT_ARGB8888 format */
  67         ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
  68
  69         width = 720;
  70         height = 1024;
  71         alien_surface = tbm_surface_create(width, height, format);
  72         EXPECT_NE((tbm_surface_h)NULL, alien_surface);
  73
  74         queue = tbm_surface_queue_create(TBM_UT_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));
  77 }
  78
  79 void TBMSurfaceQueue::TearDown()
  80 {
  81         if (alien_surface)
  82                 tbm_surface_destroy(alien_surface);
  83
  84         if (queue)
  85                 tbm_surface_queue_destroy(queue);
  86
  87         if (formats)
  88                 free(formats);
  89
  90         TBMBufmgr::TearDown();
  91 }
  92
  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;
  96
  97 static int cb_data;
  98 static void tbm_surface_queue_event_handler(tbm_surface_queue_h surface_queue, void *data)
  99 {
 100         if (data == &cb_data)
 101                 *((int *)data) = 1;
 102 }
 103
 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)
 107 {
 108         if (data == &trace_cb_data)
 109                 trace_cb_data = trace;
 110 }
 111
 112 static tbm_surface_h tbm_surface_alloc_cb_handler(tbm_surface_queue_h surface_queue, void *data)
 113 {
 114         return (tbm_surface_h)data;
 115 }
 116
 117 void tbm_surface_free_cb_handler(tbm_surface_queue_h surface_queue, void *data, tbm_surface_h surface)
 118 {
 119         if (data == surface)
 120                 tbm_surface_destroy(surface);
 121 }
 122
 123 TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
 124 {
 125         tbm_surface_queue_h queue1 = NULL;
 126
 127         queue1 = tbm_surface_queue_create(TBM_UT_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));
 130
 131         tbm_surface_queue_destroy(queue1);
 132         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 133 }
 134
 135 /* tbm_surface_queue_h tbm_surface_queue_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
 136                 int height, int format, int flags); */
 137 TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
 138 {
 139         tbm_surface_queue_h queue1 = NULL;
 140
 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));
 144
 145         queue1 = tbm_surface_queue_create(TBM_UT_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));
 148
 149         queue1 = tbm_surface_queue_create(TBM_UT_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));
 152
 153         queue1 = tbm_surface_queue_create(TBM_UT_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));
 156 }
 157
 158 /* tbm_surface_queue_h tbm_surface_queue_sequence_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
 159                 int height, int format, int flags); */
 160 TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
 161 {
 162         tbm_surface_queue_h queue1 = NULL;
 163
 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));
 167
 168         queue1 = tbm_surface_queue_sequence_create(TBM_UT_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));
 171
 172         queue1 = tbm_surface_queue_sequence_create(TBM_UT_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));
 175
 176         queue1 = tbm_surface_queue_sequence_create(TBM_UT_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));
 179 }
 180
 181 TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
 182 {
 183         tbm_surface_queue_h queue1 = NULL;
 184
 185         queue1 = tbm_surface_queue_sequence_create(TBM_UT_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));
 188
 189         tbm_surface_queue_destroy(queue1);
 190         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 191 }
 192
 193
 194 /* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */
 195 TEST_F(TBMSurfaceQueue, DestroyNULL)
 196 {
 197         tbm_surface_queue_destroy(NULL);
 198         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 199 }
 200
 201 TEST_F(TBMSurfaceQueue, DestroyTwice)
 202 {
 203         tbm_surface_queue_destroy(queue);
 204         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 205
 206         tbm_surface_queue_destroy(queue);
 207         EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 208
 209         /* to prevent destroy in TearDown */
 210         queue = NULL;
 211 }
 212
 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)
 216 {
 217         ASSERT_EXIT({
 218                 result = tbm_surface_queue_dequeue(NULL, &surface);
 219                 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 220
 221                 result = tbm_surface_queue_dequeue(queue, NULL);
 222                 EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 223
 224                 exit(0);
 225         }, ::testing::ExitedWithCode(0), "");
 226 }
 227
 228 TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
 229 {
 230         result = tbm_surface_queue_dequeue(invalid_queue, &surface);
 231         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 232 }
 233
 234 TEST_F(TBMSurfaceQueue, DequeueSuccess)
 235 {
 236         /* do dequeue three times */
 237         for (int i = 0; i < TBM_UT_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);
 241         }
 242
 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);
 246 }
 247
 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)
 251 {
 252         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 253         int num;
 254
 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));
 257
 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));
 260 }
 261
 262 TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
 263 {
 264         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 265         int num;
 266
 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));
 269 }
 270
 271 TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
 272 {
 273         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 274         int num = 0;
 275
 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));
 279         EXPECT_EQ(0, num);
 280
 281         /* do dequeue three times */
 282         for (int i = 0; i < TBM_UT_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);
 286         }
 287
 288         /* test */
 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(TBM_UT_SURFACE_QUEUE_SIZE, num);
 292         for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
 293                 EXPECT_NE(nullptr, surfaces[i]);
 294
 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(TBM_UT_SURFACE_QUEUE_SIZE, num);
 299 }
 300
 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)
 304 {
 305         result = tbm_surface_queue_dequeue(queue, &surface);
 306         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 307
 308         result = tbm_surface_queue_cancel_dequeue(NULL, surface);
 309         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 310
 311         result = tbm_surface_queue_cancel_dequeue(queue, NULL);
 312         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 313 }
 314
 315 TEST_F(TBMSurfaceQueue, CancelDequeueFailInvaildInput)
 316 {
 317         result = tbm_surface_queue_dequeue(queue, &surface);
 318         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 319
 320
 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));
 323
 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));
 326
 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));
 329 }
 330
 331 TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
 332 {
 333         tbm_surface_h last_surface = NULL;
 334
 335         for (int i = 0; i < TBM_UT_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);
 339         }
 340
 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);
 345
 346         /* test */
 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));
 349
 350         /* extra check */
 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);
 354 }
 355
 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)
 359 {
 360         result = tbm_surface_queue_dequeue(queue, &surface);
 361         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 362
 363         /* test */
 364         result = tbm_surface_queue_enqueue(NULL, surface);
 365         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 366
 367         result = tbm_surface_queue_enqueue(this->queue, NULL);
 368         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 369 }
 370
 371 TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
 372 {
 373         result = tbm_surface_queue_dequeue(queue, &surface);
 374         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 375
 376         /* test */
 377         result = tbm_surface_queue_enqueue(invalid_queue, surface);
 378         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 379
 380         result = tbm_surface_queue_enqueue(queue, invalid_surface);
 381         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 382
 383         result = tbm_surface_queue_enqueue(queue, alien_surface);
 384         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 385 }
 386
 387 TEST_F(TBMSurfaceQueue, EnqueueSuccess)
 388 {
 389         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 390
 391
 392         for (int i = 0; i < TBM_UT_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));
 395         }
 396
 397         /* test */
 398         for (int i = 0; i < TBM_UT_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));
 401         }
 402 }
 403
 404 TEST_F(TBMSurfaceQueue, EnqueueFailTwice)
 405 {
 406         result = tbm_surface_queue_dequeue(queue, &surface);
 407         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 408
 409         /* test */
 410         result = tbm_surface_queue_enqueue(queue, surface);
 411         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 412
 413         result = tbm_surface_queue_enqueue(queue, surface);
 414         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 415 }
 416
 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)
 420 {
 421         /* test */
 422         result = tbm_surface_queue_acquire(NULL, &surface);
 423         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 424
 425         result = tbm_surface_queue_acquire(queue, &surface);
 426         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 427 }
 428
 429 TEST_F(TBMSurfaceQueue, AcquireFailInvaildInput)
 430 {
 431         result = tbm_surface_queue_acquire(invalid_queue, &surface);
 432         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 433 }
 434
 435 TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
 436 {
 437         result = tbm_surface_queue_acquire(invalid_queue, &surface);
 438         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 439 }
 440
 441 TEST_F(TBMSurfaceQueue, AcquireSuccess)
 442 {
 443         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 444         tbm_surface_h acquired_surface = NULL;
 445
 446
 447         for (int i = 0; i < TBM_UT_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));
 452         }
 453
 454         /* test */
 455         for (int i = 0; i < TBM_UT_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);
 459         }
 460
 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);
 465 }
 466
 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)
 470 {
 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);
 474
 475         /* test */
 476         result = tbm_surface_queue_cancel_acquire(NULL, surface);
 477         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 478
 479         result = tbm_surface_queue_cancel_acquire(queue, NULL);
 480         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 481 }
 482
 483 TEST_F(TBMSurfaceQueue, CancelAcquireFailInvaildInput)
 484 {
 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));
 489
 490         /* test */
 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));
 493
 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));
 496
 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));
 499 }
 500
 501 TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
 502 {
 503         tbm_surface_h last_surface = NULL;
 504
 505         for (int i = 0; i < TBM_UT_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));
 510         }
 511
 512         for (int i = 0; i < TBM_UT_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));
 515         }
 516
 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);
 521
 522         /* test */
 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));
 525
 526         /* extra check */
 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);
 530 }
 531
 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)
 535 {
 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));
 542
 543         /* test */
 544         result = tbm_surface_queue_release(NULL, surface);
 545         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 546
 547         result = tbm_surface_queue_release(this->queue, NULL);
 548         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 549 }
 550
 551 TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
 552 {
 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));
 559
 560         /* test */
 561         result = tbm_surface_queue_release(invalid_queue, surface);
 562         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 563
 564         result = tbm_surface_queue_release(queue, invalid_surface);
 565         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 566
 567         result = tbm_surface_queue_release(queue, alien_surface);
 568         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 569 }
 570
 571 TEST_F(TBMSurfaceQueue, ReleaseSuccess)
 572 {
 573         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 574
 575         for (int i = 0; i < TBM_UT_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));
 582         }
 583
 584         /* test */
 585         for (int i = 0; i < TBM_UT_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));
 588         }
 589 }
 590
 591 TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
 592 {
 593         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 594
 595         /* create a sequence queue instead of a default one*/
 596         tbm_surface_queue_destroy(queue);
 597         queue = tbm_surface_queue_sequence_create(TBM_UT_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()));
 599
 600         for (int i = 0; i < TBM_UT_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));
 607         }
 608
 609         /* test */
 610         for (int i = 0; i < TBM_UT_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));
 613         }
 614 }
 615
 616 TEST_F(TBMSurfaceQueue, ReleaseFailTwice)
 617 {
 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));
 624
 625         /* test */
 626         result = tbm_surface_queue_release(queue, surface);
 627         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 628
 629         result = tbm_surface_queue_release(queue, surface);
 630         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 631 }
 632
 633 /* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
 634 TEST_F(TBMSurfaceQueue, GetWidthFailNull)
 635 {
 636         int width = tbm_surface_queue_get_width(NULL);
 637         EXPECT_EQ(0, width);
 638         EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 639 }
 640
 641 TEST_F(TBMSurfaceQueue, GetWidthFailInvalidInput)
 642 {
 643         int width = tbm_surface_queue_get_width(invalid_queue);
 644         EXPECT_EQ(0, width);
 645         EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 646 }
 647
 648 TEST_F(TBMSurfaceQueue, GetWidthSuccess)
 649 {
 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));
 653 }
 654
 655 /* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
 656 TEST_F(TBMSurfaceQueue, GetHeightFailNull)
 657 {
 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));
 661 }
 662
 663 TEST_F(TBMSurfaceQueue, GetHeightFailInvalidInput)
 664 {
 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));
 668 }
 669
 670 TEST_F(TBMSurfaceQueue, GetHeightSuccess)
 671 {
 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));
 675 }
 676
 677 /* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
 678 TEST_F(TBMSurfaceQueue, GetFormatFailNull)
 679 {
 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));
 683 }
 684
 685 TEST_F(TBMSurfaceQueue, GetFormatFailInvalidInput)
 686 {
 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));
 690 }
 691
 692 TEST_F(TBMSurfaceQueue, GetFormatSuccess)
 693 {
 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));
 697 }
 698
 699 /* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
 700 TEST_F(TBMSurfaceQueue, GetSizeFailNull)
 701 {
 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));
 705 }
 706
 707 TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
 708 {
 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));
 712 }
 713
 714 TEST_F(TBMSurfaceQueue, GetSizeSuccess)
 715 {
 716         int q_size = tbm_surface_queue_get_size(queue);
 717         EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE,  q_size);
 718         EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 719 }
 720
 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)
 724 {
 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));
 727 }
 728
 729 TEST_F(TBMSurfaceQueue, ResetFailInvalidInput)
 730 {
 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));
 733
 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));
 736
 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));
 739
 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));
 742 }
 743
 744 TEST_F(TBMSurfaceQueue, ResetSuccessEmptyQueue)
 745 {
 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));
 748 }
 749
 750 TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
 751 {
 752         tbm_surface_h surface = NULL;
 753
 754
 755         result = tbm_surface_queue_dequeue(queue, &surface);
 756         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 757
 758         /* test */
 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));
 761
 762         /* extra check */
 763         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 764 }
 765
 766 TEST_F(TBMSurfaceQueue, ResetSuccess)
 767 {
 768         tbm_surface_h surface = NULL;
 769
 770
 771         result = tbm_surface_queue_dequeue(queue, &surface);
 772         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 773
 774         /* test */
 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));
 777
 778         /* extra check */
 779         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 780 }
 781
 782 TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
 783 {
 784         tbm_surface_h surface = NULL;
 785
 786         /* create a sequence queue instead of a default one*/
 787         tbm_surface_queue_destroy(queue);
 788         queue = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
 789         ASSERT_TRUE(queue != NULL);
 790
 791         result = tbm_surface_queue_dequeue(queue, &surface);
 792         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 793
 794         /* test */
 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));
 797
 798         /* extra check */
 799         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 800 }
 801
 802 /* tbm_surface_queue_error_e tbm_surface_queue_set_size(
 803                 tbm_surface_queue_h surface_queue, int TBM_UT_SURFACE_QUEUE_SIZE, int flush); */
 804 TEST_F(TBMSurfaceQueue, SetSizeFailNull)
 805 {
 806         result = tbm_surface_queue_set_size(NULL, TBM_UT_SURFACE_QUEUE_SIZE, 0);
 807         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 808 }
 809
 810 TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
 811 {
 812         result = tbm_surface_queue_set_size(invalid_queue, TBM_UT_SURFACE_QUEUE_SIZE, 0);
 813         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 814
 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));
 817 }
 818
 819 TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
 820 {
 821         tbm_surface_h surface = NULL;
 822
 823         result = tbm_surface_queue_dequeue(queue, &surface);
 824         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 825
 826         /*test: */
 827         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 830
 831         /*test: with flush*/
 832         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 835 }
 836
 837 TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
 838 {
 839         tbm_surface_h surface = NULL;
 840
 841         result = tbm_surface_queue_dequeue(queue, &surface);
 842         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 843
 844         /*test: */
 845         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 848
 849         /*test: with flush*/
 850         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 853 }
 854
 855 TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
 856 {
 857         tbm_surface_h surface = NULL;
 858
 859         result = tbm_surface_queue_dequeue(queue, &surface);
 860         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 861
 862         /*test: */
 863         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 866
 867         /*test: with flush*/
 868         result = tbm_surface_queue_set_size(queue, TBM_UT_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";
 871 }
 872
 873 /* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */
 874 TEST_F(TBMSurfaceQueue, FlushFailNull)
 875 {
 876         result = tbm_surface_queue_flush(NULL);
 877         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 878 }
 879
 880 TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
 881 {
 882         result = tbm_surface_queue_flush(invalid_queue);
 883         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 884 }
 885
 886 TEST_F(TBMSurfaceQueue, FlushSuccess)
 887 {
 888         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 889
 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));
 893
 894
 895         for (int i = 0; i < TBM_UT_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));
 900         }
 901
 902         /* test */
 903         result = tbm_surface_queue_flush(queue);
 904         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 905
 906         /* extra check */
 907         for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
 908                 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 909 }
 910
 911 /* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */
 912 TEST_F(TBMSurfaceQueue, FreeFlushFailNull)
 913 {
 914         result = tbm_surface_queue_free_flush(NULL);
 915         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 916 }
 917
 918 TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
 919 {
 920         result = tbm_surface_queue_free_flush(invalid_queue);
 921         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 922 }
 923
 924 TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
 925 {
 926         tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 927
 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));
 931
 932
 933         /* init queue */
 934         for (int i = 0; i < TBM_UT_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));
 939         }
 940
 941         /* test */
 942         result = tbm_surface_queue_free_flush(queue);
 943         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 944
 945         /* extra check */
 946         for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
 947                 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 948 }
 949
 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)
 953 {
 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));
 956
 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));
 959 }
 960
 961 TEST_F(TBMSurfaceQueue, AddResetCbFailInvalidInput)
 962 {
 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));
 965 }
 966
 967 TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
 968 {
 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));
 973
 974         /* test */
 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));
 977
 978         /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
 979         cb_data = 0;
 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);
 983 }
 984
 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)
 988 {
 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));
 991 }
 992
 993 TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
 994 {
 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);
 998
 999         /* test */
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));
1002
1003         /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
1004         cb_data = 0;
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);
1008 }
1009
1010 TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
1011 {
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);
1015
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));
1019
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));
1023
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));
1027
1028         /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
1029         cb_data = 0;
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);
1033 }
1034
1035 /* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */
1036 TEST_F(TBMSurfaceQueue, NotifyResetFailNull)
1037 {
1038         result = tbm_surface_queue_notify_reset(NULL);
1039         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1040 }
1041
1042 TEST_F(TBMSurfaceQueue, NotifyResetFailInvalidInput)
1043 {
1044         result = tbm_surface_queue_notify_reset(invalid_queue);
1045         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1046 }
1047
1048 TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
1049 {
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));
1052
1053         /* test */
1054         cb_data = 0;
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);
1058 }
1059
1060 /* tbm_surface_queue_error_e tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue); */
1061 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailNull)
1062 {
1063         result = tbm_surface_queue_notify_dequeuable(NULL);
1064         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1065 }
1066
1067 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailInvalidInput)
1068 {
1069         result = tbm_surface_queue_notify_dequeuable(invalid_queue);
1070         EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1071 }
1072
1073 TEST_F(TBMSurfaceQueue, NotifyDequeuableCbSuccess)
1074 {
1075         /* test */
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));
1078
1079         cb_data = 0;
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);
1083 }
1084
1085 /* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */
1086 TEST_F(TBMSurfaceQueue, CanDequeueFailNull)
1087 {
1088         ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0));
1089 }
1090
1091 TEST_F(TBMSurfaceQueue, CanDequeueFailInvalidInput)
1092 {
1093         ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0));
1094 }
1095
1096 TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
1097 {
1098         int dq_count = 0;
1099
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));
1104                 dq_count++;
1105         }
1106         EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, dq_count);
1107 }
1108
1109 TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
1110 {
1111         /*Dequeue all*/
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));
1115         }
1116
1117         /* test */
1118         ASSERT_FALSE(tbm_surface_queue_can_dequeue(queue, 0));
1119 }
1120
1121
1122 /* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */
1123 TEST_F(TBMSurfaceQueue, CanAcquireFailNull)
1124 {
1125         ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0));
1126 }
1127
1128 TEST_F(TBMSurfaceQueue, CanAcquireFailInvalidInput)
1129 {
1130         ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0));
1131 }
1132
1133 TEST_F(TBMSurfaceQueue, CanAcquireFailEmptyQueue)
1134 {
1135         ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0));
1136 }
1137
1138 TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
1139 {
1140         int acq_count = 0;
1141
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);
1146         }
1147
1148         /*Dequeue all*/
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));
1152                 acq_count++;
1153         }
1154
1155         EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, acq_count);
1156 }
1157
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)
1161 {
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));
1164
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));
1167 }
1168
1169 TEST_F(TBMSurfaceQueue, AddDestroyCbFailInvalidInput)
1170 {
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));
1173 }
1174
1175 TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
1176 {
1177         /* test */
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));
1180
1181         cb_data = 0;
1182         tbm_surface_queue_destroy(queue);
1183         ASSERT_TRUE(cb_data == 1);
1184
1185         /* to avoid destroying queue in TearDown*/
1186         queue = NULL;
1187 }
1188
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)
1192 {
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));
1195 }
1196
1197 TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailInvalidInput)
1198 {
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));
1201 }
1202
1203 TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
1204 {
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));
1209
1210         cb_data = 0;
1211         tbm_surface_queue_destroy(queue);
1212         ASSERT_TRUE(cb_data == 0);
1213
1214         /* to avoid destroying queue in TearDown*/
1215         queue = NULL;
1216 }
1217
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)
1221 {
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));
1224
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));
1227 }
1228
1229 TEST_F(TBMSurfaceQueue, AddDequeuableCbFailInvalidInput)
1230 {
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));
1233 }
1234
1235 TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
1236 {
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));
1243
1244         /* test */
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));
1247
1248         cb_data = 0;
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);
1252 }
1253
1254
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)
1258 {
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));
1261 }
1262
1263 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailInvalidInput)
1264 {
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));
1268 }
1269
1270 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
1271 {
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));
1280
1281         /* test */
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));
1284
1285         cb_data = 0;
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);
1289 }
1290
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)
1294 {
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));
1297
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));
1300 }
1301
1302 TEST_F(TBMSurfaceQueue, AddDequeueCbFailInvalidInput)
1303 {
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));
1306 }
1307
1308 TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
1309 {
1310         /* test */
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));
1313
1314         cb_data = 0;
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);
1318 }
1319
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)
1323 {
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));
1326 }
1327
1328 TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailInvalidInput)
1329 {
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));
1333 }
1334
1335 TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
1336 {
1337         /* test */
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));
1340
1341         cb_data = 0;
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);
1345
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));
1348
1349         cb_data = 0;
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);
1353 }
1354
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)
1358 {
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));
1361
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));
1364 }
1365
1366 TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailInvalidInput)
1367 {
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));
1370 }
1371
1372 TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
1373 {
1374         /* test */
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));
1377
1378         cb_data = 0;
1379         ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1380         ASSERT_TRUE(cb_data == 1);
1381 }
1382
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)
1386 {
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));
1389 }
1390
1391 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailInvalidInput)
1392 {
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));
1396 }
1397
1398 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
1399 {
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));
1402
1403         /* test */
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));
1406
1407         cb_data = 0;
1408         ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1409         ASSERT_TRUE(cb_data == 0);
1410 }
1411
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)
1415 {
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));
1418
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));
1421 }
1422
1423 TEST_F(TBMSurfaceQueue, AddAcquirableCbFailInvalidInput)
1424 {
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));
1427 }
1428
1429 TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
1430 {
1431         tbm_surface_queue_dequeue(queue, &surface);
1432
1433         /* test */
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));
1436
1437         cb_data = 0;
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);
1441 }
1442
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)
1446 {
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));
1449 }
1450
1451 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailInvalidInput)
1452 {
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));
1456 }
1457
1458 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
1459 {
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));
1464
1465         /* test */
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));
1468
1469         cb_data = 0;
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);
1473 }
1474
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)
1478 {
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));
1481
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));
1484 }
1485
1486 TEST_F(TBMSurfaceQueue, AddTraceCbFailInvalidInput)
1487 {
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));
1490 }
1491
1492 TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
1493 {
1494         trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1495
1496         /* test */
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));
1499
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);
1503
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);
1507
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);
1512
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);
1516
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);
1520
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);
1525 }
1526
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)
1530 {
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));
1533 }
1534
1535 TEST_F(TBMSurfaceQueue, RemoveTraceCbFailInvalidInput)
1536 {
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));
1540 }
1541
1542 TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
1543 {
1544         trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1545
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));
1548
1549         /* test */
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));
1552
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);
1556 }
1557
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)
1561 {
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));
1565 }
1566
1567 TEST_F(TBMSurfaceQueue, SetAllocCbFailInvalidInput)
1568 {
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));
1572 }
1573
1574 TEST_F(TBMSurfaceQueue, SetAllocCbSuccess)
1575 {
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));
1579
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);
1584
1585         /* test:  alien_surface has to be deleted*/
1586         tbm_surface_queue_destroy(queue);
1587         ASSERT_FALSE(tbm_surface_internal_is_valid(alien_surface));
1588
1589         alien_surface = NULL;
1590 }
1591
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)
1595 {
1596         int num = 0;
1597
1598         ASSERT_EXIT({
1599
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));
1602
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));
1605
1606                 exit(0);
1607         }, ::testing::ExitedWithCode(0), "");
1608
1609 }
1610
1611 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailInvalidInput)
1612 {
1613         int num = 0;
1614
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));
1617 }
1618
1619 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
1620 {
1621         int num = 0;
1622
1623         result = tbm_surface_queue_set_size(queue, 4, 0);
1624
1625         /* one acquired */
1626         result = tbm_surface_queue_dequeue(queue, &surface);
1627         result = tbm_surface_queue_enqueue(queue, surface);
1628         result = tbm_surface_queue_acquire(queue, &surface);
1629
1630         /* one enqueued */
1631         result = tbm_surface_queue_dequeue(queue, &surface);
1632         result = tbm_surface_queue_enqueue(queue, surface);
1633
1634         /* one dequeued */
1635         result = tbm_surface_queue_dequeue(queue, &surface);
1636
1637         /* one released */
1638         result = tbm_surface_queue_dequeue(queue, &surface);
1639         result = tbm_surface_queue_cancel_dequeue(queue, surface);
1640
1641
1642         /* test */
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));
1645         EXPECT_EQ(0, num);
1646
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));
1649         EXPECT_EQ(1, num);
1650
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));
1653         EXPECT_EQ(1, num);
1654
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));
1657         EXPECT_EQ(1, num);
1658
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));
1661         EXPECT_EQ(1, num);
1662 }
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)
1666 {
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));
1669 }
1670
1671 TEST_F(TBMSurfaceQueue, SetModesFailInvalidInput)
1672 {
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));
1675 }
1676
1677 TEST_F(TBMSurfaceQueue, SetModesSuccess)
1678 {
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));
1681 }
1682
1683 /* tbm_surface_queue_set_sync_count() */
1684 TEST_F(TBMSurfaceQueue, SetSyncCountFailNull)
1685 {
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));
1688 }
1689
1690 TEST_F(TBMSurfaceQueue, SetSyncCountFailInvalidInput)
1691 {
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));
1694 }
1695
1696 TEST_F(TBMSurfaceQueue, SetSyncCountSuccess)
1697 {
1698         result = tbm_surface_queue_dequeue(queue, &surface);
1699         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1700
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));
1704
1705         result = tbm_surface_queue_enqueue(queue, surface);
1706         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1707
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));
1711
1712         result = tbm_surface_queue_acquire(queue, &surface);
1713         EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
1714 }