utests/src/ut_tdm_layer.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "gtest/gtest.h"
  32 #include "ut_common.h"
  33 #include <limits.h>
  34 #include <string.h>
  35 #include <sys/epoll.h>
  36 #include <sys/timerfd.h>
  37
  38 #include "tdm.h"
  39 extern "C" {
  40 #include "tbm_bufmgr.h"
  41 #include "tbm_drm_helper.h"
  42 #include "tbm_surface.h"
  43 #include "tbm_surface_queue.h"
  44 }
  45
  46 class TDMLayer : public ::testing::Test {
  47 protected:
  48         tdm_display *dpy = NULL;
  49         tbm_bufmgr tbm_bufmgr = NULL;
  50         int master_fd = -42, tbm_fd = -42, layer_count = 0, output_count = 0;
  51         tdm_layer **tdm_layer_array = NULL;
  52         tbm_surface_h *tdm_layers_buffer_array = NULL;
  53         tbm_surface_queue_h *tdm_layers_buffer_queue_array = NULL;
  54         int *tdm_layer_output_idx = NULL;
  55         const tdm_output_mode **preferred_mode_array = NULL;
  56         bool has_layers = false;
  57         virtual void SetEnv()
  58         {
  59                 setenv("TDM_DEBUG_MODULE", "all", 1);
  60                 setenv("TDM_DEBUG", "1", 1);
  61                 setenv("TDM_THREAD", "0", 1);
  62                 setenv("TDM_COMMIT_PER_VBLANK", "1", 1);
  63                 setenv("TDM_DLOG", "1", 1);
  64                 setenv("XDG_RUNTIME_DIR", ".", 1);
  65                 setenv("TBM_DLOG", "1", 1);
  66                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  67         }
  68         void SetUp(void)
  69         {
  70                 const tdm_output_mode *preferred_mode = NULL;
  71                 tdm_error error = TDM_ERROR_NONE;
  72
  73                 SetEnv();
  74
  75                 /* FIXME: fix the error. If we initialize TBM before TDM we get fail
  76                  * in the tdm_output_set_dpms */
  77 #if 0
  78                 tbm_bufmgr = tbm_bufmgr_init(-1);
  79                 ASSERT_FALSE(tbm_bufmgr == NULL);
  80 #endif
  81
  82                 dpy = tdm_display_init(&error);
  83                 ASSERT_TRUE(error == TDM_ERROR_NONE);
  84                 ASSERT_FALSE(dpy == NULL);
  85
  86                 master_fd = tbm_drm_helper_get_master_fd();
  87                 tbm_fd = tbm_drm_helper_get_fd();
  88                 ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE);
  89
  90                 preferred_mode_array = (const tdm_output_mode **)calloc(output_count, sizeof(tdm_output_mode *));
  91                 ASSERT_FALSE(NULL == preferred_mode_array);
  92                 if (!preferred_mode_array)
  93                         return;
  94
  95                 for (int i = 0; i < output_count; i++) {
  96                         tdm_output *output = tdm_display_get_output(dpy, i, &error);
  97                         int output_modes_cnt = 0;
  98                         const tdm_output_mode *output_modes;
  99
 100                         if (TDM_ERROR_NONE != error || NULL == output)
 101                                 continue;
 102
 103                         tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
 104                         if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
 105                                 continue;
 106
 107                         if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
 108                                 continue;
 109
 110                         error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt);
 111                         if (TDM_ERROR_NONE != error)
 112                                 continue;
 113                         if (output_modes_cnt <= 0) {
 114                                 continue;
 115                         }
 116
 117                         for(int j = 0; j < output_modes_cnt; j++)
 118                                 if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
 119                                         preferred_mode = &output_modes[j];
 120
 121                         if (!preferred_mode)
 122                                 continue;
 123
 124                         int temp_layer_count = 0;
 125                         if (TDM_ERROR_NONE != tdm_output_get_layer_count(output, &temp_layer_count))
 126                                 continue;
 127                         if (0 == temp_layer_count)
 128                                 continue;
 129                         tdm_layer_array = (tdm_layer **) realloc(tdm_layer_array,
 130                                                                                                          (layer_count + temp_layer_count)*sizeof(tdm_layer *));
 131
 132                         ASSERT_FALSE(NULL == tdm_layer_array);
 133
 134                         tdm_layer_output_idx = (int *) realloc(tdm_layer_output_idx,
 135                                                                                         (layer_count + temp_layer_count)*sizeof(int));
 136                         ASSERT_FALSE(NULL == tdm_layer_output_idx);
 137
 138                         for (int k = layer_count; k < (layer_count + temp_layer_count); k++) {
 139                                 tdm_layer_array[k] = tdm_output_get_layer(output, k, &error);
 140                                 tdm_layer_output_idx[k] = i;
 141                                 ASSERT_TRUE(TDM_ERROR_NONE == error);
 142                                 ASSERT_FALSE(NULL == tdm_layer_array[k]);
 143                         }
 144                         layer_count += temp_layer_count;
 145                         preferred_mode_array[i] = preferred_mode;
 146                 }
 147
 148                 tdm_layers_buffer_array = (tbm_surface_h *) calloc(layer_count, sizeof(tbm_surface_h));
 149                 ASSERT_FALSE(NULL == tdm_layers_buffer_array);
 150
 151                 tdm_layers_buffer_queue_array = (tbm_surface_queue_h *) calloc(layer_count, sizeof(tbm_surface_queue_h));
 152                 ASSERT_FALSE(NULL == tdm_layers_buffer_queue_array);
 153
 154 #ifdef FAIL_ON_UNSUPPORTED
 155                 ASSERT_GT(layer_count, 0);
 156 #endif
 157                 if (layer_count > 0)
 158                         has_layers = true;
 159         }
 160         void TearDown(void)
 161         {
 162                 tdm_error error;
 163
 164                 for (int i = 0; i < layer_count; ++i) {
 165                         error = tdm_layer_unset_buffer(tdm_layer_array[i]);
 166                         EXPECT_TRUE(error == TDM_ERROR_NONE);
 167
 168                         if (tdm_layers_buffer_array[i])
 169                                 tbm_surface_destroy(tdm_layers_buffer_array[i]);
 170
 171                         if (tdm_layers_buffer_queue_array[i])
 172                                 tbm_surface_queue_destroy(tdm_layers_buffer_queue_array[i]);
 173
 174                         tdm_layers_buffer_array[i] = NULL;
 175                         tdm_layers_buffer_queue_array[i] = NULL;
 176                 }
 177
 178                 tdm_display_deinit(dpy);
 179                 dpy = NULL;
 180                 tbm_bufmgr_deinit(tbm_bufmgr);
 181                 tbm_bufmgr = NULL;
 182                 if (tdm_layer_array)
 183                         free(tdm_layer_array);
 184                 if (tdm_layer_output_idx)
 185                         free(tdm_layer_output_idx);
 186                 if (preferred_mode_array)
 187                         free(preferred_mode_array);
 188                 if (master_fd > -1) {
 189                         int temp_master_fd = tbm_drm_helper_get_master_fd();
 190                         EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
 191                         if (temp_master_fd > -1)
 192                                 exit(1);
 193                         close(master_fd);
 194                 }
 195                 if (tbm_fd > -1) {
 196                         int temp_tbm_fd = tbm_drm_helper_get_fd();
 197                         EXPECT_EQ(temp_tbm_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
 198                         if (temp_tbm_fd > -1)
 199                                 exit(1);
 200                         close(tbm_fd);
 201                 }
 202
 203                 unsetenv("TDM_DEBUG_MODULE");
 204                 unsetenv("TDM_DEBUG");
 205                 unsetenv("TDM_THREAD");
 206                 unsetenv("TDM_COMMIT_PER_VBLANK");
 207                 unsetenv("TDM_DLOG");
 208                 unsetenv("XDG_RUNTIME_DIR");
 209                 unsetenv("TBM_DLOG");
 210                 unsetenv("TBM_DISPLAY_SERVER");
 211         }
 212
 213         tbm_surface_h UtCreateBufferForLayer(int layer_idx, int width, int height,
 214                                                                                  int format, int flags)
 215         {
 216                 tbm_surface_h buffer;
 217
 218                 buffer = tbm_surface_internal_create_with_flags(width, height, format, flags);
 219
 220                 tdm_layers_buffer_array[layer_idx] = buffer;
 221
 222                 return buffer;
 223         }
 224
 225         tbm_surface_queue_h UtCreateBufferQueueForLayer(int layer_idx, int width, int height,
 226                                                                                  int format, int flags)
 227         {
 228                 tbm_surface_queue_h buffer_queue;
 229
 230                 buffer_queue = tbm_surface_queue_create(2, width, height, format, flags);
 231
 232                 tdm_layers_buffer_queue_array[layer_idx] = buffer_queue;
 233
 234                 return buffer_queue;
 235         }
 236 };
 237
 238 class TDMLayerCommit : public TDMLayer
 239 {
 240 private:
 241         int epFd = -1;
 242         int timerFd = -1;
 243         int tdmFd = -1;
 244         static const int timeLimitSec = 0;
 245         static const int timeLimitNsec = 100000000;
 246
 247 protected:
 248         static int utLayerCommitHandlerCounter;
 249         static void UtLayerCommitHandler(tdm_layer *layer, unsigned int sequence,
 250                                                                          unsigned int tv_sec, unsigned int tv_usec,
 251                                                                          void *user_data)
 252         {
 253                 int *data = (int *)user_data;
 254                 if (data)
 255                         (*data)++;
 256
 257                 utLayerCommitHandlerCounter++;
 258         }
 259
 260         void SetUp(void)
 261         {
 262                 tdm_error error;
 263                 tdm_output *output;
 264                 struct epoll_event ep;
 265
 266                 utLayerCommitHandlerCounter = 0;
 267
 268                 ASSERT_NO_FATAL_FAILURE(TDMLayer::SetUp());
 269
 270                 for (int i = 0; i < output_count; ++i) {
 271                         if (!preferred_mode_array[i])
 272                                 continue;
 273
 274                         output = tdm_display_get_output(dpy, i, &error);
 275                         ASSERT_FALSE(output == NULL);
 276                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 277
 278                         error = tdm_output_set_mode(output, preferred_mode_array[i]);
 279                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 280
 281                         error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON);
 282                         ASSERT_TRUE(error == TDM_ERROR_NONE);
 283                 }
 284
 285                 epFd = epoll_create1(0);
 286                 ASSERT_TRUE(epFd != -1);
 287
 288                 timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
 289                 ASSERT_TRUE(timerFd != -1);
 290
 291                 memset(&ep, 0, sizeof ep);
 292                 ep.events |= EPOLLIN;
 293                 ep.data.fd = timerFd;
 294                 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
 295
 296                 ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
 297
 298                 memset(&ep, 0, sizeof ep);
 299                 ep.events |= EPOLLIN;
 300                 ep.data.fd = tdmFd;
 301                 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
 302         }
 303
 304         void TearDown(void)
 305         {
 306                 tdm_output *output;
 307                 tdm_error error;
 308
 309                 for (int i = 0; i < output_count; ++i) {
 310                         if (!preferred_mode_array[i])
 311                                 continue;
 312
 313                         output = tdm_display_get_output(dpy, i, &error);
 314                         EXPECT_FALSE(output == NULL);
 315                         EXPECT_TRUE(error == TDM_ERROR_NONE);
 316
 317                         error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF);
 318                         EXPECT_TRUE(error == TDM_ERROR_NONE);
 319                 }
 320
 321                 TDMLayer::TearDown();
 322         }
 323
 324         void UtHandleCommitEvent(int num_waiting_layers)
 325         {
 326                 struct itimerspec its;
 327                 int count;
 328                 struct epoll_event ep_event[2];
 329
 330                 if (utLayerCommitHandlerCounter == num_waiting_layers)
 331                         return;
 332
 333                 its.it_interval.tv_sec = 0;
 334                 its.it_interval.tv_nsec = 0;
 335                 its.it_value.tv_sec = timeLimitSec;
 336                 its.it_value.tv_nsec = timeLimitNsec;
 337
 338                 ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
 339
 340                 while (1) {
 341                         count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
 342                         ASSERT_TRUE(count >= 0);
 343
 344                         for (int i = 0; i < count; i++) {
 345                                 if (ep_event[i].data.fd == timerFd) {
 346                                         return;
 347                                 } else {
 348                                         ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
 349                                         if (utLayerCommitHandlerCounter == num_waiting_layers)
 350                                                 return;
 351                                 }
 352                         }
 353                 }
 354         }
 355 };
 356
 357 class TDMLayerCommitThread : public TDMLayerCommit
 358 {
 359 protected:
 360         void SetEnv()
 361         {
 362                 setenv("TDM_DEBUG_MODULE", "all", 1);
 363                 setenv("TDM_DEBUG", "1", 1);
 364                 setenv("TDM_THREAD", "1", 1);
 365                 setenv("TDM_COMMIT_PER_VBLANK", "1", 1);
 366                 setenv("TDM_DLOG", "1", 1);
 367                 setenv("XDG_RUNTIME_DIR", ".", 1);
 368                 setenv("TBM_DLOG", "1", 1);
 369                 setenv("TBM_DISPLAY_SERVER", "1", 1);
 370         }
 371 };
 372
 373 class TDMLayerCommitWithDisabledCommitPerVblank : public TDMLayerCommit
 374 {
 375 protected:
 376         void SetEnv()
 377         {
 378                 setenv("TDM_DEBUG_MODULE", "all", 1);
 379                 setenv("TDM_DEBUG", "1", 1);
 380                 setenv("TDM_THREAD", "0", 1);
 381                 setenv("TDM_COMMIT_PER_VBLANK", "0", 1);
 382                 setenv("TDM_DLOG", "1", 1);
 383                 setenv("XDG_RUNTIME_DIR", ".", 1);
 384                 setenv("TBM_DLOG", "1", 1);
 385                 setenv("TBM_DISPLAY_SERVER", "1", 1);
 386         }
 387 };
 388
 389 int TDMLayerCommit::utLayerCommitHandlerCounter = 0;
 390
 391 TEST_F(TDMLayer, LayerGetCapabilitiesSuccessful)
 392 {
 393         SKIP_FLAG(has_layers);
 394         for (int i = 0; i < layer_count; i++) {
 395                 tdm_layer_capability capabilities = (tdm_layer_capability) -42;
 396                 ASSERT_TRUE(TDM_ERROR_NONE == tdm_layer_get_capabilities(tdm_layer_array[i], &capabilities));
 397                 ASSERT_NE(capabilities, -42);
 398         }
 399 }
 400
 401 TEST_F(TDMLayer, LayerGetCapabilitiesFailNullAll)
 402 {
 403         SKIP_FLAG(has_layers);
 404         ASSERT_EXIT({if (tdm_layer_get_capabilities(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 405                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 406 }
 407
 408 TEST_F(TDMLayer, LayerGetCapabilitiesFailOnlyLayer)
 409 {
 410         SKIP_FLAG(has_layers);
 411         ASSERT_EXIT({for (int i = 0; i < layer_count; i++) {
 412                                          if (tdm_layer_get_capabilities(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
 413                                 }
 414                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 415 }
 416
 417 TEST_F(TDMLayer, OutputGetPrimaryIndexSuccessful)
 418 {
 419         SKIP_FLAG(has_layers);
 420         for (int i = 0; i < output_count; i++) {
 421                 tdm_error error = TDM_ERROR_NONE;
 422                 int index = -42;
 423                 tdm_output * output = tdm_display_get_output(dpy, i, &error);
 424                 ASSERT_FALSE(NULL == output);
 425                 ASSERT_TRUE(TDM_ERROR_NONE == error);
 426                 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_primary_index(output, &index));
 427                 ASSERT_NE(index, -42);
 428         }
 429 }
 430
 431 TEST_F(TDMLayer, OutputGetPrimaryIndexFailNullAll)
 432 {
 433         SKIP_FLAG(has_layers);
 434         ASSERT_EXIT({if (tdm_output_get_primary_index(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 435                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 436 }
 437
 438 TEST_F(TDMLayer, OutputGetPrimaryIndexFailOnlyOutput)
 439 {
 440         SKIP_FLAG(has_layers);
 441         ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
 442                                          tdm_error error = TDM_ERROR_NONE;
 443                                          tdm_output * output = tdm_display_get_output(dpy, i, &error);
 444                                          if (NULL == output) exit(1);
 445                                          if (TDM_ERROR_NONE != error) exit(1);
 446                                          if (tdm_output_get_primary_index(output, NULL) == TDM_ERROR_NONE) exit(1);
 447                                 }
 448                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 449 }
 450
 451 /* tdm_layer_get_available_formats() */
 452
 453 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullAll)
 454 {
 455         SKIP_FLAG(has_layers);
 456         ASSERT_EXIT({if (tdm_layer_get_available_formats(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
 457                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 458 }
 459
 460 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullLayer)
 461 {
 462         SKIP_FLAG(has_layers);
 463         ASSERT_EXIT({const tbm_format *formats;
 464                                  int count;
 465                                  if (tdm_layer_get_available_formats(NULL, &formats, &count) == TDM_ERROR_NONE) exit(1);
 466                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 467 }
 468
 469 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullFormats)
 470 {
 471         SKIP_FLAG(has_layers);
 472         ASSERT_EXIT({int count;
 473                                  for (int i = 0; i < layer_count; i++) {
 474                                          if (tdm_layer_get_available_formats(tdm_layer_array[i], NULL, &count) == TDM_ERROR_NONE) exit(1);
 475                                 }
 476                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 477 }
 478
 479 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullCount)
 480 {
 481         SKIP_FLAG(has_layers);
 482         ASSERT_EXIT({const tbm_format *formats;
 483                                  for (int i = 0; i < layer_count; i++) {
 484                                          if (tdm_layer_get_available_formats(tdm_layer_array[i], &formats, NULL) == TDM_ERROR_NONE) exit(1);
 485                                 }
 486                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 487 }
 488
 489 TEST_F(TDMLayer, LayerGetAvailableFormatsSuccess)
 490 {
 491         SKIP_FLAG(has_layers);
 492         tdm_error error;
 493         const tbm_format *formats;
 494         int count;
 495
 496         for (int i = 0; i < layer_count; ++i) {
 497                 error = tdm_layer_get_available_formats(tdm_layer_array[i], &formats, &count);
 498                 ASSERT_EQ(TDM_ERROR_NONE, error);
 499                 ASSERT_NE(NULL, formats);
 500                 ASSERT_NE(0, count);
 501         }
 502 }
 503
 504 /* tdm_layer_get_available_properties() */
 505
 506 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullAll)
 507 {
 508         SKIP_FLAG(has_layers);
 509         ASSERT_EXIT({if (tdm_layer_get_available_properties(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
 510                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 511 }
 512
 513 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullLayer)
 514 {
 515         SKIP_FLAG(has_layers);
 516         ASSERT_EXIT({const tdm_prop *props;
 517                                  int count;
 518                                  if (tdm_layer_get_available_properties(NULL, &props, &count) == TDM_ERROR_NONE) exit(1);
 519                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 520 }
 521
 522 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullFormats)
 523 {
 524         SKIP_FLAG(has_layers);
 525         ASSERT_EXIT({int count;
 526                                  for (int i = 0; i < layer_count; i++) {
 527                                          if (tdm_layer_get_available_properties(tdm_layer_array[i], NULL, &count) == TDM_ERROR_NONE) exit(1);
 528                                 }
 529                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 530 }
 531
 532 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullCount)
 533 {
 534         SKIP_FLAG(has_layers);
 535         ASSERT_EXIT({const tdm_prop *props;
 536                                  for (int i = 0; i < layer_count; i++) {
 537                                          if (tdm_layer_get_available_properties(tdm_layer_array[i], &props, NULL) == TDM_ERROR_NONE) exit(1);
 538                                 }
 539                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 540 }
 541
 542 TEST_F(TDMLayer, LayerGetAvailablePropertiesSuccess)
 543 {
 544         SKIP_FLAG(has_layers);
 545         tdm_error error;
 546         const tdm_prop *props;
 547         int count;
 548
 549         for (int i = 0; i < layer_count; ++i) {
 550                 error = tdm_layer_get_available_properties(tdm_layer_array[i], &props, &count);
 551                 ASSERT_EQ(TDM_ERROR_NONE, error);
 552         }
 553 }
 554
 555 /* tdm_layer_get_zpos() */
 556
 557 TEST_F(TDMLayer, LayerGetZposFailNullAll)
 558 {
 559         SKIP_FLAG(has_layers);
 560         ASSERT_EXIT({if (tdm_layer_get_zpos(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 561                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 562 }
 563
 564 TEST_F(TDMLayer,  LayerGetZposFailNullLayer)
 565 {
 566         SKIP_FLAG(has_layers);
 567         ASSERT_EXIT({int zpos;
 568                                  if (tdm_layer_get_zpos(NULL, &zpos) == TDM_ERROR_NONE) exit(1);
 569                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 570 }
 571
 572 TEST_F(TDMLayer, LayerGetZposFailNullZpos)
 573 {
 574         SKIP_FLAG(has_layers);
 575         ASSERT_EXIT({for (int i = 0; i < layer_count; i++) {
 576                                          if (tdm_layer_get_zpos(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
 577                                 }
 578                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 579 }
 580
 581 TEST_F(TDMLayer, LayerGetZposSuccess)
 582 {
 583         SKIP_FLAG(has_layers);
 584         tdm_error error;
 585
 586         for (int i = 0; i < layer_count; ++i) {
 587                 int zpos = INT_MIN;
 588                 error = tdm_layer_get_zpos(tdm_layer_array[i], &zpos);
 589                 ASSERT_EQ(TDM_ERROR_NONE, error);
 590                 ASSERT_NE(INT_MIN, zpos);
 591         }
 592 }
 593
 594 /* tdm_layer_set_property() */
 595
 596 TEST_F(TDMLayer,  LayerSetPropertyFailNullLayer)
 597 {
 598         SKIP_FLAG(has_layers);
 599         ASSERT_EXIT({tdm_value value;
 600                                  int id = INT_MAX;
 601                                  if (tdm_layer_set_property(NULL, id, value) == TDM_ERROR_NONE) exit(1);
 602                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 603 }
 604
 605 TEST_F(TDMLayer,  LayerSetPropertyFailWrongId)
 606 {
 607         SKIP_FLAG(has_layers);
 608         tdm_error error;
 609         tdm_value value;
 610         int id = INT_MAX;
 611
 612         for (int i = 0; i < layer_count; ++i) {
 613                 error = tdm_layer_set_property(tdm_layer_array[i], id, value);
 614                 ASSERT_NE(TDM_ERROR_NONE, error);
 615         }
 616 }
 617
 618 /* tdm_layer_get_property() */
 619
 620 TEST_F(TDMLayer,  LayerGetPropertyFailNullLayer)
 621 {
 622         SKIP_FLAG(has_layers);
 623         ASSERT_EXIT({tdm_value value;
 624                                  int id = INT_MAX;
 625                                  if (tdm_layer_get_property(NULL, id, &value) == TDM_ERROR_NONE) exit(1);
 626                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 627 }
 628
 629 TEST_F(TDMLayer,  LayerGetPropertyFailNullValue)
 630 {
 631         SKIP_FLAG(has_layers);
 632         ASSERT_EXIT({int id = INT_MAX;
 633                                  for (int i = 0; i < layer_count; ++i) {
 634                                         if (tdm_layer_get_property(tdm_layer_array[i], id, NULL) == TDM_ERROR_NONE) exit(1);
 635                                  }
 636                                 exit(0);}, ::testing::ExitedWithCode(0), "");
 637 }
 638
 639 TEST_F(TDMLayer,  LayerGetPropertyFailWrongId)
 640 {
 641         SKIP_FLAG(has_layers);
 642         tdm_error error;
 643         tdm_value value;
 644         int id = INT_MAX;
 645
 646         for (int i = 0; i < layer_count; ++i) {
 647                 error = tdm_layer_get_property(tdm_layer_array[i], id, &value);
 648                 ASSERT_NE(TDM_ERROR_NONE, error);
 649         }
 650 }
 651
 652 /* tdm_layer_set_info() */
 653
 654 TEST_F(TDMLayer,  LayerSetInfoFailNullAll)
 655 {
 656         SKIP_FLAG(has_layers);
 657         ASSERT_EXIT({if (tdm_layer_set_info(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 658                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 659 }
 660
 661 TEST_F(TDMLayer,  LayerSetInfoFailNullLayer)
 662 {
 663         SKIP_FLAG(has_layers);
 664
 665         ASSERT_EXIT({tdm_info_layer info = {0};
 666                                  if (tdm_layer_set_info(NULL, &info) == TDM_ERROR_NONE) exit(1);
 667                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 668 }
 669
 670 TEST_F(TDMLayer,  LayerSetInfoFailNullInfo)
 671 {
 672         SKIP_FLAG(has_layers);
 673
 674         ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
 675                                         if (tdm_layer_set_info(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
 676                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 677 }
 678
 679 tdm_error
 680 _ut_tdm_layer_set_info(tdm_layer *layer, int w, int h)
 681 {
 682         tdm_info_layer info = {0};
 683
 684         info.src_config.size.h = w;
 685         info.src_config.size.v = h;
 686         info.src_config.pos.x = 0;
 687         info.src_config.pos.y = 0;
 688         info.src_config.pos.w = w;
 689         info.src_config.pos.h = h;
 690         info.src_config.format = TBM_FORMAT_ARGB8888;
 691         info.dst_pos.x = 0;
 692         info.dst_pos.y = 0;
 693         info.dst_pos.w = w;
 694         info.dst_pos.h = h;
 695         info.transform = TDM_TRANSFORM_NORMAL;
 696
 697         return tdm_layer_set_info(layer, &info);
 698 }
 699
 700 TEST_F(TDMLayer,  LayerSetInfoSuccess)
 701 {
 702         SKIP_FLAG(has_layers);
 703         tdm_error error;
 704
 705         for (int i = 0; i < layer_count; ++i) {
 706                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], 128, 128);
 707                 ASSERT_EQ(TDM_ERROR_NONE, error);
 708         }
 709 }
 710
 711 /* tdm_layer_get_info() */
 712
 713 TEST_F(TDMLayer,  LayerGetInfoFailNullAll)
 714 {
 715         SKIP_FLAG(has_layers);
 716         ASSERT_EXIT({if (tdm_layer_get_info(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 717                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 718 }
 719
 720 TEST_F(TDMLayer,  LayerGetInfoFailNullLayer)
 721 {
 722         SKIP_FLAG(has_layers);
 723
 724         ASSERT_EXIT({tdm_info_layer info = {0};
 725                                  if (tdm_layer_get_info(NULL, &info) == TDM_ERROR_NONE) exit(1);
 726                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 727 }
 728
 729 TEST_F(TDMLayer,  LayerGetInfoFailNullInfo)
 730 {
 731         SKIP_FLAG(has_layers);
 732
 733         ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
 734                                         if (tdm_layer_get_info(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
 735                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 736 }
 737
 738 TEST_F(TDMLayer,  LayerGetInfoSuccess)
 739 {
 740         SKIP_FLAG(has_layers);
 741         tdm_error error;
 742         tdm_info_layer set_info = {0};
 743         tdm_info_layer ret_info = {0};
 744
 745         set_info.src_config.size.h = 128;
 746         set_info.src_config.size.v = 128;
 747         set_info.src_config.pos.x = 0;
 748         set_info.src_config.pos.y = 0;
 749         set_info.src_config.pos.w = 128;
 750         set_info.src_config.pos.h = 128;
 751         set_info.src_config.format = TBM_FORMAT_ARGB8888;
 752         set_info.dst_pos.x = 0;
 753         set_info.dst_pos.y = 0;
 754         set_info.dst_pos.w = 128;
 755         set_info.dst_pos.h = 128;
 756         set_info.transform = TDM_TRANSFORM_NORMAL;
 757
 758         for (int i = 0; i < layer_count; ++i) {
 759                 error = tdm_layer_get_info(tdm_layer_array[i], &set_info);
 760                 ASSERT_EQ(TDM_ERROR_NONE, error);
 761
 762                 error = tdm_layer_get_info(tdm_layer_array[i], &ret_info);
 763                 ASSERT_EQ(TDM_ERROR_NONE, error);
 764
 765                 ASSERT_TRUE(!memcmp(&ret_info, &set_info, sizeof(tdm_info_layer)));
 766         }
 767 }
 768
 769 /* tdm_layer_set_buffer() */
 770
 771 TEST_F(TDMLayer, LayerSetBufferFailNullAll)
 772 {
 773         SKIP_FLAG(has_layers);
 774         ASSERT_EXIT({if (tdm_layer_set_buffer(NULL, NULL) == TDM_ERROR_NONE) exit(1);
 775                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 776 }
 777
 778 TEST_F(TDMLayer, LayerSetBufferFailNullLayer)
 779 {
 780         SKIP_FLAG(has_layers);
 781
 782         ASSERT_EXIT({tdm_error error;
 783                                  tbm_surface_h buffer = UtCreateBufferForLayer(0, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 784                                  if (!buffer) exit(1);
 785                                  error = tdm_layer_set_buffer(NULL, buffer);
 786                                  if (error == TDM_ERROR_NONE) exit(1);
 787                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 788 }
 789
 790 TEST_F(TDMLayer, LayerSetBufferFailNullBuffer)
 791 {
 792         SKIP_FLAG(has_layers);
 793
 794         ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
 795                                         if (tdm_layer_set_buffer(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
 796                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 797 }
 798
 799 TEST_F(TDMLayer, LayerSetBufferSuccess)
 800 {
 801         SKIP_FLAG(has_layers);
 802         tbm_surface_h buffer;
 803         tdm_error error;
 804
 805         for (int i = 0; i < layer_count; ++i) {
 806                 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 807                 ASSERT_NE(NULL, buffer);
 808
 809                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 810                 ASSERT_EQ(TDM_ERROR_NONE, error);
 811         }
 812 }
 813
 814 TEST_F(TDMLayer, LayerSetBufferSuccessTwice)
 815 {
 816         SKIP_FLAG(has_layers);
 817         tbm_surface_h buffer;
 818         tdm_error error;
 819
 820         for (int i = 0; i < layer_count; ++i) {
 821                 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 822                 ASSERT_NE(NULL, buffer);
 823
 824                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 825                 ASSERT_EQ(TDM_ERROR_NONE, error);
 826
 827                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 828                 ASSERT_EQ(TDM_ERROR_NONE, error);
 829         }
 830 }
 831
 832 /* tdm_layer_unset_buffer() */
 833
 834 TEST_F(TDMLayer, LayerUnsetBufferFailNullLayer)
 835 {
 836         SKIP_FLAG(has_layers);
 837
 838         ASSERT_EXIT({tdm_error error;
 839                                  error = tdm_layer_unset_buffer(NULL);
 840                                  if (error == TDM_ERROR_NONE) exit(1);
 841                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 842 }
 843
 844 TEST_F(TDMLayer, LayerUnsetBufferSuccess)
 845 {
 846         SKIP_FLAG(has_layers);
 847         tbm_surface_h buffer;
 848         tdm_error error;
 849
 850         for (int i = 0; i < layer_count; ++i) {
 851                 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 852                 ASSERT_NE(NULL, buffer);
 853
 854                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 855                 ASSERT_EQ(TDM_ERROR_NONE, error);
 856
 857                 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
 858                 ASSERT_EQ(TDM_ERROR_NONE, error);
 859         }
 860 }
 861
 862 /* tdm_layer_commit() */
 863
 864 TEST_F(TDMLayer, LayerCommitFailNullAll)
 865 {
 866         SKIP_FLAG(has_layers);
 867
 868         ASSERT_EXIT({tdm_error error;
 869                                  error = tdm_layer_commit(NULL, NULL, NULL);
 870                                  if (error == TDM_ERROR_NONE) exit(1);
 871                                  exit(0);}, ::testing::ExitedWithCode(0), "");
 872 }
 873
 874 TEST_F(TDMLayer, LayerCommitFailDpmsOff)
 875 {
 876         SKIP_FLAG(has_layers);
 877         tdm_error error;
 878
 879         for (int i = 0; i < layer_count; ++i) {
 880                 error = tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
 881                 ASSERT_NE(TDM_ERROR_NONE, error);
 882         }
 883 }
 884
 885 TEST_F(TDMLayerCommit, LayerCommitSuccess)
 886 {
 887         SKIP_FLAG(has_layers);
 888         tdm_error error;
 889         int data = 0;
 890
 891         for (int i = 0; i < layer_count; ++i) {
 892                 tbm_surface_h buffer = NULL;
 893                 tdm_layer_capability layer_capability;
 894
 895                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
 896                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
 897
 898                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
 899                 ASSERT_EQ(TDM_ERROR_NONE, error);
 900
 901                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
 902                         w /= 2;
 903                         h /= 2;
 904                 }
 905
 906                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
 907                 ASSERT_EQ(TDM_ERROR_NONE, error);
 908
 909                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 910                 ASSERT_NE(NULL, buffer);
 911
 912                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 913                 ASSERT_EQ(TDM_ERROR_NONE, error);
 914
 915                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
 916                 ASSERT_EQ(TDM_ERROR_NONE, error);
 917         }
 918
 919         UtHandleCommitEvent(layer_count);
 920
 921         ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
 922         ASSERT_EQ(layer_count, data);
 923 }
 924
 925 TEST_F(TDMLayerCommitThread, LayerCommitSuccess)
 926 {
 927         SKIP_FLAG(has_layers);
 928         tdm_error error;
 929         int data = 0;
 930
 931         for (int i = 0; i < layer_count; ++i) {
 932                 tbm_surface_h buffer = NULL;
 933                 tdm_layer_capability layer_capability;
 934
 935                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
 936                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
 937
 938                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
 939                 ASSERT_EQ(TDM_ERROR_NONE, error);
 940
 941                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
 942                         w /= 2;
 943                         h /= 2;
 944                 }
 945
 946                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
 947                 ASSERT_EQ(TDM_ERROR_NONE, error);
 948
 949                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 950                 ASSERT_NE(NULL, buffer);
 951
 952                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 953                 ASSERT_EQ(TDM_ERROR_NONE, error);
 954
 955                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
 956                 ASSERT_EQ(TDM_ERROR_NONE, error);
 957         }
 958
 959         UtHandleCommitEvent(layer_count);
 960
 961         ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
 962         ASSERT_EQ(layer_count, data);
 963 }
 964
 965 TEST_F(TDMLayerCommit, LayerCommitSuccessOnlyPrimaryLayers)
 966 {
 967         SKIP_FLAG(has_layers);
 968         tdm_error error;
 969         int data = 0;
 970         int num_waiting_layers = 0;
 971
 972         for (int i = 0; i < layer_count; ++i) {
 973                 tbm_surface_h buffer = NULL;
 974                 tdm_layer_capability layer_capability;
 975
 976                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
 977                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
 978
 979                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
 980                 ASSERT_EQ(TDM_ERROR_NONE, error);
 981
 982                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
 983                         continue;
 984
 985                 num_waiting_layers++;
 986
 987                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
 988                 ASSERT_EQ(TDM_ERROR_NONE, error);
 989
 990                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
 991                 ASSERT_NE(NULL, buffer);
 992
 993                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
 994                 ASSERT_EQ(TDM_ERROR_NONE, error);
 995
 996                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
 997                 ASSERT_EQ(TDM_ERROR_NONE, error);
 998         }
 999
1000         UtHandleCommitEvent(num_waiting_layers);
1001
1002         ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1003         ASSERT_EQ(num_waiting_layers, data);
1004 }
1005
1006 TEST_F(TDMLayerCommitThread, LayerCommitSuccessOnlyPrimaryLayers)
1007 {
1008         SKIP_FLAG(has_layers);
1009         tdm_error error;
1010         int data = 0;
1011         int num_waiting_layers = 0;
1012
1013         for (int i = 0; i < layer_count; ++i) {
1014                 tbm_surface_h buffer = NULL;
1015                 tdm_layer_capability layer_capability;
1016
1017                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1018                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1019
1020                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1021                 ASSERT_EQ(TDM_ERROR_NONE, error);
1022
1023                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
1024                         continue;
1025
1026                 num_waiting_layers++;
1027
1028                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1029                 ASSERT_EQ(TDM_ERROR_NONE, error);
1030
1031                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1032                 ASSERT_NE(NULL, buffer);
1033
1034                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1035                 ASSERT_EQ(TDM_ERROR_NONE, error);
1036
1037                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1038                 ASSERT_EQ(TDM_ERROR_NONE, error);
1039         }
1040
1041         UtHandleCommitEvent(num_waiting_layers);
1042
1043         ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1044         ASSERT_EQ(num_waiting_layers, data);
1045 }
1046
1047 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerCommitSuccess)
1048 {
1049         SKIP_FLAG(has_layers);
1050         tdm_error error;
1051         int data = 0;
1052
1053         for (int i = 0; i < layer_count; ++i) {
1054                 tbm_surface_h buffer = NULL;
1055                 tdm_layer_capability layer_capability;
1056
1057                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1058                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1059
1060                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1061                 ASSERT_EQ(TDM_ERROR_NONE, error);
1062
1063                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1064                         w /= 2;
1065                         h /= 2;
1066                 }
1067
1068                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1069                 ASSERT_EQ(TDM_ERROR_NONE, error);
1070
1071                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1072                 ASSERT_NE(NULL, buffer);
1073
1074                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1075                 ASSERT_EQ(TDM_ERROR_NONE, error);
1076
1077                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1078                 ASSERT_EQ(TDM_ERROR_NONE, error);
1079         }
1080
1081         UtHandleCommitEvent(layer_count);
1082
1083         ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1084         ASSERT_EQ(layer_count, data);
1085 }
1086
1087 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerCommitSuccessOnlyPrimaryLayers)
1088 {
1089         SKIP_FLAG(has_layers);
1090         tdm_error error;
1091         int data = 0;
1092         int num_waiting_layers = 0;
1093
1094         for (int i = 0; i < layer_count; ++i) {
1095                 tbm_surface_h buffer = NULL;
1096                 tdm_layer_capability layer_capability;
1097
1098                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1099                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1100
1101                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1102                 ASSERT_EQ(TDM_ERROR_NONE, error);
1103
1104                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
1105                         continue;
1106
1107                 num_waiting_layers++;
1108
1109                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1110                 ASSERT_EQ(TDM_ERROR_NONE, error);
1111
1112                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1113                 ASSERT_NE(NULL, buffer);
1114
1115                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1116                 ASSERT_EQ(TDM_ERROR_NONE, error);
1117
1118                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1119                 ASSERT_EQ(TDM_ERROR_NONE, error);
1120         }
1121
1122         UtHandleCommitEvent(num_waiting_layers);
1123
1124         ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1125         ASSERT_EQ(num_waiting_layers, data);
1126 }
1127
1128 TEST_F(TDMLayerCommit, LayerCommitSuccessUnsetAfterCommit)
1129 {
1130         SKIP_FLAG(has_layers);
1131         tdm_error error;
1132         int data = 0;
1133
1134         for (int i = 0; i < layer_count; ++i) {
1135                 tbm_surface_h buffer = NULL;
1136                 tdm_layer_capability layer_capability;
1137
1138                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1139                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1140
1141                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1142                 ASSERT_EQ(TDM_ERROR_NONE, error);
1143
1144                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1145                         w /= 2;
1146                         h /= 2;
1147                 }
1148
1149                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1150                 ASSERT_EQ(TDM_ERROR_NONE, error);
1151
1152                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1153                 ASSERT_NE(NULL, buffer);
1154
1155                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1156                 ASSERT_EQ(TDM_ERROR_NONE, error);
1157
1158                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1159                 ASSERT_EQ(TDM_ERROR_NONE, error);
1160         }
1161
1162         for (int i = 0; i < layer_count; ++i) {
1163                 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1164                 ASSERT_EQ(TDM_ERROR_NONE, error);
1165         }
1166
1167         UtHandleCommitEvent(layer_count);
1168         ASSERT_EQ(0, utLayerCommitHandlerCounter);
1169         ASSERT_EQ(0, data);
1170 }
1171
1172 TEST_F(TDMLayerCommit, LayerCommitSuccessUnsetBeforeCommit_2)
1173 {
1174         SKIP_FLAG(has_layers);
1175         tdm_error error;
1176         int data = 0;
1177
1178         for (int i = 0; i < layer_count; ++i) {
1179                 tbm_surface_h buffer = NULL;
1180                 tdm_layer_capability layer_capability;
1181
1182                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1183                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1184
1185                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1186                 ASSERT_EQ(TDM_ERROR_NONE, error);
1187
1188                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1189                         w /= 2;
1190                         h /= 2;
1191                 }
1192
1193                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1194                 ASSERT_EQ(TDM_ERROR_NONE, error);
1195
1196                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1197                 ASSERT_NE(NULL, buffer);
1198
1199                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1200                 ASSERT_EQ(TDM_ERROR_NONE, error);
1201
1202                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1203                 ASSERT_EQ(TDM_ERROR_NONE, error);
1204         }
1205
1206         UtHandleCommitEvent(layer_count);
1207         ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1208         ASSERT_EQ(layer_count, data);
1209
1210         for (int i = 0; i < layer_count; ++i) {
1211                 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1212                 ASSERT_EQ(TDM_ERROR_NONE, error);
1213         }
1214 }
1215
1216 /* tdm_layer_is_committing() */
1217
1218 TEST_F(TDMLayer, LayerIsCommittingFailNullAll)
1219 {
1220         SKIP_FLAG(has_layers);
1221
1222         ASSERT_EXIT({tdm_error error;
1223                                  error = tdm_layer_is_committing(NULL, NULL);
1224                                  if (error == TDM_ERROR_NONE) exit(1);
1225                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1226 }
1227
1228 TEST_F(TDMLayer, LayerIsCommittingFailNullLayer)
1229 {
1230         SKIP_FLAG(has_layers);
1231         unsigned int committing;
1232
1233         ASSERT_EXIT({tdm_error error;
1234                                  error = tdm_layer_is_committing(NULL, &committing);
1235                                  if (error == TDM_ERROR_NONE) exit(1);
1236                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1237 }
1238
1239 TEST_F(TDMLayer, LayerIsCommittingFailNullCommitting)
1240 {
1241         SKIP_FLAG(has_layers);
1242
1243         ASSERT_EXIT({tdm_error error;
1244                                  error = tdm_layer_is_committing(tdm_layer_array[0], NULL);
1245                                  if (error == TDM_ERROR_NONE) exit(1);
1246                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1247 }
1248
1249 TEST_F(TDMLayer, LayerIsCommittingSuccessWithoutCommit)
1250 {
1251         SKIP_FLAG(has_layers);
1252         tdm_error error;
1253         unsigned int committing;
1254
1255         for (int i = 0; i < layer_count; ++i) {
1256                 error = tdm_layer_is_committing(tdm_layer_array[0], &committing);
1257                 ASSERT_EQ(TDM_ERROR_NONE, error);
1258
1259                 ASSERT_EQ(0, committing);
1260         }
1261 }
1262
1263 TEST_F(TDMLayerCommit, LayerIsCommittingSuccess)
1264 {
1265         SKIP_FLAG(has_layers);
1266         tdm_error error;
1267         unsigned int committing;
1268
1269         for (int i = 0; i < layer_count; ++i) {
1270                 tbm_surface_h buffer = NULL;
1271                 tdm_layer_capability layer_capability;
1272
1273                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1274                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1275
1276                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1277                 ASSERT_EQ(TDM_ERROR_NONE, error);
1278
1279                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1280                         w /= 2;
1281                         h /= 2;
1282                 }
1283
1284                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1285                 ASSERT_EQ(TDM_ERROR_NONE, error);
1286
1287                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1288                 ASSERT_NE(NULL, buffer);
1289
1290                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1291                 ASSERT_EQ(TDM_ERROR_NONE, error);
1292
1293                 error = tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1294                 ASSERT_EQ(TDM_ERROR_NONE, error);
1295
1296                 error = tdm_layer_is_committing(tdm_layer_array[0], &committing);
1297                 ASSERT_EQ(TDM_ERROR_NONE, error);
1298
1299                 ASSERT_EQ(1, committing);
1300         }
1301 }
1302
1303 /* tdm_layer_remove_commit_handler() */
1304
1305 TEST_F(TDMLayer, LayerRemoveCommitHandlerFailNullAll)
1306 {
1307         SKIP_FLAG(has_layers);
1308
1309         ASSERT_EXIT({tdm_error error;
1310                                  error = tdm_layer_remove_commit_handler(NULL, NULL, NULL);
1311                                  if (error == TDM_ERROR_NONE) exit(1);
1312                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1313 }
1314
1315 TEST_F(TDMLayerCommit, LayerRemoveCommitHandlerSuccess)
1316 {
1317         SKIP_FLAG(has_layers);
1318         tdm_error error;
1319         int data = 0;
1320
1321         for (int i = 0; i < layer_count; ++i) {
1322                 tbm_surface_h buffer = NULL;
1323                 tdm_layer_capability layer_capability;
1324
1325                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1326                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1327
1328                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1329                 ASSERT_EQ(TDM_ERROR_NONE, error);
1330
1331                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1332                         w /= 2;
1333                         h /= 2;
1334                 }
1335
1336                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1337                 ASSERT_EQ(TDM_ERROR_NONE, error);
1338
1339                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1340                 ASSERT_NE(NULL, buffer);
1341
1342                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1343                 ASSERT_EQ(TDM_ERROR_NONE, error);
1344
1345                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1346                 ASSERT_EQ(TDM_ERROR_NONE, error);
1347
1348                 error = tdm_layer_remove_commit_handler(tdm_layer_array[i], UtLayerCommitHandler, &data);
1349                 ASSERT_EQ(TDM_ERROR_NONE, error);
1350         }
1351
1352         UtHandleCommitEvent(layer_count);
1353         ASSERT_EQ(0, utLayerCommitHandlerCounter);
1354         ASSERT_EQ(0, data);
1355 }
1356
1357 /* tdm_layer_get_displaying_buffer() */
1358
1359 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferFailNullAll)
1360 {
1361         SKIP_FLAG(has_layers);
1362
1363         ASSERT_EXIT({if (tdm_layer_get_displaying_buffer(NULL, NULL) != NULL) exit(1);
1364                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1365 }
1366
1367 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferFailWithoutCommit)
1368 {
1369         SKIP_FLAG(has_layers);
1370         tdm_error error;
1371
1372         for (int i = 0; i < layer_count; ++i) {
1373                 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1374                 ASSERT_NE(TDM_ERROR_NONE, error);
1375         }
1376 }
1377
1378 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferSuccess)
1379 {
1380         SKIP_FLAG(has_layers);
1381         tdm_error error;
1382         int data = 0;
1383
1384         for (int i = 0; i < layer_count; ++i) {
1385                 tbm_surface_h buffer = NULL;
1386                 tdm_layer_capability layer_capability;
1387
1388                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1389                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1390
1391                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1392                 ASSERT_EQ(TDM_ERROR_NONE, error);
1393
1394                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1395                         w /= 2;
1396                         h /= 2;
1397                 }
1398
1399                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1400                 ASSERT_EQ(TDM_ERROR_NONE, error);
1401
1402                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1403                 ASSERT_NE(NULL, buffer);
1404
1405                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1406                 ASSERT_EQ(TDM_ERROR_NONE, error);
1407
1408                 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1409                 ASSERT_EQ(TDM_ERROR_NONE, error);
1410         }
1411
1412         UtHandleCommitEvent(layer_count);
1413         ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1414         ASSERT_EQ(layer_count, data);
1415
1416         for (int i = 0; i < layer_count; ++i) {
1417                 ASSERT_EQ(tdm_layers_buffer_array[i], tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1418                 ASSERT_EQ(TDM_ERROR_NONE, error);
1419         }
1420 }
1421
1422 /* tdm_layer_is_usable() */
1423
1424 TEST_F(TDMLayer, LayerIsUsableFailNullAll)
1425 {
1426         SKIP_FLAG(has_layers);
1427
1428         ASSERT_EXIT({if (tdm_layer_is_usable(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1429                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1430 }
1431
1432 TEST_F(TDMLayer, LayerIsUsableFailNullLayer)
1433 {
1434         SKIP_FLAG(has_layers);
1435         unsigned int usable;
1436
1437         ASSERT_EXIT({if (tdm_layer_is_usable(NULL, &usable) == TDM_ERROR_NONE) exit(1);
1438                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1439 }
1440
1441 TEST_F(TDMLayer, LayerIsUsableFailNullUsable)
1442 {
1443         SKIP_FLAG(has_layers);
1444
1445         ASSERT_EXIT({if (tdm_layer_is_usable(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1446                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1447 }
1448
1449 TEST_F(TDMLayer, LayerIsUsableSuccessAllUsable)
1450 {
1451         SKIP_FLAG(has_layers);
1452         unsigned int usable;
1453         tdm_error error;
1454
1455         for (int i = 0; i < layer_count; ++i) {
1456                 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1457                 ASSERT_EQ(TDM_ERROR_NONE, error);
1458                 ASSERT_NE(0, usable);
1459         }
1460 }
1461
1462 TEST_F(TDMLayer, LayerIsUsableSuccessAllUsable_2)
1463 {
1464         SKIP_FLAG(has_layers);
1465         unsigned int usable;
1466         tdm_error error;
1467
1468         for (int i = 0; i < layer_count; ++i) {
1469                 tbm_surface_h buffer;
1470
1471                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1472                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1473
1474                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1475                 ASSERT_NE(NULL, buffer);
1476
1477                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1478                 ASSERT_EQ(TDM_ERROR_NONE, error);
1479
1480                 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1481                 ASSERT_EQ(TDM_ERROR_NONE, error);
1482
1483                 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1484                 ASSERT_EQ(TDM_ERROR_NONE, error);
1485                 ASSERT_NE(0, usable);
1486         }
1487 }
1488
1489 TEST_F(TDMLayer, LayerIsUsableSuccessAllNoUsable)
1490 {
1491         SKIP_FLAG(has_layers);
1492         unsigned int usable;
1493         tdm_error error;
1494
1495         for (int i = 0; i < layer_count; ++i) {
1496                 tbm_surface_h buffer;
1497
1498                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1499                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1500
1501                 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1502                 ASSERT_NE(NULL, buffer);
1503
1504                 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1505                 ASSERT_EQ(TDM_ERROR_NONE, error);
1506
1507                 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1508                 ASSERT_EQ(TDM_ERROR_NONE, error);
1509                 ASSERT_EQ(0, usable);
1510         }
1511 }
1512
1513 /* tdm_layer_set_video_pos() */
1514
1515 TEST_F(TDMLayer, LayerSetVideoPosFailNullAll)
1516 {
1517         SKIP_FLAG(has_layers);
1518
1519         ASSERT_EXIT({if (tdm_layer_set_video_pos(NULL, -1) == TDM_ERROR_NONE) exit(1);
1520                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1521 }
1522
1523 TEST_F(TDMLayer, LayerSetVideoPosFailNoVideoLayers)
1524 {
1525         SKIP_FLAG(has_layers);
1526         tdm_error error;
1527         tdm_layer_capability layer_capability;
1528
1529         for (int i = 0; i < layer_count; ++i) {
1530                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1531                 ASSERT_EQ(TDM_ERROR_NONE, error);
1532
1533                 if (layer_capability & TDM_LAYER_CAPABILITY_VIDEO)
1534                         continue;
1535
1536                 error = tdm_layer_set_video_pos(tdm_layer_array[i], -1);
1537                 ASSERT_NE(TDM_ERROR_NONE, error);
1538         }
1539 }
1540
1541 TEST_F(TDMLayer, LayerSetVideoPosSuccess)
1542 {
1543         SKIP_FLAG(has_layers);
1544         tdm_error error;
1545         tdm_layer_capability layer_capability;
1546
1547         for (int i = 0; i < layer_count; ++i) {
1548                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1549                 ASSERT_EQ(TDM_ERROR_NONE, error);
1550
1551                 if (!(layer_capability & TDM_LAYER_CAPABILITY_VIDEO))
1552                         continue;
1553
1554                 error = tdm_layer_set_video_pos(tdm_layer_array[i], -1);
1555                 ASSERT_EQ(TDM_ERROR_NONE, error);
1556         }
1557 }
1558
1559 /* tdm_layer_create_capture() */
1560
1561 TEST_F(TDMLayer, LayerCreateCaptureNullAll)
1562 {
1563         SKIP_FLAG(has_layers);
1564
1565         ASSERT_EXIT({if (tdm_layer_create_capture(NULL, NULL) != NULL) exit(1);
1566                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1567 }
1568
1569 TEST_F(TDMLayer, LayerCreateCaptureSuccess)
1570 {
1571         SKIP_FLAG(has_layers);
1572         tdm_error error;
1573         tdm_capture *capture;
1574
1575         for (int i = 0; i < layer_count; ++i) {
1576                 capture = tdm_layer_create_capture(tdm_layer_array[i], &error);
1577                 if (error == TDM_ERROR_NO_CAPABILITY)
1578                         return;
1579
1580                 ASSERT_EQ(TDM_ERROR_NONE, error);
1581                 ASSERT_NE(NULL, capture);
1582         }
1583 }
1584
1585 /* tdm_layer_get_buffer_flags() */
1586
1587 TEST_F(TDMLayer, LayerGetBufferFlagsNullAll)
1588 {
1589         SKIP_FLAG(has_layers);
1590
1591         ASSERT_EXIT({if (tdm_layer_get_buffer_flags(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1592                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1593 }
1594
1595 TEST_F(TDMLayer, LayerGetBufferFlagsNullLayer)
1596 {
1597         SKIP_FLAG(has_layers);
1598         unsigned int flags;
1599
1600         ASSERT_EXIT({if (tdm_layer_get_buffer_flags(NULL, &flags) == TDM_ERROR_NONE) exit(1);
1601                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1602 }
1603
1604 TEST_F(TDMLayer, LayerGetBufferFlagsNullFlags)
1605 {
1606         SKIP_FLAG(has_layers);
1607
1608         ASSERT_EXIT({if (tdm_layer_get_buffer_flags(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1609                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1610 }
1611
1612 TEST_F(TDMLayer, LayerGetBufferFlagsSuccess)
1613 {
1614         SKIP_FLAG(has_layers);
1615         tdm_error error;
1616         unsigned int flags;
1617
1618         for (int i = 0; i < layer_count; ++i) {
1619                 error = tdm_layer_get_buffer_flags(tdm_layer_array[i], &flags);
1620                 if (error == TDM_ERROR_NOT_IMPLEMENTED)
1621                         return;
1622
1623                 ASSERT_EQ(TDM_ERROR_NONE, error);
1624         }
1625 }
1626
1627 /* tdm_layer_set_buffer_queue() */
1628
1629 TEST_F(TDMLayer, LayerSetBufferQueueFailNullAll)
1630 {
1631         SKIP_FLAG(has_layers);
1632
1633         ASSERT_EXIT({if (tdm_layer_set_buffer_queue(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1634                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1635 }
1636
1637 TEST_F(TDMLayer, LayerSetBufferQueueFailNullLayer)
1638 {
1639         SKIP_FLAG(has_layers);
1640         tbm_surface_queue_h bufer_queue;
1641
1642         bufer_queue = UtCreateBufferQueueForLayer(0, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1643         ASSERT_NE(NULL, bufer_queue);
1644
1645         ASSERT_EXIT({if (tdm_layer_set_buffer_queue(NULL, bufer_queue) == TDM_ERROR_NONE) exit(1);
1646                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1647 }
1648
1649 TEST_F(TDMLayer, LayerSetBufferQueueFailNullBufferQueue)
1650 {
1651         SKIP_FLAG(has_layers);
1652
1653         ASSERT_EXIT({if (tdm_layer_set_buffer_queue(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1654                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1655 }
1656
1657 TEST_F(TDMLayer, LayerSetBufferQueueSuccess)
1658 {
1659         SKIP_FLAG(has_layers);
1660         tdm_error error;
1661         tbm_surface_queue_h buffer_queue;
1662         tdm_layer_capability layer_capability;
1663
1664         for (int i = 0; i < layer_count; ++i) {
1665                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1666                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1667
1668                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1669                 ASSERT_EQ(TDM_ERROR_NONE, error);
1670
1671                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1672                         w /= 2;
1673                         h /= 2;
1674                 }
1675
1676                 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1677                 ASSERT_NE(NULL, buffer_queue);
1678
1679                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1680                 ASSERT_EQ(TDM_ERROR_NONE, error);
1681         }
1682 }
1683
1684 TEST_F(TDMLayer, LayerSetBufferQueueSuccessTwice)
1685 {
1686         SKIP_FLAG(has_layers);
1687         tdm_error error;
1688         tbm_surface_queue_h buffer_queue;
1689         tdm_layer_capability layer_capability;
1690
1691         for (int i = 0; i < layer_count; ++i) {
1692                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1693                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1694
1695                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1696                 ASSERT_EQ(TDM_ERROR_NONE, error);
1697
1698                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1699                         w /= 2;
1700                         h /= 2;
1701                 }
1702
1703                 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1704                 ASSERT_NE(NULL, buffer_queue);
1705
1706                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1707                 ASSERT_EQ(TDM_ERROR_NONE, error);
1708
1709                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1710                 ASSERT_EQ(TDM_ERROR_NONE, error);
1711         }
1712 }
1713
1714 TEST_F(TDMLayerCommitThread, LayerSetBufferQueueSuccessRemoveBufferQueue)
1715 {
1716         SKIP_FLAG(has_layers);
1717         tdm_error error;
1718         tbm_surface_queue_error_e tbm_err;
1719         tbm_surface_queue_h buffer_queue;
1720         tdm_layer_capability layer_capability;
1721
1722         for (int i = 0; i < layer_count; ++i) {
1723                 tbm_surface_h surface;
1724
1725                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1726                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1727
1728                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1729                 ASSERT_EQ(TDM_ERROR_NONE, error);
1730
1731                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1732                         w /= 2;
1733                         h /= 2;
1734                 }
1735
1736                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1737                 ASSERT_EQ(TDM_ERROR_NONE, error);
1738
1739                 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1740                 ASSERT_NE(NULL, buffer_queue);
1741
1742                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1743                 ASSERT_EQ(TDM_ERROR_NONE, error);
1744
1745                 tbm_err = tbm_surface_queue_dequeue(buffer_queue, &surface);
1746                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1747
1748                 tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1749
1750                 tbm_err = tbm_surface_queue_enqueue(buffer_queue, surface);
1751                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1752         }
1753
1754         /* FIXME: use another func. */
1755         UtHandleCommitEvent(1);
1756
1757         for (int i = 0; i < layer_count; ++i) {
1758                 ASSERT_NE(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1759                 ASSERT_EQ(TDM_ERROR_NONE, error);
1760
1761                 tbm_surface_queue_destroy(tdm_layers_buffer_queue_array[i]);
1762                 tdm_layers_buffer_queue_array[i] = NULL;
1763
1764                 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1765                 ASSERT_NE(TDM_ERROR_NONE, error);
1766         }
1767 }
1768
1769 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerSetBufferQueueSuccessRemoveBufferQueue)
1770 {
1771         SKIP_FLAG(has_layers);
1772         tdm_error error;
1773         tbm_surface_queue_error_e tbm_err;
1774         tbm_surface_queue_h buffer_queue;
1775         tdm_layer_capability layer_capability;
1776
1777         for (int i = 0; i < layer_count; ++i) {
1778                 tbm_surface_h surface;
1779
1780                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1781                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1782
1783                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1784                 ASSERT_EQ(TDM_ERROR_NONE, error);
1785
1786                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1787                         w /= 2;
1788                         h /= 2;
1789                 }
1790
1791                 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1792                 ASSERT_EQ(TDM_ERROR_NONE, error);
1793
1794                 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1795                 ASSERT_NE(NULL, buffer_queue);
1796
1797                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1798                 ASSERT_EQ(TDM_ERROR_NONE, error);
1799
1800                 tbm_err = tbm_surface_queue_dequeue(buffer_queue, &surface);
1801                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1802
1803                 tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1804
1805                 tbm_err = tbm_surface_queue_enqueue(buffer_queue, surface);
1806                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1807         }
1808
1809         /* FIXME: use another func. */
1810         UtHandleCommitEvent(1);
1811
1812         for (int i = 0; i < layer_count; ++i) {
1813                 tbm_surface_h surface;
1814
1815                 tbm_err = tbm_surface_queue_dequeue(tdm_layers_buffer_queue_array[i], &surface);
1816                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, error);
1817
1818                 tbm_err = tbm_surface_queue_enqueue(tdm_layers_buffer_queue_array[i], surface);
1819                 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, error);
1820
1821                 error = tdm_layer_unset_buffer_queue(tdm_layer_array[i]);
1822                 ASSERT_EQ(TDM_ERROR_NONE, error);
1823         }
1824
1825         /* FIXME: use another func. */
1826         UtHandleCommitEvent(1);
1827
1828         for (int i = 0; i < layer_count; ++i) {
1829                 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1830                 ASSERT_NE(TDM_ERROR_NONE, error);
1831         }
1832 }
1833
1834 /* tdm_layer_unset_buffer_queue() */
1835
1836 TEST_F(TDMLayer, LayerUnsetBufferQueueFailNullAll)
1837 {
1838         SKIP_FLAG(has_layers);
1839
1840         ASSERT_EXIT({if (tdm_layer_unset_buffer_queue(NULL) == TDM_ERROR_NONE) exit(1);
1841                                  exit(0);}, ::testing::ExitedWithCode(0), "");
1842 }
1843
1844 TEST_F(TDMLayer, LayerUnsetBufferQueueSuccess)
1845 {
1846         SKIP_FLAG(has_layers);
1847         tdm_error error;
1848         tbm_surface_queue_h buffer_queue;
1849         tdm_layer_capability layer_capability;
1850
1851         for (int i = 0; i < layer_count; ++i) {
1852                 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1853                 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1854
1855                 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1856                 ASSERT_EQ(TDM_ERROR_NONE, error);
1857
1858                 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1859                         w /= 2;
1860                         h /= 2;
1861                 }
1862
1863                 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1864                 ASSERT_NE(NULL, buffer_queue);
1865
1866                 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1867                 ASSERT_EQ(TDM_ERROR_NONE, error);
1868
1869                 error = tdm_layer_unset_buffer_queue(tdm_layer_array[i]);
1870                 ASSERT_EQ(TDM_ERROR_NONE, error);
1871         }
1872 }