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