utests/ut_tbm_surface_queue.cpp

   1 #include <gtest/gtest.h>
   2 #include <stdlib.h>
   3
   4 #include <tbm_surface.h>
   5 #include <tbm_surface_internal.h>
   6 #include <tbm_surface_queue.h>
   7 #include "ut.h"
   8
   9 int memory_for_invalid_param;
  10 tbm_surface_queue_h invalid_queue = (tbm_surface_queue_h)&memory_for_invalid_param;
  11 int memory_for_invalid_queue;
  12 tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
  13
  14 static int cb_data;
  15 static void tbm_surface_queue_event_handler(tbm_surface_queue_h surface_queue, void *data)
  16 {
  17         if (data == &cb_data)
  18                 *((int *)data) = 1;
  19 }
  20
  21 static tbm_surface_queue_trace trace_cb_data;
  22 static void tbm_surface_queue_trace_event_handler(tbm_surface_queue_h surface_queue,
  23                 tbm_surface_h surface, tbm_surface_queue_trace trace, void *data)
  24 {
  25         if (data == &trace_cb_data)
  26                 trace_cb_data = trace;
  27 }
  28
  29 static tbm_surface_h tbm_surface_alloc_cb_handler(tbm_surface_queue_h surface_queue, void *data)
  30 {
  31         return (tbm_surface_h)data;
  32 }
  33
  34 void tbm_surface_free_cb_handler(tbm_surface_queue_h surface_queue, void *data, tbm_surface_h surface)
  35 {
  36         if (data == surface)
  37                 tbm_surface_destroy(surface);
  38 }
  39
  40 /* tbm_surface_queue_h tbm_surface_queue_create(int QUEUE_SIZE, int width,
  41                 int height, int format, int flags); */
  42 TEST(UtSurfaceQueueCreate, CreateFailInvalidInput)
  43 {
  44         tbm_surface_queue_h queue = NULL;
  45
  46         ut_set_default_tbm_env();
  47
  48         queue = tbm_surface_queue_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  49         ASSERT_EQ(nullptr, queue); // Expected Value: NULL
  50
  51         queue = tbm_surface_queue_create(QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  52         ASSERT_EQ(nullptr, queue);
  53
  54         queue = tbm_surface_queue_create(QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  55         ASSERT_EQ(nullptr, queue);
  56
  57         queue = tbm_surface_queue_create(QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
  58         ASSERT_EQ(nullptr, queue);
  59 }
  60
  61 TEST(UtSurfaceQueueCreate, CreateSuccess)
  62 {
  63         tbm_surface_queue_h queue = NULL;
  64         uint32_t num = 0;
  65         tbm_format *formats = NULL;
  66
  67         ut_set_default_tbm_env();
  68
  69         ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num));
  70
  71         queue = tbm_surface_queue_create(QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
  72         ASSERT_NE(nullptr, queue);
  73
  74         tbm_surface_queue_destroy(queue);
  75
  76         free(formats);
  77 }
  78
  79
  80 /* tbm_surface_queue_h tbm_surface_queue_sequence_create(int QUEUE_SIZE, int width,
  81                 int height, int format, int flags); */
  82 TEST(UtSurfaceQueueCreate, SequenceCreateFailInvalidInput)
  83 {
  84         tbm_surface_queue_h queue = NULL;
  85
  86         ut_set_default_tbm_env();
  87
  88         queue = tbm_surface_queue_sequence_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  89         ASSERT_EQ(nullptr, queue); // Expected Value: NULL
  90
  91         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  92         ASSERT_EQ(nullptr, queue);
  93
  94         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
  95         ASSERT_EQ(nullptr, queue);
  96
  97         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
  98         ASSERT_EQ(nullptr, queue);
  99 }
 100
 101 TEST(UtSurfaceQueueCreate, SequenceCreateSuccess)
 102 {
 103         tbm_surface_queue_h queue = NULL;
 104         uint32_t num = 0;
 105         tbm_format *formats = NULL;
 106
 107         ut_set_default_tbm_env();
 108
 109         ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num));
 110
 111         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
 112         ASSERT_NE(nullptr, queue);
 113
 114         free(formats);
 115 }
 116
 117
 118 /* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */
 119 TEST_F(SurfaceQueueTest, DestroyNULL)
 120 {
 121         tbm_surface_queue_destroy(NULL);
 122 }
 123
 124 TEST_F(SurfaceQueueTest, DestroyTwice)
 125 {
 126         tbm_surface_queue_destroy(queue);
 127
 128         tbm_surface_queue_destroy(queue);
 129
 130         /* to prevent destroy in TearDown */
 131         queue = NULL;
 132 }
 133
 134 /* tbm_surface_queue_error_e tbm_surface_queue_dequeue(
 135                 tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
 136 TEST_F(SurfaceQueueTest, DequeueFailNull)
 137 {
 138         ASSERT_EXIT({
 139
 140                 result = tbm_surface_queue_dequeue(NULL, &surface);
 141                 ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 142
 143                 result = tbm_surface_queue_dequeue(queue, NULL);
 144                 ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 145
 146                 exit(0);
 147         }, ::testing::ExitedWithCode(0), "");
 148 }
 149
 150 TEST_F(SurfaceQueueTest, DequeueFailInvaildInput)
 151 {
 152         result = tbm_surface_queue_dequeue(invalid_queue, &surface);
 153         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 154 }
 155
 156 TEST_F(SurfaceQueueTest, DequeueSuccess)
 157 {
 158         /* do dequeue three times */
 159         for (int i = 0; i < QUEUE_SIZE; i++) {
 160                 result = tbm_surface_queue_dequeue(queue, &surface);
 161                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 162                 ASSERT_NE((tbm_surface_h)NULL, surface);
 163         }
 164
 165         result = tbm_surface_queue_dequeue(queue, &surface);
 166         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 167         ASSERT_EQ(nullptr, surface);
 168 }
 169
 170 /* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue,
 171         tbm_surface_h *surfaces, int *num); */
 172 TEST_F(SurfaceQueueTest, GetSurfacesFailNull)
 173 {
 174         tbm_surface_h surfaces[QUEUE_SIZE];
 175         int num;
 176
 177         result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
 178         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 179
 180         result = tbm_surface_queue_get_surfaces(queue, surfaces, NULL);
 181         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 182 }
 183
 184 TEST_F(SurfaceQueueTest, GetSurfacesFailInvaildInput)
 185 {
 186         tbm_surface_h surfaces[QUEUE_SIZE];
 187         int num;
 188
 189         result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
 190         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 191 }
 192
 193 TEST_F(SurfaceQueueTest, GetSurfacesSuccess)
 194 {
 195         tbm_surface_h surfaces[QUEUE_SIZE];
 196         int num = 0;
 197
 198         /* test: empty queue*/
 199         result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
 200         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 201         ASSERT_EQ(0, num);
 202
 203         /* do dequeue three times */
 204         for (int i = 0; i < QUEUE_SIZE; i++) {
 205                 result = tbm_surface_queue_dequeue(queue, &surface);
 206                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 207                 ASSERT_NE(nullptr, surface);
 208         }
 209
 210         /* test */
 211         result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
 212         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 213         ASSERT_EQ(QUEUE_SIZE, num);
 214         for (int i = 0; i < QUEUE_SIZE; i++)
 215                 ASSERT_NE(nullptr, surfaces[i]);
 216
 217         /* test: get only number of surfaces */
 218         result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
 219         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 220         ASSERT_EQ(QUEUE_SIZE, num);
 221 }
 222
 223 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
 224                 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
 225 TEST_F(SurfaceQueueTest, CancelDequeueFailNull)
 226 {
 227         result = tbm_surface_queue_dequeue(queue, &surface);
 228         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 229
 230         result = tbm_surface_queue_cancel_dequeue(NULL, surface);
 231         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 232
 233         result = tbm_surface_queue_cancel_dequeue(queue, NULL);
 234         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 235 }
 236
 237 TEST_F(SurfaceQueueTest, CancelDequeueFailInvaildInput)
 238 {
 239         result = tbm_surface_queue_dequeue(queue, &surface);
 240         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 241
 242
 243         result = tbm_surface_queue_cancel_dequeue(invalid_queue, surface);
 244         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 245
 246         result = tbm_surface_queue_cancel_dequeue(queue, invalid_surface);
 247         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 248
 249         result = tbm_surface_queue_cancel_dequeue(queue, alien_surface);
 250         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 251 }
 252
 253 TEST_F(SurfaceQueueTest, CancelDequeueSuccess)
 254 {
 255         tbm_surface_h last_surface = NULL;
 256
 257         for (int i = 0; i < QUEUE_SIZE; i++) {
 258                 result = tbm_surface_queue_dequeue(queue, &surface);
 259                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 260                 ASSERT_NE(nullptr, surface);
 261         }
 262
 263         last_surface = surface;
 264         result = tbm_surface_queue_dequeue(queue, &surface);
 265         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 266         ASSERT_EQ(nullptr, surface);
 267
 268         /* test */
 269         result = tbm_surface_queue_cancel_dequeue(queue, last_surface);
 270         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 271
 272         /* extra check */
 273         result = tbm_surface_queue_dequeue(queue, &surface);
 274         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 275         ASSERT_EQ(last_surface, surface);
 276 }
 277
 278 /* tbm_surface_queue_error_e tbm_surface_queue_enqueue(
 279                 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
 280 TEST_F(SurfaceQueueTest, EnqueueFailNull)
 281 {
 282         result = tbm_surface_queue_dequeue(queue, &surface);
 283         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 284
 285         /* test */
 286         result = tbm_surface_queue_enqueue(NULL, surface);
 287         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 288
 289         result = tbm_surface_queue_enqueue(this->queue, NULL);
 290         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 291 }
 292
 293 TEST_F(SurfaceQueueTest, EnqueueFailInvaildInput)
 294 {
 295         result = tbm_surface_queue_dequeue(queue, &surface);
 296         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 297
 298         /* test */
 299         result = tbm_surface_queue_enqueue(invalid_queue, surface);
 300         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 301
 302         result = tbm_surface_queue_enqueue(queue, invalid_surface);
 303         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 304
 305         result = tbm_surface_queue_enqueue(queue, alien_surface);
 306         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 307 }
 308
 309 TEST_F(SurfaceQueueTest, EnqueueSuccess)
 310 {
 311         tbm_surface_h surfaces[QUEUE_SIZE] = { NULL };
 312
 313
 314         for (int i = 0; i < QUEUE_SIZE; i++) {
 315                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 316                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 317         }
 318
 319         /* test */
 320         for (int i = 0; i < QUEUE_SIZE; i++) {
 321                 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
 322                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 323         }
 324 }
 325
 326 TEST_F(SurfaceQueueTest, EnqueueFailTwice)
 327 {
 328         result = tbm_surface_queue_dequeue(queue, &surface);
 329         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 330
 331         /* test */
 332         result = tbm_surface_queue_enqueue(queue, surface);
 333         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 334
 335         result = tbm_surface_queue_enqueue(queue, surface);
 336         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 337 }
 338
 339 /* tbm_surface_queue_error_e tbm_surface_queue_acquire(
 340                 tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
 341 TEST_F(SurfaceQueueTest, AcquireFailNull)
 342 {
 343         /* test */
 344         result = tbm_surface_queue_acquire(NULL, &surface);
 345         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 346
 347         result = tbm_surface_queue_acquire(queue, &surface);
 348         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 349 }
 350
 351 TEST_F(SurfaceQueueTest, AcquireFailInvaildInput)
 352 {
 353         result = tbm_surface_queue_acquire(invalid_queue, &surface);
 354         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 355 }
 356
 357 TEST_F(SurfaceQueueTest, AcquireFailAcquireEmptyQueue)
 358 {
 359         result = tbm_surface_queue_acquire(invalid_queue, &surface);
 360         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 361 }
 362
 363 TEST_F(SurfaceQueueTest, AcquireSuccess)
 364 {
 365         tbm_surface_h surfaces[QUEUE_SIZE] = { NULL };
 366         tbm_surface_h acquired_surface = NULL;
 367
 368
 369         for (int i = 0; i < QUEUE_SIZE; i++) {
 370                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 371                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 372                 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
 373                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 374         }
 375
 376         /* test */
 377         for (int i = 0; i < QUEUE_SIZE; i++) {
 378                 result = tbm_surface_queue_acquire(queue, &acquired_surface);
 379                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 380                 ASSERT_EQ(surfaces[i], acquired_surface);
 381         }
 382
 383         /* test: acquire empty queue*/
 384         result = tbm_surface_queue_acquire(queue, &acquired_surface);
 385         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 386         ASSERT_EQ(nullptr, acquired_surface);
 387 }
 388
 389 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
 390                 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
 391 TEST_F(SurfaceQueueTest, CancelAcquireFailNull)
 392 {
 393         result = tbm_surface_queue_dequeue(queue, &surface);
 394         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 395         result = tbm_surface_queue_enqueue(queue, surface);
 396
 397         /* test */
 398         result = tbm_surface_queue_cancel_acquire(NULL, surface);
 399         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 400
 401         result = tbm_surface_queue_cancel_acquire(queue, NULL);
 402         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 403 }
 404
 405 TEST_F(SurfaceQueueTest, CancelAcquireFailInvaildInput)
 406 {
 407         result = tbm_surface_queue_dequeue(queue, &surface);
 408         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 409         result = tbm_surface_queue_enqueue(queue, surface);
 410         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 411
 412         /* test */
 413         result = tbm_surface_queue_cancel_acquire(invalid_queue, surface);
 414         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 415
 416         result = tbm_surface_queue_cancel_acquire(queue, invalid_surface);
 417         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 418
 419         result = tbm_surface_queue_cancel_acquire(queue, alien_surface);
 420         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 421 }
 422
 423 TEST_F(SurfaceQueueTest, CancelAcquireSuccess)
 424 {
 425         tbm_surface_h last_surface = NULL;
 426
 427         for (int i = 0; i < QUEUE_SIZE; i++) {
 428                 result = tbm_surface_queue_dequeue(queue, &surface);
 429                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 430                 result = tbm_surface_queue_enqueue(queue, surface);
 431                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 432         }
 433
 434         for (int i = 0; i < QUEUE_SIZE; i++) {
 435                 result = tbm_surface_queue_acquire(queue, &surface);
 436                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 437         }
 438
 439         last_surface = surface;
 440         result = tbm_surface_queue_acquire(queue, &surface);
 441         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 442         ASSERT_EQ(nullptr, surface);
 443
 444         /* test */
 445         result = tbm_surface_queue_cancel_acquire(queue, last_surface);
 446         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 447
 448         /* extra check */
 449         result = tbm_surface_queue_acquire(queue, &surface);
 450         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 451         ASSERT_EQ(last_surface, surface);
 452 }
 453
 454 /* tbm_surface_queue_error_e tbm_surface_queue_release(
 455                 tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
 456 TEST_F(SurfaceQueueTest, ReleaseFailNull)
 457 {
 458         result = tbm_surface_queue_dequeue(queue, &surface);
 459         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 460         result = tbm_surface_queue_enqueue(queue, surface);
 461         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 462         result = tbm_surface_queue_acquire(queue, &surface);
 463         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 464
 465         /* test */
 466         result = tbm_surface_queue_release(NULL, surface);
 467         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 468
 469         result = tbm_surface_queue_release(this->queue, NULL);
 470         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 471 }
 472
 473 TEST_F(SurfaceQueueTest, ReleaseFailInvaildInput)
 474 {
 475         result = tbm_surface_queue_dequeue(queue, &surface);
 476         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 477         result = tbm_surface_queue_enqueue(queue, surface);
 478         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 479         result = tbm_surface_queue_acquire(queue, &surface);
 480         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 481
 482         /* test */
 483         result = tbm_surface_queue_release(invalid_queue, surface);
 484         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 485
 486         result = tbm_surface_queue_release(queue, invalid_surface);
 487         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 488
 489         result = tbm_surface_queue_release(queue, alien_surface);
 490         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 491 }
 492
 493 TEST_F(SurfaceQueueTest, ReleaseSuccess)
 494 {
 495         tbm_surface_h surfaces[QUEUE_SIZE] = { NULL };
 496
 497         for (int i = 0; i < QUEUE_SIZE; i++) {
 498                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 499                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 500                 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
 501                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 502                 result = tbm_surface_queue_acquire(queue, &surfaces[i]);
 503                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 504         }
 505
 506         /* test */
 507         for (int i = 0; i < QUEUE_SIZE; i++) {
 508                 result = tbm_surface_queue_release(queue, surfaces[i]);
 509                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 510         }
 511 }
 512
 513 TEST_F(SurfaceQueueTest, ReleaseSequenceSuccess)
 514 {
 515         tbm_surface_h surfaces[QUEUE_SIZE] = { NULL };
 516
 517         /* create a sequence queue instead of a default one*/
 518         tbm_surface_queue_destroy(queue);
 519         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
 520         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 521
 522         for (int i = 0; i < QUEUE_SIZE; i++) {
 523                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 524                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 525                 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
 526                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 527                 result = tbm_surface_queue_acquire(queue, &surfaces[i]);
 528                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 529         }
 530
 531         /* test */
 532         for (int i = 0; i < QUEUE_SIZE; i++) {
 533                 result = tbm_surface_queue_release(queue, surfaces[i]);
 534                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 535         }
 536 }
 537
 538 TEST_F(SurfaceQueueTest, ReleaseFailTwice)
 539 {
 540         result = tbm_surface_queue_dequeue(queue, &surface);
 541         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 542         result = tbm_surface_queue_enqueue(queue, surface);
 543         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 544         result = tbm_surface_queue_acquire(queue, &surface);
 545         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 546
 547         /* test */
 548         result = tbm_surface_queue_release(queue, surface);
 549         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 550
 551         result = tbm_surface_queue_release(queue, surface);
 552         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 553 }
 554
 555 /* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
 556 TEST_F(SurfaceQueueTest, GetWidthFailNull)
 557 {
 558         int width = tbm_surface_queue_get_width(NULL);
 559         ASSERT_EQ(0, width);
 560 }
 561
 562 TEST_F(SurfaceQueueTest, GetWidthFailInvalidInput)
 563 {
 564         int width = tbm_surface_queue_get_width(invalid_queue);
 565         ASSERT_EQ(0, width);
 566 }
 567
 568 TEST_F(SurfaceQueueTest, GetWidthSuccess)
 569 {
 570         int width = tbm_surface_queue_get_width(queue);
 571         ASSERT_EQ(this->width, width);
 572 }
 573
 574 /* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
 575 TEST_F(SurfaceQueueTest, GetHeightFailNull)
 576 {
 577         int height = tbm_surface_queue_get_height(NULL);
 578         ASSERT_EQ(0, height);
 579 }
 580
 581 TEST_F(SurfaceQueueTest, GetHeightFailInvalidInput)
 582 {
 583         int height = tbm_surface_queue_get_height(invalid_queue);
 584         ASSERT_EQ(0, height);
 585 }
 586
 587 TEST_F(SurfaceQueueTest, GetHeightSuccess)
 588 {
 589         int height = tbm_surface_queue_get_height(queue);
 590         ASSERT_EQ(this->height, height);
 591 }
 592
 593 /* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
 594 TEST_F(SurfaceQueueTest, GetFormatFailNull)
 595 {
 596         int format = tbm_surface_queue_get_format(NULL);
 597         ASSERT_EQ(0, format);
 598 }
 599
 600 TEST_F(SurfaceQueueTest, GetFormatFailInvalidInput)
 601 {
 602         int format = tbm_surface_queue_get_format(invalid_queue);
 603         ASSERT_EQ(0, format);
 604 }
 605
 606 TEST_F(SurfaceQueueTest, GetFormatSuccess)
 607 {
 608         int format = tbm_surface_queue_get_format(queue);
 609         ASSERT_EQ((int)this->format, format);
 610 }
 611
 612 /* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
 613 TEST_F(SurfaceQueueTest, GetSizeFailNull)
 614 {
 615         int q_size = tbm_surface_queue_get_size(NULL);
 616         ASSERT_EQ(0, q_size);
 617 }
 618
 619 TEST_F(SurfaceQueueTest, GetSizeFailInvalidInput)
 620 {
 621         int q_size = tbm_surface_queue_get_size(invalid_queue);
 622         ASSERT_EQ(0, q_size);
 623 }
 624
 625 TEST_F(SurfaceQueueTest, GetSizeSuccess)
 626 {
 627         int q_size = tbm_surface_queue_get_size(queue);
 628         ASSERT_EQ(QUEUE_SIZE,  q_size);
 629 }
 630
 631 /* tbm_surface_queue_error_e tbm_surface_queue_reset(
 632                 tbm_surface_queue_h surface_queue, int width, int height, int format); */
 633 TEST_F(SurfaceQueueTest, ResetFailNull)
 634 {
 635         result = tbm_surface_queue_reset(NULL, width, height, format);
 636         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 637 }
 638
 639 TEST_F(SurfaceQueueTest, ResetFailInvalidInput)
 640 {
 641         result = tbm_surface_queue_reset(invalid_queue, width, height, format);
 642         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 643
 644         result = tbm_surface_queue_reset(invalid_queue, -1, height, format);
 645         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 646
 647         result = tbm_surface_queue_reset(invalid_queue, width, -1, format);
 648         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 649
 650         result = tbm_surface_queue_reset(invalid_queue, width, height, 0);
 651         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 652 }
 653
 654 TEST_F(SurfaceQueueTest, ResetSuccessEmptyQueue)
 655 {
 656         result = tbm_surface_queue_reset(queue, width-10, height-10, format);
 657         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 658 }
 659
 660 TEST_F(SurfaceQueueTest, ResetSuccessSameParams)
 661 {
 662         tbm_surface_h surface = NULL;
 663
 664
 665         result = tbm_surface_queue_dequeue(queue, &surface);
 666         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 667
 668         /* test */
 669         result = tbm_surface_queue_reset(queue, width, height, format);
 670         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 671
 672         /* extra check */
 673         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 674 }
 675
 676 TEST_F(SurfaceQueueTest, ResetSuccess)
 677 {
 678         tbm_surface_h surface = NULL;
 679
 680
 681         result = tbm_surface_queue_dequeue(queue, &surface);
 682         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 683
 684         /* test */
 685         result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
 686         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 687
 688         /* extra check */
 689         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 690 }
 691
 692 TEST_F(SurfaceQueueTest, ResetSequenceSuccess)
 693 {
 694         tbm_surface_h surface = NULL;
 695
 696         /* create a sequence queue instead of a default one*/
 697         tbm_surface_queue_destroy(queue);
 698         queue = tbm_surface_queue_sequence_create(QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
 699         ASSERT_TRUE(queue != NULL);
 700
 701         result = tbm_surface_queue_dequeue(queue, &surface);
 702         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 703
 704         /* test */
 705         result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
 706         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 707
 708         /* extra check */
 709         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 710 }
 711
 712 /* tbm_surface_queue_error_e tbm_surface_queue_set_size(
 713                 tbm_surface_queue_h surface_queue, int QUEUE_SIZE, int flush); */
 714 TEST_F(SurfaceQueueTest, SetSizeFailNull)
 715 {
 716         result = tbm_surface_queue_set_size(NULL, QUEUE_SIZE, 0);
 717         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 718 }
 719
 720 TEST_F(SurfaceQueueTest, SetSizeFailInvalidInput)
 721 {
 722         result = tbm_surface_queue_set_size(invalid_queue, QUEUE_SIZE, 0);
 723         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 724
 725         result = tbm_surface_queue_set_size(NULL, 0, 0);
 726         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 727 }
 728
 729 TEST_F(SurfaceQueueTest, SetSizeSuccessTheSameSize)
 730 {
 731         tbm_surface_h surface = NULL;
 732
 733         result = tbm_surface_queue_dequeue(queue, &surface);
 734         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 735
 736         /*test: */
 737         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE, 0);
 738         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 739         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 740
 741         /*test: with flush*/
 742         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE, 1);
 743         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 744         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 745 }
 746
 747 TEST_F(SurfaceQueueTest, SetSizeSuccessIncrease)
 748 {
 749         tbm_surface_h surface = NULL;
 750
 751         result = tbm_surface_queue_dequeue(queue, &surface);
 752         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 753
 754         /*test: */
 755         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE+1, 0);
 756         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 757         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 758
 759         /*test: with flush*/
 760         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE+2, 1);
 761         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 762         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 763 }
 764
 765 TEST_F(SurfaceQueueTest, SetSizeSuccessReduce)
 766 {
 767         tbm_surface_h surface = NULL;
 768
 769         result = tbm_surface_queue_dequeue(queue, &surface);
 770         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 771
 772         /*test: */
 773         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE-1, 0);
 774         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 775         ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 776
 777         /*test: with flush*/
 778         result = tbm_surface_queue_set_size(queue, QUEUE_SIZE-2, 1);
 779         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 780         ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 781 }
 782
 783 /* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */
 784 TEST_F(SurfaceQueueTest, FlushFailNull)
 785 {
 786         result = tbm_surface_queue_flush(NULL);
 787         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 788 }
 789
 790 TEST_F(SurfaceQueueTest, FlushFailInvalidInput)
 791 {
 792         result = tbm_surface_queue_flush(invalid_queue);
 793         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 794 }
 795
 796 TEST_F(SurfaceQueueTest, FlushSuccess)
 797 {
 798         tbm_surface_h surfaces[QUEUE_SIZE];
 799
 800         /*test: flushing not initialized queue*/
 801         result = tbm_surface_queue_flush(queue);
 802         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 803
 804
 805         for (int i = 0; i < QUEUE_SIZE; i++) {
 806                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 807                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 808                 result = tbm_surface_queue_enqueue(queue, surfaces[i]);
 809                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 810         }
 811
 812         /* test */
 813         result = tbm_surface_queue_flush(queue);
 814         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 815
 816         /* extra check */
 817         for (int i = 0; i < QUEUE_SIZE; i++)
 818                 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 819 }
 820
 821 /* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */
 822 TEST_F(SurfaceQueueTest, FreeFlushFailNull)
 823 {
 824         result = tbm_surface_queue_free_flush(NULL);
 825         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 826 }
 827
 828 TEST_F(SurfaceQueueTest, FreeFlushFailInvalidInput)
 829 {
 830         result = tbm_surface_queue_free_flush(invalid_queue);
 831         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 832 }
 833
 834 TEST_F(SurfaceQueueTest, FreeFlushSuccess)
 835 {
 836         tbm_surface_h surfaces[QUEUE_SIZE];
 837
 838         /*test: flushing not initialized queue*/
 839         result = tbm_surface_queue_free_flush(queue);
 840         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 841
 842
 843         /* init queue */
 844         for (int i = 0; i < QUEUE_SIZE; i++) {
 845                 result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
 846                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 847                 result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
 848                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 849         }
 850
 851         /* test */
 852         result = tbm_surface_queue_free_flush(queue);
 853         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 854
 855         /* extra check */
 856         for (int i = 0; i < QUEUE_SIZE; i++)
 857                 ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 858 }
 859
 860 /* tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb(
 861         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
 862 TEST_F(SurfaceQueueTest, AddResetCbFailNull)
 863 {
 864         result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
 865         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 866
 867         result = tbm_surface_queue_add_reset_cb(queue, NULL, &cb_data);
 868         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 869 }
 870
 871 TEST_F(SurfaceQueueTest, AddResetCbFailInvalidInput)
 872 {
 873         result = tbm_surface_queue_add_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
 874         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 875 }
 876
 877 TEST_F(SurfaceQueueTest, AddResetCbSuccess)
 878 {
 879         result = tbm_surface_queue_dequeue(queue, &surface);
 880         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 881         result = tbm_surface_queue_enqueue(queue, surface);
 882         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 883
 884         /* test */
 885         result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
 886         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 887
 888         /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
 889         cb_data = 0;
 890         result = tbm_surface_queue_flush(queue);
 891         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 892         ASSERT_TRUE(cb_data == 1);
 893 }
 894
 895 /* tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb(
 896         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
 897 TEST_F(SurfaceQueueTest, RemoveResetCbFailNull)
 898 {
 899         result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
 900         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 901 }
 902
 903 TEST_F(SurfaceQueueTest, RemoveResetCbSuccess)
 904 {
 905         result = tbm_surface_queue_dequeue(queue, &surface);
 906         result = tbm_surface_queue_enqueue(queue, surface);
 907         result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
 908
 909         /* test */
 910         result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
 911         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 912
 913         /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
 914         cb_data = 0;
 915         result = tbm_surface_queue_flush(queue);
 916         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 917         ASSERT_TRUE(cb_data == 0);
 918 }
 919
 920 TEST_F(SurfaceQueueTest, RemoveResetCbFailInvalidInput)
 921 {
 922         result = tbm_surface_queue_dequeue(queue, &surface);
 923         result = tbm_surface_queue_enqueue(queue, surface);
 924         result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
 925
 926         /* test: invalid queue*/
 927         result = tbm_surface_queue_remove_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
 928         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 929
 930         /* test: invalid data */
 931         result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, NULL);
 932         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 933
 934         /* test: invalid cb function */
 935         result = tbm_surface_queue_remove_reset_cb(queue, (tbm_surface_queue_notify_cb)1, &cb_data);
 936         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 937
 938         /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
 939         cb_data = 0;
 940         result = tbm_surface_queue_flush(queue);
 941         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 942         ASSERT_TRUE(cb_data == 1);
 943 }
 944
 945 /* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */
 946 TEST_F(SurfaceQueueTest, NotifyResetFailNull)
 947 {
 948         result = tbm_surface_queue_notify_reset(NULL);
 949         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 950 }
 951
 952 TEST_F(SurfaceQueueTest, NotifyResetFailInvalidInput)
 953 {
 954         result = tbm_surface_queue_notify_reset(invalid_queue);
 955         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 956 }
 957
 958 TEST_F(SurfaceQueueTest, NotifyResetCbSuccess)
 959 {
 960         result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
 961         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 962
 963         /* test */
 964         cb_data = 0;
 965         result = tbm_surface_queue_notify_reset(queue);
 966         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 967         ASSERT_TRUE(cb_data == 1);
 968 }
 969
 970 /* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */
 971 TEST_F(SurfaceQueueTest, CanDequeueFailNull)
 972 {
 973         ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0));
 974 }
 975
 976 TEST_F(SurfaceQueueTest, CanDequeueFailInvalidInput)
 977 {
 978         ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0));
 979 }
 980
 981 TEST_F(SurfaceQueueTest, CanDequeueSuccess)
 982 {
 983         int dq_count = 0;
 984
 985         /* test: dequeue all*/
 986         while (tbm_surface_queue_can_dequeue(queue, 0)) {
 987                 result = tbm_surface_queue_dequeue(queue, &surface);
 988                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
 989                 dq_count++;
 990         }
 991         ASSERT_EQ(QUEUE_SIZE, dq_count);
 992 }
 993
 994 TEST_F(SurfaceQueueTest, CanDequeueFailEmptyQueue)
 995 {
 996         /*Dequeue all*/
 997         while (tbm_surface_queue_can_dequeue(queue, 0)) {
 998                 result = tbm_surface_queue_dequeue(queue, &surface);
 999                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1000         }
1001
1002         /* test */
1003         ASSERT_FALSE(tbm_surface_queue_can_dequeue(queue, 0));
1004 }
1005
1006
1007 /* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */
1008 TEST_F(SurfaceQueueTest, CanAcquireFailNull)
1009 {
1010         ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0));
1011 }
1012
1013 TEST_F(SurfaceQueueTest, CanAcquireFailInvalidInput)
1014 {
1015         ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0));
1016 }
1017
1018 TEST_F(SurfaceQueueTest, CanAcquireFailEmptyQueue)
1019 {
1020         ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0));
1021 }
1022
1023 TEST_F(SurfaceQueueTest, CanAcquireSuccess)
1024 {
1025         int acq_count = 0;
1026
1027         while (tbm_surface_queue_can_dequeue(queue, 0)) {
1028                 result = tbm_surface_queue_dequeue(queue, &surface);
1029                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1030                 result = tbm_surface_queue_enqueue(queue, surface);
1031         }
1032
1033         /*Dequeue all*/
1034         while (tbm_surface_queue_can_acquire(queue, 0)) {
1035                 result = tbm_surface_queue_acquire(queue, &surface);
1036                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1037                 acq_count++;
1038         }
1039
1040         ASSERT_EQ(QUEUE_SIZE, acq_count);
1041 }
1042
1043 /* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
1044         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
1045 TEST_F(SurfaceQueueTest, AddDestroyCbFailNull)
1046 {
1047         result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1048         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1049
1050         result = tbm_surface_queue_add_destroy_cb(queue, NULL, &cb_data);
1051         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1052 }
1053
1054 TEST_F(SurfaceQueueTest, AddDestroyCbFailInvalidInput)
1055 {
1056         result = tbm_surface_queue_add_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1057         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1058 }
1059
1060 TEST_F(SurfaceQueueTest, AddDestroyCbSuccess)
1061 {
1062         /* test */
1063         result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1064         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1065
1066         cb_data = 0;
1067         tbm_surface_queue_destroy(queue);
1068         ASSERT_TRUE(cb_data == 1);
1069
1070         /* to avoid destroying queue in TearDown*/
1071         queue = NULL;
1072 }
1073
1074 /* tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
1075         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
1076 TEST_F(SurfaceQueueTest, RemoveDestroyCbFailNull)
1077 {
1078         result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1079         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1080 }
1081
1082 TEST_F(SurfaceQueueTest, RemoveDestroyCbFailInvalidInput)
1083 {
1084         result = tbm_surface_queue_remove_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1085         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1086 }
1087
1088 TEST_F(SurfaceQueueTest, RemoveDestroyCbSuccess)
1089 {
1090         result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1091         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1092         result = tbm_surface_queue_remove_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1093         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1094
1095         cb_data = 0;
1096         tbm_surface_queue_destroy(queue);
1097         ASSERT_TRUE(cb_data == 0);
1098
1099         /* to avoid destroying queue in TearDown*/
1100         queue = NULL;
1101 }
1102
1103 /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb(
1104         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
1105 TEST_F(SurfaceQueueTest, AddDequeuableCbFailNull)
1106 {
1107         result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1108         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1109
1110         result = tbm_surface_queue_add_dequeuable_cb(queue, NULL, &cb_data);
1111         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1112 }
1113
1114 TEST_F(SurfaceQueueTest, AddDequeuableCbFailInvalidInput)
1115 {
1116         result = tbm_surface_queue_add_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1117         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1118 }
1119
1120 TEST_F(SurfaceQueueTest, AddDequeuableCbSuccess)
1121 {
1122         result = tbm_surface_queue_dequeue(queue, &surface);
1123         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1124         result = tbm_surface_queue_enqueue(queue, surface);
1125         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1126         result = tbm_surface_queue_acquire(queue, &surface);
1127         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1128
1129         /* test */
1130         result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1131         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1132
1133         cb_data = 0;
1134         result = tbm_surface_queue_release(queue, surface);
1135         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1136         ASSERT_TRUE(cb_data == 1);
1137 }
1138
1139
1140 /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb(
1141         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
1142 TEST_F(SurfaceQueueTest, RemoveDequeuableCbFailNull)
1143 {
1144         result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1145         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1146 }
1147
1148 TEST_F(SurfaceQueueTest, RemoveDequeuableCbFailInvalidInput)
1149 {
1150         /* test: invalid queue */
1151         result = tbm_surface_queue_remove_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1152         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1153 }
1154
1155 TEST_F(SurfaceQueueTest, RemoveDequeuableCbSuccess)
1156 {
1157         result = tbm_surface_queue_dequeue(queue, &surface);
1158         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1159         result = tbm_surface_queue_enqueue(queue, surface);
1160         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1161         result = tbm_surface_queue_acquire(queue, &surface);
1162         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1163         result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1164         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1165
1166         /* test */
1167         result = tbm_surface_queue_remove_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1168         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1169
1170         cb_data = 0;
1171         result = tbm_surface_queue_release(queue, surface);
1172         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1173         ASSERT_TRUE(cb_data == 0);
1174 }
1175
1176 /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb(
1177         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
1178 TEST_F(SurfaceQueueTest, AddDequeueCbFailNull)
1179 {
1180         result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1181         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1182
1183         result = tbm_surface_queue_add_dequeue_cb(queue, NULL, &cb_data);
1184         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1185 }
1186
1187 TEST_F(SurfaceQueueTest, AddDequeueCbFailInvalidInput)
1188 {
1189         result = tbm_surface_queue_add_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1190         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1191 }
1192
1193 TEST_F(SurfaceQueueTest, AddDequeueCbSuccess)
1194 {
1195         /* test */
1196         result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1197         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1198
1199         cb_data = 0;
1200         result = tbm_surface_queue_dequeue(queue, &surface);
1201         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1202         ASSERT_TRUE(cb_data == 1);
1203 }
1204
1205 /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb(
1206         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
1207 TEST_F(SurfaceQueueTest, RemoveDequeueCbFailNull)
1208 {
1209         result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1210         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1211 }
1212
1213 TEST_F(SurfaceQueueTest, RemoveDequeueCbFailInvalidInput)
1214 {
1215         /* test: invalid queue */
1216         result = tbm_surface_queue_remove_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1217         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1218 }
1219
1220 TEST_F(SurfaceQueueTest, RemoveDequeueCbSuccess)
1221 {
1222         /* test */
1223         result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1224         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1225
1226         cb_data = 0;
1227         result = tbm_surface_queue_dequeue(queue, &surface);
1228         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1229         ASSERT_TRUE(cb_data == 1);
1230
1231         result = tbm_surface_queue_remove_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1232         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1233
1234         cb_data = 0;
1235         result = tbm_surface_queue_dequeue(queue, &surface);
1236         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1237         ASSERT_TRUE(cb_data == 0);
1238 }
1239
1240 /* tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb(
1241         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
1242 TEST_F(SurfaceQueueTest, AddCanDequeueCbFailNull)
1243 {
1244         result = tbm_surface_queue_add_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1245         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1246
1247         result = tbm_surface_queue_add_can_dequeue_cb(queue, NULL, &cb_data);
1248         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1249 }
1250
1251 TEST_F(SurfaceQueueTest, AddCanDequeueCbFailInvalidInput)
1252 {
1253         result = tbm_surface_queue_add_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1254         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1255 }
1256
1257 TEST_F(SurfaceQueueTest, AddCanDequeueCbSuccess)
1258 {
1259         /* test */
1260         result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1261         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1262
1263         cb_data = 0;
1264         ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1265         ASSERT_TRUE(cb_data == 1);
1266 }
1267
1268 /* tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb(
1269         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
1270 TEST_F(SurfaceQueueTest, RemoveCanDequeueCbFailNull)
1271 {
1272         result = tbm_surface_queue_remove_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1273         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1274 }
1275
1276 TEST_F(SurfaceQueueTest, RemoveCanDequeueCbFailInvalidInput)
1277 {
1278         /* test: invalid queue */
1279         result = tbm_surface_queue_remove_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1280         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1281 }
1282
1283 TEST_F(SurfaceQueueTest, RemoveCanDequeueCbSuccess)
1284 {
1285         result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1286         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1287
1288         /* test */
1289         result = tbm_surface_queue_remove_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1290         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1291
1292         cb_data = 0;
1293         ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
1294         ASSERT_TRUE(cb_data == 0);
1295 }
1296
1297 /* tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
1298         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
1299 TEST_F(SurfaceQueueTest, AddAcquirableCbFailNull)
1300 {
1301         result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1302         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1303
1304         result = tbm_surface_queue_add_acquirable_cb(queue, NULL, &cb_data);
1305         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1306 }
1307
1308 TEST_F(SurfaceQueueTest, AddAcquirableCbFailInvalidInput)
1309 {
1310         result = tbm_surface_queue_add_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1311         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1312 }
1313
1314 TEST_F(SurfaceQueueTest, AddAcquirableCbSuccess)
1315 {
1316         tbm_surface_queue_dequeue(queue, &surface);
1317
1318         /* test */
1319         result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1320         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1321
1322         cb_data = 0;
1323         result = tbm_surface_queue_enqueue(queue, surface);
1324         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1325         ASSERT_TRUE(cb_data == 1);
1326 }
1327
1328 /* tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
1329         tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
1330 TEST_F(SurfaceQueueTest, RemoveAcquirableCbFailNull)
1331 {
1332         result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
1333         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1334 }
1335
1336 TEST_F(SurfaceQueueTest, RemoveAcquirableCbFailInvalidInput)
1337 {
1338         /* test: invalid queue */
1339         result = tbm_surface_queue_remove_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
1340         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1341 }
1342
1343 TEST_F(SurfaceQueueTest, RemoveAcquirableCbSuccess)
1344 {
1345         result = tbm_surface_queue_dequeue(queue, &surface);
1346         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1347         result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1348         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1349
1350         /* test */
1351         result = tbm_surface_queue_remove_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
1352         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1353
1354         cb_data = 0;
1355         result = tbm_surface_queue_enqueue(queue, surface);
1356         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1357         ASSERT_TRUE(cb_data == 0);
1358 }
1359
1360 /* tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb(
1361         tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
1362 TEST_F(SurfaceQueueTest, AddTraceCbFailNull)
1363 {
1364         result = tbm_surface_queue_add_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1365         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1366
1367         result = tbm_surface_queue_add_trace_cb(queue, NULL, &trace_cb_data);
1368         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1369 }
1370
1371 TEST_F(SurfaceQueueTest, AddTraceCbFailInvalidInput)
1372 {
1373         result = tbm_surface_queue_add_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1374         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1375 }
1376
1377 TEST_F(SurfaceQueueTest, AddTraceCbSuccess)
1378 {
1379         trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1380
1381         /* test */
1382         result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1383         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1384
1385         result = tbm_surface_queue_dequeue(queue, &surface);
1386         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1387         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
1388
1389         result = tbm_surface_queue_cancel_dequeue(queue, surface);
1390         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1391         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE);
1392
1393         result = tbm_surface_queue_dequeue(queue, &surface);
1394         result = tbm_surface_queue_enqueue(queue, surface);
1395         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1396         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
1397
1398         result = tbm_surface_queue_acquire(queue, &surface);
1399         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1400         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
1401
1402         result = tbm_surface_queue_cancel_acquire(queue, surface);
1403         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1404         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE);
1405
1406         result = tbm_surface_queue_acquire(queue, &surface);
1407         result = tbm_surface_queue_release(queue, surface);
1408         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1409         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_RELEASE);
1410 }
1411
1412 /* tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb(
1413         tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
1414 TEST_F(SurfaceQueueTest, RemoveTraceCbFailNull)
1415 {
1416         result = tbm_surface_queue_remove_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1417         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1418 }
1419
1420 TEST_F(SurfaceQueueTest, RemoveTraceCbFailInvalidInput)
1421 {
1422         /* test: invalid queue */
1423         result = tbm_surface_queue_remove_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1424         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1425 }
1426
1427 TEST_F(SurfaceQueueTest, RemoveTraceCbSuccess)
1428 {
1429         trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
1430
1431         result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1432         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1433
1434         /* test */
1435         result = tbm_surface_queue_remove_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
1436         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1437
1438         result = tbm_surface_queue_dequeue(queue, &surface);
1439         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1440         ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_NONE);
1441 }
1442
1443 /* tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb( tbm_surface_queue_h surface_queue,
1444         tbm_surface_alloc_cb alloc_cb,  tbm_surface_free_cb free_cb, void *data); */
1445 TEST_F(SurfaceQueueTest, SetAllocCbFailNull)
1446 {
1447         result = tbm_surface_queue_set_alloc_cb(NULL, tbm_surface_alloc_cb_handler,
1448                         tbm_surface_free_cb_handler, alien_surface);
1449         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1450 }
1451
1452 TEST_F(SurfaceQueueTest, SetAllocCbFailInvalidInput)
1453 {
1454         result = tbm_surface_queue_set_alloc_cb(invalid_queue, tbm_surface_alloc_cb_handler,
1455                         tbm_surface_free_cb_handler, alien_surface);
1456         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1457 }
1458
1459 TEST_F(SurfaceQueueTest, SetAllocCbSuccess)
1460 {
1461         result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler,
1462                         tbm_surface_free_cb_handler, alien_surface);
1463         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1464
1465         /* test: allocate */
1466         result = tbm_surface_queue_dequeue(queue, &surface);
1467         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1468         ASSERT_EQ(alien_surface, surface);
1469
1470         /* test:  alien_surface has to be deleted*/
1471         tbm_surface_queue_destroy(queue);
1472         ASSERT_FALSE(tbm_surface_internal_is_valid(alien_surface));
1473
1474         alien_surface = NULL;
1475 }
1476
1477 /* tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num(
1478                         tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num); */
1479 TEST_F(SurfaceQueueTest, GetTraceSurfaceNumFailNull)
1480 {
1481         int num = 0;
1482
1483         ASSERT_EXIT({
1484
1485                 result = tbm_surface_queue_get_trace_surface_num(NULL, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1486                 ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1487
1488                 result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, NULL);
1489                 ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1490
1491                 exit(0);
1492         }, ::testing::ExitedWithCode(0), "");
1493
1494 }
1495
1496 TEST_F(SurfaceQueueTest, GetTraceSurfaceNumFailInvalidInput)
1497 {
1498         int num = 0;
1499
1500         result = tbm_surface_queue_get_trace_surface_num(invalid_queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1501         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1502 }
1503
1504 TEST_F(SurfaceQueueTest, GetTraceSurfaceNumSuccess)
1505 {
1506         int num = 0;
1507
1508         result = tbm_surface_queue_set_size(queue, 4, 0);
1509
1510         /* one acquired */
1511         result = tbm_surface_queue_dequeue(queue, &surface);
1512         result = tbm_surface_queue_enqueue(queue, surface);
1513         result = tbm_surface_queue_acquire(queue, &surface);
1514
1515         /* one enqueued */
1516         result = tbm_surface_queue_dequeue(queue, &surface);
1517         result = tbm_surface_queue_enqueue(queue, surface);
1518
1519         /* one dequeued */
1520         result = tbm_surface_queue_dequeue(queue, &surface);
1521
1522         /* one released */
1523         result = tbm_surface_queue_dequeue(queue, &surface);
1524         result = tbm_surface_queue_cancel_dequeue(queue, surface);
1525
1526
1527         /* test */
1528         result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
1529         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1530         ASSERT_EQ(0, num);
1531
1532         result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
1533         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1534         ASSERT_EQ(1, num);
1535
1536         result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ENQUEUE, &num);
1537         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1538         ASSERT_EQ(1, num);
1539
1540         result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ACQUIRE, &num);
1541         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1542         ASSERT_EQ(1, num);
1543
1544         result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_RELEASE, &num);
1545         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1546         ASSERT_EQ(1, num);
1547 }
1548 /* tbm_surface_queue_error_e tbm_surface_queue_set_modes(
1549                         tbm_surface_queue_h surface_queue, int modes); */
1550 TEST_F(SurfaceQueueTest, SetModesFailNull)
1551 {
1552         result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1553         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1554 }
1555
1556 TEST_F(SurfaceQueueTest, SetModesFailInvalidInput)
1557 {
1558         result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1559         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1560 }
1561
1562 TEST_F(SurfaceQueueTest, SetModesSuccess)
1563 {
1564         result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
1565         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1566 }
1567
1568 /* tbm_surface_queue_set_sync_count() */
1569 TEST_F(SurfaceQueueTest, SetSyncCountFailNull)
1570 {
1571         result = tbm_surface_queue_set_sync_count(NULL, 1);
1572         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1573 }
1574
1575 TEST_F(SurfaceQueueTest, SetSyncCountFailInvalidInput)
1576 {
1577         result = tbm_surface_queue_set_sync_count(invalid_queue, 1);
1578         ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1579 }
1580
1581 TEST_F(SurfaceQueueTest, SetSyncCountSuccess)
1582 {
1583         result = tbm_surface_queue_dequeue(queue, &surface);
1584         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1585
1586         /* test: map after enqueue */
1587         result = tbm_surface_queue_set_sync_count(queue, 0);
1588         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1589
1590         result = tbm_surface_queue_enqueue(queue, surface);
1591         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1592
1593         /* test: map after acquire */
1594         result = tbm_surface_queue_set_sync_count(queue, 0);
1595         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1596
1597         result = tbm_surface_queue_acquire(queue, &surface);
1598         ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
1599
1600 }