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 "ut_tdm.h"
  32
  33 /* LCOV_EXCL_START */
  34
  35 #define BORDER_SIZE   20
  36
  37 class TDMLayer : public TDMOutput
  38 {
  39 public:
  40         bool has_layers;
  41         tdm_layer **layers;
  42         int layer_count;
  43
  44         tbm_surface_h buffers[3];
  45         tbm_surface_queue_h buffer_queue;
  46
  47         TDMLayer();
  48         void SetUp(void);
  49         void TearDown(void);
  50
  51         void DestroyBuffers(void);
  52 };
  53
  54 TDMLayer::TDMLayer()
  55 {
  56         has_layers = false;
  57         layers = NULL;
  58         layer_count = TDM_UT_INVALID_VALUE;
  59
  60         for (int b = 0; b < 3; b++)
  61                 buffers[b] = NULL;
  62
  63         buffer_queue = NULL;
  64 }
  65
  66 void TDMLayer::SetUp(void)
  67 {
  68         TDMOutput::SetUp();
  69
  70         layer_count = 0;
  71
  72         for (int o = 0; o < output_count; o++) {
  73                 int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
  74                 tdm_error ret;
  75
  76                 if (ut_tdm_output_is_hwc_enable(outputs[o]))
  77                         continue;
  78
  79                 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
  80                 ASSERT_GT(count, 0);
  81
  82                 layer_count += count;
  83                 layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count);
  84                 ASSERT_NE(layers, NULL);
  85
  86                 for (int l = 0; l < count; l++) {
  87                         tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
  88                         ASSERT_NE(layer, NULL);
  89                         ASSERT_EQ(ret, TDM_ERROR_NONE);
  90                         layers[old_layer_count + l] = layer;
  91                 }
  92         }
  93
  94         if (layer_count > 0)
  95                 has_layers = true;
  96 }
  97
  98 void TDMLayer::TearDown(void)
  99 {
 100         for (int l = 0; l < layer_count; l++) {
 101                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 102         }
 103
 104         free(layers);
 105
 106         DestroyBuffers();
 107
 108         TDMOutput::TearDown();
 109 }
 110
 111 void TDMLayer::DestroyBuffers(void)
 112 {
 113         for (int b = 0; b < 3; b++) {
 114                 if (buffers[b]) {
 115                         tbm_surface_destroy(buffers[b]);
 116                         buffers[b] = NULL;
 117                 }
 118         }
 119
 120         if (buffer_queue) {
 121                 tbm_surface_queue_destroy(buffer_queue);
 122                 buffer_queue = NULL;
 123         }
 124 }
 125
 126 bool
 127 ut_tdm_layer_is_cursor_layer(tdm_layer *layer)
 128 {
 129         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 130         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 131                 return false;
 132         return capabilities & TDM_LAYER_CAPABILITY_CURSOR;
 133 }
 134
 135 bool
 136 ut_tdm_layer_is_primary_layer(tdm_layer *layer)
 137 {
 138         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 139         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 140                 return false;
 141         return capabilities & TDM_LAYER_CAPABILITY_PRIMARY;
 142 }
 143
 144 bool
 145 ut_tdm_layer_is_video_layer(tdm_layer *layer)
 146 {
 147         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 148         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 149                 return false;
 150         return capabilities & TDM_LAYER_CAPABILITY_VIDEO;
 151 }
 152
 153 bool
 154 ut_tdm_layer_support_scale(tdm_layer *layer)
 155 {
 156         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 157         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 158                 return false;
 159         return capabilities & TDM_LAYER_CAPABILITY_SCALE;
 160 }
 161
 162 bool
 163 ut_tdm_layer_support_no_crop(tdm_layer *layer)
 164 {
 165         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 166         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 167                 return false;
 168         return capabilities & TDM_LAYER_CAPABILITY_NO_CROP;
 169 }
 170
 171 unsigned int
 172 ut_tdm_layer_get_output_pipe(tdm_layer *layer)
 173 {
 174         unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
 175         tdm_error ret;
 176         tdm_output *output = tdm_layer_get_output(layer, &ret);
 177         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 178         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 179
 180         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
 181         TDM_UT_RETURN_FALSE_IF_FAIL(pipe != (unsigned int)TDM_UT_INVALID_VALUE);
 182
 183         return pipe;
 184 }
 185
 186 tbm_format
 187 ut_tdm_layer_find_best_format(tdm_layer *layer)
 188 {
 189         const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 190         int count = TDM_UT_INVALID_VALUE;
 191         tdm_error ret;
 192         ret = tdm_layer_get_available_formats(layer, &formats, &count);
 193         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 194
 195         for (int f = 0; f < count; f++)
 196                 if (formats[f] == TBM_FORMAT_ARGB8888)
 197                         return TBM_FORMAT_ARGB8888;
 198         for (int f = 0; f < count; f++)
 199                 if (formats[f] == TBM_FORMAT_XRGB8888)
 200                         return TBM_FORMAT_XRGB8888;
 201         for (int f = 0; f < count; f++)
 202                 if (formats[f] == TBM_FORMAT_YUV420)
 203                         return TBM_FORMAT_YUV420;
 204         for (int f = 0; f < count; f++)
 205                 if (formats[f] == TBM_FORMAT_NV12)
 206                         return TBM_FORMAT_NV12;
 207
 208         return 0;
 209 }
 210
 211 bool
 212 ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill)
 213 {
 214         tdm_error ret;
 215         unsigned int flags = 0;
 216         tbm_format format = (tbm_format)0;
 217         int w, h;
 218         tdm_output *output;
 219         const tdm_output_mode *mode = NULL;
 220
 221         /* create buffers */
 222         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
 223
 224         format = ut_tdm_layer_find_best_format(layer);
 225         TDM_UT_RETURN_FALSE_IF_FAIL(format != 0);
 226
 227         output = tdm_layer_get_output(layer, &ret);
 228         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 229         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 230
 231         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 232         TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 233
 234         if (ut_tdm_layer_is_primary_layer(layer)) {
 235                 w = mode->hdisplay;
 236                 h = mode->vdisplay;
 237         } else {
 238                 w = mode->hdisplay / 2;
 239                 h = mode->vdisplay / 2;
 240         }
 241
 242         TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
 243
 244         TDM_INFO("preparing buffers done");
 245
 246         return true;
 247 }
 248
 249 bool
 250 ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
 251 {
 252         tdm_error ret;
 253         unsigned int flags = 0;
 254         tbm_format format = (tbm_format)0;
 255         int w, h;
 256
 257         /* create buffers */
 258         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
 259
 260         format = ut_tdm_layer_find_best_format(layer);
 261         TDM_UT_RETURN_FALSE_IF_FAIL(format != (tbm_format)0);
 262
 263         if (ut_tdm_layer_is_primary_layer(layer)) {
 264                 tdm_output *output;
 265                 const tdm_output_mode *mode = NULL;
 266                 output = tdm_layer_get_output(layer, &ret);
 267                 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 268                 TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 269
 270                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 271                 TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 272
 273                 w = mode->hdisplay;
 274                 h = mode->vdisplay;
 275         } else {
 276                 w = TDM_UT_BUFFER_SIZE;
 277                 h = TDM_UT_BUFFER_SIZE;
 278         }
 279
 280         *buffer_queue = tbm_surface_queue_create(2, w, h, format, flags | TBM_BO_SCANOUT);
 281         TDM_UT_RETURN_FALSE_IF_FAIL((*buffer_queue) != NULL);
 282
 283         TDM_INFO("preparing buffers done");
 284
 285         return true;
 286 }
 287
 288 bool
 289 ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info)
 290 {
 291         tdm_error ret;
 292         tdm_output *output;
 293         const tdm_output_mode *mode = NULL;
 294         int count = 0;
 295         int zpos = -1;
 296         int bw, bh;
 297         int w, h;
 298         tbm_format format;
 299
 300         output = tdm_layer_get_output(layer, &ret);
 301         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 302         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 303
 304         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 305         TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 306
 307         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
 308         TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
 309
 310         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(layer, &zpos) == TDM_ERROR_NONE);
 311         TDM_UT_RETURN_FALSE_IF_FAIL(zpos >= 0);
 312
 313         if (buffer) {
 314                 tdm_helper_get_buffer_full_size(buffer, &bw, &bh);
 315                 w = tbm_surface_get_width(buffer);
 316                 h = tbm_surface_get_height(buffer);
 317                 format = tbm_surface_get_format(buffer);
 318         } else if (buffer_queue) {
 319                 bw = w = tbm_surface_queue_get_width(buffer_queue);
 320                 bh = h = tbm_surface_queue_get_height(buffer_queue);
 321                 format = tbm_surface_queue_get_format(buffer_queue);
 322         } else {
 323                 bw = mode->hdisplay;
 324                 bh = mode->vdisplay;
 325                 w = mode->hdisplay;
 326                 h = mode->vdisplay;
 327                 format = ut_tdm_layer_find_best_format(layer);
 328         }
 329
 330         /* TODO: check min,max,prefered size and avaiable formats */
 331         memset(info, 0, sizeof *info);
 332         info->src_config.size.h = bw;
 333         info->src_config.size.v = bh;
 334         info->src_config.pos.x = 0;
 335         info->src_config.pos.y = 0;
 336         info->src_config.pos.w = w;
 337         info->src_config.pos.h = h;
 338         info->src_config.format = format;
 339         if (ut_tdm_layer_is_primary_layer(layer)) {
 340                 info->dst_pos.x = 0;
 341                 info->dst_pos.y = 0;
 342         } else {
 343                 int x = (((int)mode->hdisplay - 2 * BORDER_SIZE - w) / count) * zpos + BORDER_SIZE;
 344                 int y = (((int)mode->vdisplay - 2 * BORDER_SIZE - h) / count) * zpos + BORDER_SIZE;
 345                 x = (x > 0) ? x : 0;
 346                 y = (y > 0) ? y : 0;
 347                 info->dst_pos.x = ((x + w) <= (int)mode->hdisplay) ? x : 0;
 348                 info->dst_pos.y = ((y + h) <= (int)mode->vdisplay) ? y : 0;
 349         }
 350         info->dst_pos.w = w;
 351         info->dst_pos.h = h;
 352         info->transform = TDM_TRANSFORM_NORMAL;
 353
 354         return true;
 355 }
 356
 357 bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 358 {
 359         tdm_info_layer old_info, info;
 360
 361         TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
 362
 363         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
 364         TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
 365
 366         if (memcmp(&old_info, &info, sizeof info)) {
 367                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
 368
 369                 tdm_output *output;
 370                 tdm_error ret;
 371                 int index = -1;
 372                 unsigned int pipe = 0;
 373                 output = tdm_layer_get_output(layer, &ret);
 374                 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 375                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_index(layer, &index) == TDM_ERROR_NONE);
 376                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
 377                 TDM_INFO("filling output(%d) layer(%d) info done: src_config(%dx%d: %d,%d %dx%d: %c%c%c%c) dst_pos(%d,%d %dx%d) transform(%s)",
 378                                  pipe, index,
 379                                  info.src_config.size.h, info.src_config.size.v,
 380                                  info.src_config.pos.x, info.src_config.pos.y, info.src_config.pos.w, info.src_config.pos.h,
 381                                  FOURCC_STR(info.src_config.format),
 382                                  info.dst_pos.x, info.dst_pos.y, info.dst_pos.w, info.dst_pos.h,
 383                                  tdm_transform_str(info.transform));
 384         }
 385
 386         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE);
 387
 388         return true;
 389 }
 390
 391 bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos)
 392 {
 393         tdm_info_layer old_info, info;
 394
 395         TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
 396         TDM_UT_RETURN_FALSE_IF_FAIL(pos != NULL);
 397
 398         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
 399         TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
 400
 401         info.dst_pos.x = pos->x;
 402         info.dst_pos.y = pos->y;
 403         TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.w = pos->w);
 404         TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.h = pos->h);
 405
 406         if (memcmp(&old_info, &info, sizeof info)) {
 407                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
 408
 409                 tdm_output *output;
 410                 tdm_error ret;
 411                 int index = -1;
 412                 unsigned int pipe = 0;
 413                 output = tdm_layer_get_output(layer, &ret);
 414                 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 415                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_index(layer, &index) == TDM_ERROR_NONE);
 416                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
 417                 TDM_INFO("filling output(%d) layer(%d) info done: src_config(%dx%d: %d,%d %dx%d: %c%c%c%c) dst_pos(%d,%d %dx%d) transform(%s)",
 418                                  pipe, index,
 419                                  info.src_config.size.h, info.src_config.size.v,
 420                                  info.src_config.pos.x, info.src_config.pos.y, info.src_config.pos.w, info.src_config.pos.h,
 421                                  FOURCC_STR(info.src_config.format),
 422                                  info.dst_pos.x, info.dst_pos.y, info.dst_pos.w, info.dst_pos.h,
 423                                  tdm_transform_str(info.transform));
 424         }
 425
 426         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE);
 427
 428         return true;
 429 }
 430
 431 bool ut_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 432 {
 433         tdm_info_layer old_info, info;
 434
 435         TDM_UT_RETURN_FALSE_IF_FAIL(buffer_queue != NULL);
 436
 437         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
 438         TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true);
 439
 440         if (memcmp(&old_info, &info, sizeof info))
 441                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
 442
 443         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer_queue(layer, buffer_queue) == TDM_ERROR_NONE);
 444
 445         return true;
 446 }
 447
 448 bool ut_tdm_layer_is_avaiable(tdm_layer *layer)
 449 {
 450         tdm_error ret;
 451         tdm_output *output = tdm_layer_get_output(layer, &ret);
 452         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 453         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 454
 455         /* only check if connected */
 456         return ut_tdm_output_is_connected(output);
 457 }
 458
 459 TEST_P(TDMLayer, LayerGetOutput)
 460 {
 461         TDM_UT_SKIP_FLAG(has_layers);
 462
 463         for (int l = 0; l < layer_count; l++) {
 464                 tdm_error ret;
 465                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
 466                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 467                 ASSERT_NE(output, NULL);
 468         }
 469 }
 470
 471 TEST_P(TDMLayer, LayerGetOutputNullObject)
 472 {
 473         TDM_UT_SKIP_FLAG(has_layers);
 474
 475         tdm_error ret;
 476         tdm_output *output = tdm_layer_get_output(NULL, &ret);
 477         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 478         ASSERT_EQ(output, NULL);
 479 }
 480
 481 TEST_P(TDMLayer, LayerGetOutputNullParam)
 482 {
 483         TDM_UT_SKIP_FLAG(has_layers);
 484
 485         for (int l = 0; l < layer_count; l++) {
 486                 tdm_output *output = tdm_layer_get_output(layers[l], NULL);
 487                 ASSERT_NE(output, NULL);
 488         }
 489 }
 490
 491 TEST_P(TDMLayer, LayerGetCapabilities)
 492 {
 493         TDM_UT_SKIP_FLAG(has_layers);
 494
 495         for (int l = 0; l < layer_count; l++) {
 496                 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 497                 ASSERT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
 498                 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
 499         }
 500 }
 501
 502 TEST_P(TDMLayer, LayerGetCapabilitiesNullObject)
 503 {
 504         TDM_UT_SKIP_FLAG(has_layers);
 505
 506         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 507         ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 508         ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE);
 509 }
 510
 511 TEST_P(TDMLayer, LayerGetCapabilitiesNullOther)
 512 {
 513         TDM_UT_SKIP_FLAG(has_layers);
 514         ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 515 }
 516
 517 TEST_P(TDMLayer, LayerGetAvailableFormats)
 518 {
 519         TDM_UT_SKIP_FLAG(has_layers);
 520
 521         for (int l = 0; l < layer_count; l++) {
 522                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 523                         continue;
 524                 const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 525                 int count = TDM_UT_INVALID_VALUE;
 526                 ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
 527                 ASSERT_NE(formats, NULL);
 528                 ASSERT_GT(count, 0);
 529         }
 530 }
 531
 532 TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject)
 533 {
 534         TDM_UT_SKIP_FLAG(has_layers);
 535
 536         const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 537         int count = TDM_UT_INVALID_VALUE;
 538         ASSERT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
 539         ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
 540         ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
 541 }
 542
 543 TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
 544 {
 545         TDM_UT_SKIP_FLAG(has_layers);
 546         if (!ut_tdm_layer_is_avaiable(layers[0]))
 547                 return;
 548         ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 549 }
 550
 551 TEST_P(TDMLayer, LayerGetAvailableProperties)
 552 {
 553         TDM_UT_SKIP_FLAG(has_layers);
 554
 555         for (int l = 0; l < layer_count; l++) {
 556                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 557                         continue;
 558                 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 559                 int count = TDM_UT_INVALID_VALUE;
 560                 ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
 561                 ASSERT_GE(count, 0);
 562                 if (count > 0)
 563                         ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
 564         }
 565 }
 566
 567 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullObject)
 568 {
 569         TDM_UT_SKIP_FLAG(has_layers);
 570
 571         const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 572         int count = TDM_UT_INVALID_VALUE;
 573         ASSERT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
 574         ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
 575         ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
 576 }
 577
 578 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther)
 579 {
 580         TDM_UT_SKIP_FLAG(has_layers);
 581
 582         ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 583 }
 584
 585 TEST_P(TDMLayer, LayerGetZpos)
 586 {
 587         TDM_UT_SKIP_FLAG(has_layers);
 588
 589         bool *check_table = (bool*)calloc(layer_count, output_count);
 590         ASSERT_NE(check_table, NULL);
 591
 592         for (int l = 0; l < layer_count; l++) {
 593                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 594                         continue;
 595                 unsigned int pipe = ut_tdm_layer_get_output_pipe(layers[l]);
 596                 int zpos = TDM_UT_INVALID_VALUE;
 597                 EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE);
 598                 EXPECT_TRUE(zpos != TDM_UT_INVALID_VALUE);
 599                 if (ut_tdm_layer_is_video_layer(layers[l]))
 600                         continue;
 601                 EXPECT_TRUE(zpos >= 0);
 602                 EXPECT_TRUE(pipe < (unsigned int)output_count);
 603                 EXPECT_TRUE(*(check_table + pipe * layer_count + zpos) == false);
 604                 *(check_table + pipe * layer_count + zpos) = true;
 605         }
 606
 607         free(check_table);
 608 }
 609
 610 TEST_P(TDMLayer, LayerGetZposNullObject)
 611 {
 612         TDM_UT_SKIP_FLAG(has_layers);
 613
 614         int zpos = TDM_UT_INVALID_VALUE;
 615         ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
 616         ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE);
 617 }
 618
 619 TEST_P(TDMLayer, LayerGetZposNullParam)
 620 {
 621         TDM_UT_SKIP_FLAG(has_layers);
 622
 623         ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 624 }
 625
 626 TEST_P(TDMLayer, DISABLED_LayerSetProperty)
 627 {
 628 }
 629
 630 TEST_P(TDMLayer, LayerSetPropertyNullObject)
 631 {
 632         tdm_value value = {.s32 = 0};
 633
 634         ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
 635 }
 636
 637 TEST_P(TDMLayer, LayerGetProperty)
 638 {
 639         TDM_UT_SKIP_FLAG(has_layers);
 640
 641         for (int l = 0; l < layer_count; l++) {
 642                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 643                         continue;
 644
 645                 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 646                 int count = TDM_UT_INVALID_VALUE;
 647                 ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
 648                 ASSERT_GE(count, 0);
 649                 if (count > 0) {
 650                         ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
 651
 652                         for (int i = 0; i < count; i++) {
 653                                 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
 654                                 ASSERT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
 655                                 ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
 656                         }
 657                 }
 658         }
 659 }
 660
 661 TEST_P(TDMLayer, LayerGetPropertyNullObject)
 662 {
 663         TDM_UT_SKIP_FLAG(has_layers);
 664
 665         tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
 666         ASSERT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
 667         ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
 668 }
 669
 670 TEST_P(TDMLayer, LayerGetPropertyNullOther)
 671 {
 672         TDM_UT_SKIP_FLAG(has_layers);
 673
 674         ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
 675 }
 676
 677 TEST_P(TDMLayer, LayerSetInfo)
 678 {
 679         TDM_UT_SKIP_FLAG(has_layers);
 680
 681         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 682
 683         for (int l = 0; l < layer_count; l++) {
 684                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 685                         continue;
 686
 687                 tdm_info_layer info;
 688                 ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
 689                 ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
 690         }
 691 }
 692
 693 TEST_P(TDMLayer, LayerSetInfoNullObject)
 694 {
 695         TDM_UT_SKIP_FLAG(has_layers);
 696
 697         tdm_info_layer info;
 698         memset(&info, 0, sizeof info);
 699         ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
 700 }
 701
 702 TEST_P(TDMLayer, LayerSetInfoNullOther)
 703 {
 704         TDM_UT_SKIP_FLAG(has_layers);
 705
 706         ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 707 }
 708
 709 TEST_P(TDMLayer, DISABLED_LayerGetInfo)
 710 {
 711 }
 712
 713 TEST_P(TDMLayer, LayerGetInfoNullObject)
 714 {
 715         TDM_UT_SKIP_FLAG(has_layers);
 716
 717         tdm_info_layer temp;
 718
 719         ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
 720 }
 721
 722 TEST_P(TDMLayer, LayerGetInfoNullParam)
 723 {
 724         TDM_UT_SKIP_FLAG(has_layers);
 725
 726         ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 727 }
 728
 729 TEST_P(TDMLayer, LayerGetBufferFlags)
 730 {
 731         TDM_UT_SKIP_FLAG(has_layers);
 732
 733         for (int l = 0; l < layer_count; l++) {
 734                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 735                         continue;
 736
 737                 unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
 738                 ASSERT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
 739                 ASSERT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
 740         }
 741 }
 742
 743 TEST_P(TDMLayer, LayerGetBufferFlagsNullObject)
 744 {
 745         TDM_UT_SKIP_FLAG(has_layers);
 746
 747         unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
 748         ASSERT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
 749         ASSERT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
 750 }
 751
 752 TEST_P(TDMLayer, LayerGetBufferFlagsNullOther)
 753 {
 754         TDM_UT_SKIP_FLAG(has_layers);
 755
 756         ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 757 }
 758
 759 static void
 760 _ut_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence,
 761                                                 unsigned int tv_sec, unsigned int tv_usec,
 762                                                 void *user_data)
 763 {
 764         bool *done = (bool*)user_data;
 765         if (done)
 766                 *done = true;
 767 }
 768
 769 TEST_P(TDMLayer, LayerSetBuffer)
 770 {
 771         TDM_UT_SKIP_FLAG(has_layers);
 772
 773         tdm_error ret;
 774
 775         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 776
 777         for (int l = 0; l < layer_count; l++) {
 778                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 779                         continue;
 780
 781                 int next_buffer = 0;
 782
 783                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
 784                         continue;
 785                 if (ut_tdm_layer_is_video_layer(layers[l]))
 786                         continue;
 787
 788                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 789
 790                 /* set buffer & commit for 100 times */
 791                 for (int t = 0; t < 10; t++) {
 792                         tbm_surface_h displaying_buffer = NULL;
 793                         ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
 794                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 795                         while (displaying_buffer != buffers[next_buffer]) {
 796                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 797                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
 798                                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 799                         }
 800                         next_buffer++;
 801                         if (next_buffer == 3)
 802                                 next_buffer = 0;
 803                 }
 804
 805                 DestroyBuffers();
 806         }
 807 }
 808
 809 TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit)
 810 {
 811         TDM_UT_SKIP_FLAG(has_layers);
 812
 813         tdm_error ret;
 814
 815         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 816
 817         for (int l = 0; l < layer_count; l++) {
 818                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 819                         continue;
 820
 821                 int next_buffer = 0;
 822
 823                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
 824                         continue;
 825                 if (ut_tdm_layer_is_video_layer(layers[l]))
 826                         continue;
 827
 828                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 829
 830                 /* set buffer & commit for 10 times */
 831                 for (int t = 0; t < 10; t++) {
 832                         tbm_surface_h displaying_buffer = NULL;
 833                         ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 834                         if (next_buffer == 3)
 835                                 next_buffer = 0;
 836                         ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
 837                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 838                         while (displaying_buffer != buffers[next_buffer]) {
 839                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 840                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
 841                                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 842                         }
 843                         next_buffer++;
 844                         if (next_buffer == 3)
 845                                 next_buffer = 0;
 846                 }
 847
 848                 DestroyBuffers();
 849         }
 850 }
 851
 852 TEST_P(TDMLayer, LayerSetBufferNullObject)
 853 {
 854         TDM_UT_SKIP_FLAG(has_layers);
 855
 856         tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 857         ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
 858 }
 859
 860 TEST_P(TDMLayer, LayerSetBufferNullOther)
 861 {
 862         TDM_UT_SKIP_FLAG(has_layers);
 863
 864         ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 865 }
 866
 867 TEST_P(TDMLayer, LayerUnsetBuffer)
 868 {
 869         TDM_UT_SKIP_FLAG(has_layers);
 870
 871         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 872
 873         for (int l = 0; l < layer_count; l++) {
 874                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 875                         continue;
 876
 877                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 878         }
 879 }
 880
 881 TEST_P(TDMLayer, LayerUnsetBufferNullObject)
 882 {
 883         TDM_UT_SKIP_FLAG(has_layers);
 884
 885         ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
 886 }
 887
 888 TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit)
 889 {
 890         TDM_UT_SKIP_FLAG(has_layers);
 891
 892         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 893
 894         for (int l = 0; l < layer_count; l++) {
 895                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 896                         continue;
 897
 898                 int next_buffer = 0;
 899
 900                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
 901                         continue;
 902                 if (ut_tdm_layer_is_video_layer(layers[l]))
 903                         continue;
 904                 if (ut_tdm_layer_is_primary_layer(layers[l]))
 905                         continue;
 906
 907                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 908
 909                 /* set buffer & commit for 10 times */
 910                 for (int t = 0; t < 10; t++) {
 911                         ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 912                         if (next_buffer == 3)
 913                                 next_buffer = 0;
 914                         ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 915                         if (next_buffer == 3)
 916                                 next_buffer = 0;
 917                 }
 918
 919                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 920
 921                 DestroyBuffers();
 922         }
 923 }
 924
 925 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit)
 926 {
 927         TDM_UT_SKIP_FLAG(has_layers);
 928
 929         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 930
 931         for (int l = 0; l < layer_count; l++) {
 932                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 933                         continue;
 934
 935                 int next_buffer = 0;
 936
 937                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
 938                         continue;
 939                 if (ut_tdm_layer_is_video_layer(layers[l]))
 940                         continue;
 941                 if (ut_tdm_layer_is_primary_layer(layers[l]))
 942                         continue;
 943
 944                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 945
 946                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 947                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 948                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 949
 950                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 951
 952                 DestroyBuffers();
 953         }
 954 }
 955
 956 /* drmModePageFlip can't be done twice in a vblank */
 957 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit)
 958 {
 959         TDM_UT_SKIP_FLAG(has_layers);
 960
 961         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 962
 963         for (int l = 0; l < layer_count; l++) {
 964                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 965                         continue;
 966
 967                 int next_buffer = 0;
 968
 969                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
 970                         continue;
 971                 if (ut_tdm_layer_is_video_layer(layers[l]))
 972                         continue;
 973                 if (ut_tdm_layer_is_primary_layer(layers[l]))
 974                         continue;
 975
 976                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 977
 978                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 979                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 980
 981                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 982                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 983
 984                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 985
 986                 DestroyBuffers();
 987         }
 988 }
 989
 990 /* drmModePageFlip can't be done twice in a vblank */
 991 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer)
 992 {
 993         TDM_UT_SKIP_FLAG(has_layers);
 994
 995         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 996
 997         for (int l = 0; l < layer_count; l++) {
 998                 if (!ut_tdm_layer_is_avaiable(layers[l]))
 999                         continue;
1000
1001                 int next_buffer = 0;
1002
1003                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1004                         continue;
1005                 if (ut_tdm_layer_is_video_layer(layers[l]))
1006                         continue;
1007                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1008                         continue;
1009
1010                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1011
1012                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1013                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1014
1015                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1016                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1017
1018                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
1019
1020                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1021
1022                 DestroyBuffers();
1023         }
1024 }
1025
1026 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone)
1027 {
1028         TDM_UT_SKIP_FLAG(has_layers);
1029
1030         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1031
1032         for (int l = 0; l < layer_count; l++) {
1033                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1034                         continue;
1035
1036                 int next_buffer = 0;
1037                 bool done;
1038
1039                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1040                         continue;
1041                 if (ut_tdm_layer_is_video_layer(layers[l]))
1042                         continue;
1043                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1044                         continue;
1045
1046                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1047
1048                 /* set buffer & commit for 10 times */
1049                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1050                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1051
1052                 done = false;
1053                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1054                 while (!done) {
1055                         ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1056                 }
1057
1058                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1059
1060                 DestroyBuffers();
1061         }
1062 }
1063
1064 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit)
1065 {
1066         TDM_UT_SKIP_FLAG(has_layers);
1067
1068         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1069
1070         for (int l = 0; l < layer_count; l++) {
1071                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1072                         continue;
1073
1074                 int next_buffer = 0;
1075                 bool done;
1076
1077                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1078                         continue;
1079                 if (ut_tdm_layer_is_video_layer(layers[l]))
1080                         continue;
1081                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1082                         continue;
1083
1084                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1085
1086                 /* set buffer & commit for 10 times */
1087                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1088                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1089
1090                 done = false;
1091                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1092                 while (!done) {
1093                         ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1094                 }
1095
1096                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1097                 next_buffer = 0;
1098                 ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1099
1100                 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1101
1102                 DestroyBuffers();
1103         }
1104 }
1105
1106 TEST_P(TDMLayer, LayerCommitDPMSOff)
1107 {
1108         TDM_UT_SKIP_FLAG(has_layers);
1109
1110         tdm_error ret;
1111         tdm_output *output = tdm_layer_get_output(layers[0], &ret);
1112         ASSERT_EQ(ret, TDM_ERROR_NONE);
1113         ASSERT_NE(output, NULL);
1114
1115         if (!ut_tdm_output_is_connected(output))
1116                 return;
1117
1118         EXPECT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true);
1119
1120         EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
1121
1122         EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF);
1123
1124         EXPECT_TRUE(ut_tdm_output_unset(dpy, output) == true);
1125 }
1126
1127 TEST_P(TDMLayer, LayerCommitNullObject)
1128 {
1129         TDM_UT_SKIP_FLAG(has_layers);
1130
1131         ASSERT_EQ(tdm_layer_commit(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1132 }
1133
1134 TEST_P(TDMLayer, LayerCommitNullOther)
1135 {
1136         TDM_UT_SKIP_FLAG(has_layers);
1137
1138         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1139
1140         ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
1141 }
1142
1143 TEST_P(TDMLayer, LayerIsCommittingNullObject)
1144 {
1145         TDM_UT_SKIP_FLAG(has_layers);
1146
1147         unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE;
1148         ASSERT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
1149         ASSERT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
1150 }
1151
1152 TEST_P(TDMLayer, LayerIsCommittingNullOther)
1153 {
1154         TDM_UT_SKIP_FLAG(has_layers);
1155
1156         ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1157 }
1158
1159 TEST_P(TDMLayer, LayerRemoveCommitHandler)
1160 {
1161         TDM_UT_SKIP_FLAG(has_layers);
1162
1163         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1164
1165         for (int l = 0; l < layer_count; l++) {
1166                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1167                         continue;
1168
1169                 tdm_error ret;
1170                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1171                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1172                 ASSERT_NE(output, NULL);
1173
1174                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1175                         continue;
1176                 if (ut_tdm_layer_is_video_layer(layers[l]))
1177                         continue;
1178                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1179                         continue;
1180
1181                 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
1182
1183                 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true);
1184
1185                 for (int t = 0; t < 10; t++) {
1186                         bool done1 = false, done2 = false, done3 = false;
1187                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1188                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1189                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1190                         ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1191                         while (!done1 || done2 || !done3) {
1192                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1193                         }
1194                 }
1195
1196                 DestroyBuffers();
1197         }
1198 }
1199
1200 TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData)
1201 {
1202         TDM_UT_SKIP_FLAG(has_layers);
1203
1204         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1205
1206         for (int l = 0; l < layer_count; l++) {
1207                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1208                         continue;
1209
1210                 tdm_error ret;
1211                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1212                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1213                 ASSERT_NE(output, NULL);
1214
1215                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1216                         continue;
1217                 if (ut_tdm_layer_is_video_layer(layers[l]))
1218                         continue;
1219                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1220                         continue;
1221
1222                 for (int t = 0; t < 10; t++) {
1223                         bool done1 = false, done2 = false, done3 = false;
1224                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1225                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1226                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1227                         ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1228                         while (!done1 || !done2 || !done3) {
1229                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1230                         }
1231                 }
1232         }
1233 }
1234 static void
1235 _ut_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence,
1236                                                  unsigned int tv_sec, unsigned int tv_usec,
1237                                                  void *user_data)
1238 {
1239         bool *done = (bool*)user_data;
1240         if (done)
1241                 *done = true;
1242         ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _ut_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
1243 }
1244
1245 TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
1246 {
1247         TDM_UT_SKIP_FLAG(has_layers);
1248
1249         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1250
1251         for (int l = 0; l < layer_count; l++) {
1252                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1253                         continue;
1254
1255                 tdm_error ret;
1256                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1257                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1258                 ASSERT_NE(output, NULL);
1259
1260                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1261                         continue;
1262                 if (ut_tdm_layer_is_video_layer(layers[l]))
1263                         continue;
1264                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1265                         continue;
1266
1267                 for (int t = 0; t < 10; t++) {
1268                         bool done1 = false, done2 = false, done3 = false;
1269                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
1270                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
1271                         ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
1272                         while (!done1 || !done2 || !done3) {
1273                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1274                         }
1275                 }
1276         }
1277 }
1278
1279 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject)
1280 {
1281         TDM_UT_SKIP_FLAG(has_layers);
1282
1283         ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1284 }
1285
1286 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
1287 {
1288         TDM_UT_SKIP_FLAG(has_layers);
1289
1290         ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
1291 }
1292
1293 TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject)
1294 {
1295         TDM_UT_SKIP_FLAG(has_layers);
1296
1297         tbm_surface_h displaying_buffer;
1298         tdm_error ret;
1299         displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret);
1300         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1301         ASSERT_EQ(displaying_buffer, NULL);
1302 }
1303
1304 TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther)
1305 {
1306         TDM_UT_SKIP_FLAG(has_layers);
1307
1308         tbm_surface_h displaying_buffer;
1309         displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL);
1310         ASSERT_EQ(displaying_buffer, NULL);
1311 }
1312
1313 TEST_P(TDMLayer, LayerIsUsableNullObject)
1314 {
1315         TDM_UT_SKIP_FLAG(has_layers);
1316
1317         unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE;
1318         ASSERT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
1319         ASSERT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
1320 }
1321
1322 TEST_P(TDMLayer, LayerSetBufferQueue)
1323 {
1324         TDM_UT_SKIP_FLAG(has_layers);
1325
1326         tdm_error ret;
1327
1328         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1329
1330         for (int l = 0; l < layer_count; l++) {
1331                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1332                         continue;
1333
1334                 tbm_surface_h buffer;
1335                 tbm_surface_h displaying_buffer;
1336
1337                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1338                         continue;
1339                 if (ut_tdm_layer_is_video_layer(layers[l]))
1340                         continue;
1341                 if (ut_tdm_layer_is_primary_layer(layers[l]))
1342                         continue;
1343
1344                 ASSERT_EQ(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
1345                 ASSERT_NE(buffer_queue, NULL);
1346
1347                 ASSERT_EQ(ut_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
1348
1349                 ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
1350
1351                 for (int t = 0; t < 10; t++) {
1352                         ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1353                         ASSERT_NE(buffer, NULL);
1354                         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
1355                         ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1356
1357                         displaying_buffer = NULL;
1358                         while (displaying_buffer != buffer) {
1359                                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1360                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
1361                                 ASSERT_EQ(ret, TDM_ERROR_NONE);
1362                         }
1363                 }
1364
1365                 ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
1366
1367                 DestroyBuffers();
1368         }
1369 }
1370
1371 TEST_P(TDMLayer, LayerSetBufferQueueTwice)
1372 {
1373         TDM_UT_SKIP_FLAG(has_layers);
1374
1375         ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1376
1377         for (int l = 0; l < layer_count; l++) {
1378                 tbm_surface_queue_h buffer_queue1 = NULL;
1379                 tbm_surface_queue_h buffer_queue2 = NULL;
1380
1381                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1382                         continue;
1383                 if (ut_tdm_layer_is_cursor_layer(layers[l]))
1384                         continue;
1385                 if (ut_tdm_layer_is_video_layer(layers[l]))
1386                         continue;
1387
1388                 EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true);
1389                 EXPECT_TRUE(buffer_queue1 != NULL);
1390                 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue1) == TDM_ERROR_NONE);
1391
1392                 EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true);
1393                 EXPECT_TRUE(buffer_queue2 != NULL);
1394                 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue2) == TDM_ERROR_NONE);
1395
1396                 if (buffer_queue1)
1397                         tbm_surface_queue_destroy(buffer_queue1);
1398                 if (buffer_queue2)
1399                         tbm_surface_queue_destroy(buffer_queue2);
1400         }
1401 }
1402
1403 TEST_P(TDMLayer, LayerSetBufferQueueNullObject)
1404 {
1405         TDM_UT_SKIP_FLAG(has_layers);
1406
1407         tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE;
1408
1409         ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
1410 }
1411
1412 TEST_P(TDMLayer, LayerSetBufferQueueNullOther)
1413 {
1414         TDM_UT_SKIP_FLAG(has_layers);
1415
1416         ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1417 }
1418
1419 TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject)
1420 {
1421         TDM_UT_SKIP_FLAG(has_layers);
1422
1423         ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
1424 }
1425
1426 TEST_P(TDMLayer, LayerIsUsableNullOther)
1427 {
1428         TDM_UT_SKIP_FLAG(has_layers);
1429
1430         ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1431 }
1432
1433 TEST_P(TDMLayer, LayerSetVideoPos)
1434 {
1435         TDM_UT_SKIP_FLAG(has_layers);
1436
1437         for (int l = 0; l < layer_count; ++l) {
1438                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1439                         continue;
1440
1441                 if (!ut_tdm_layer_is_video_layer(layers[l]))
1442                         continue;
1443                 ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
1444         }
1445 }
1446
1447 TEST_P(TDMLayer, LayerSetVideoPosNullObject)
1448 {
1449         TDM_UT_SKIP_FLAG(has_layers);
1450
1451         ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
1452 }
1453
1454 TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer)
1455 {
1456         TDM_UT_SKIP_FLAG(has_layers);
1457
1458         for (int l = 0; l < layer_count; ++l) {
1459                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1460                         continue;
1461
1462                 if (ut_tdm_layer_is_video_layer(layers[l]))
1463                         continue;
1464
1465                 ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
1466         }
1467 }
1468
1469 TEST_P(TDMLayer, LayerCreateCapture)
1470 {
1471         TDM_UT_SKIP_FLAG(has_layers);
1472
1473         for (int l = 0; l < layer_count; ++l) {
1474                 tdm_error ret;
1475                 tdm_capture *capture;
1476
1477                 if (!ut_tdm_layer_is_avaiable(layers[l]))
1478                         continue;
1479
1480                 capture = tdm_layer_create_capture(layers[l], &ret);
1481                 if (ret == TDM_ERROR_NONE)
1482                         ASSERT_NE(capture, NULL);
1483         }
1484 }
1485
1486 TEST_P(TDMLayer, LayerCreateCaptureNullObject)
1487 {
1488         TDM_UT_SKIP_FLAG(has_layers);
1489
1490         tdm_error ret;
1491         tdm_capture *capture = tdm_layer_create_capture(NULL, &ret);
1492         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1493         ASSERT_EQ(capture, NULL);
1494 }
1495
1496 #ifdef TDM_UT_TEST_WITH_PARAMS
1497 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1498                                                 TDMLayer,
1499                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1500 #else
1501 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1502                                                 TDMLayer,
1503                                                 Values(TDM_DEFAULT_MODULE));
1504 #endif
1505
1506 /* LCOV_EXCL_END */