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