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