haltests/src/tc_tdm_hwc.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 HWC_WIN_NUM 5
  36
  37 class TDMHwc : public TDMOutput
  38 {
  39 public:
  40         TDMHwc();
  41         void SetUp(void);
  42         void TearDown(void);
  43
  44         tdm_error error;
  45 };
  46
  47 TDMHwc::TDMHwc()
  48 {
  49         error = TDM_ERROR_NONE;
  50 }
  51
  52 void TDMHwc::SetUp(void)
  53 {
  54         TDMOutput::SetUp();
  55 }
  56
  57 void TDMHwc::TearDown(void)
  58 {
  59         TDMOutput::TearDown();
  60 }
  61
  62 static void
  63 _tc_tdm_hwc_commit_cb(tdm_hwc *hwc, unsigned int sequence,
  64                                                 unsigned int tv_sec, unsigned int tv_usec,
  65                                                 void *user_data)
  66 {
  67         bool *done = (bool*)user_data;
  68         if (done)
  69                 *done = true;
  70 }
  71
  72 /* tdm_hwc_window * tdm_hwc_create_window(tdm_output *output, tdm_error *error); */
  73 TEST_P(TDMHwc, CreateWindowFailNull)
  74 {
  75         TDM_UT_SKIP_FLAG(has_outputs);
  76
  77         EXPECT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
  78         EXPECT_NE(TDM_ERROR_NONE, error);
  79 }
  80
  81 TEST_P(TDMHwc, CreateWindowSuccessful)
  82 {
  83         TDM_UT_SKIP_FLAG(has_outputs);
  84
  85         tdm_hwc *hwc = NULL;
  86         tdm_error error;
  87         tdm_hwc_window * hw = NULL;
  88
  89         for (int o = 0; o < output_count; o++) {
  90                 hwc = tdm_output_get_hwc(outputs[o], &error);
  91                 if (hwc) {
  92                         hw = tdm_hwc_create_window(hwc, &error);
  93                         EXPECT_EQ(TDM_ERROR_NONE, error);
  94                         tdm_hwc_window_destroy(hw);
  95                 } else {
  96                         EXPECT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
  97                         EXPECT_NE(TDM_ERROR_NONE, error);
  98                 }
  99         }
 100 }
 101
 102 /* tdm_hwc_get_supported_formats() */
 103 TEST_P(TDMHwc, GetSupportedFormatsFailNull)
 104 {
 105         TDM_UT_SKIP_FLAG(has_outputs);
 106
 107         tdm_error error;
 108
 109         error = tdm_hwc_get_video_supported_formats(NULL, NULL, NULL);
 110         EXPECT_NE(TDM_ERROR_NONE, error);
 111 }
 112
 113 TEST_P(TDMHwc, GetSupportedFormatsSuccessful)
 114 {
 115         TDM_UT_SKIP_FLAG(has_outputs);
 116
 117         tdm_hwc *hwc = NULL;
 118         tdm_error error = TDM_ERROR_NONE;
 119         const tbm_format *formats;
 120         int count;
 121
 122         for (int o = 0; o < output_count; o++) {
 123                 hwc = tdm_output_get_hwc(outputs[o], &error);
 124                 if (hwc) {
 125                         error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
 126                         if (error != TDM_ERROR_NOT_IMPLEMENTED) {
 127                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 128                                 if (count > 0)
 129                                         EXPECT_NE(NULL, formats);
 130                         }
 131                 } else {
 132                         error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
 133                         EXPECT_NE(TDM_ERROR_NONE, error);
 134                 }
 135         }
 136 }
 137
 138
 139 /* tdm_hwc_get_video_available_properties() */
 140 TEST_P(TDMHwc, GetAvailableVideoPropertiesFailNull)
 141 {
 142         TDM_UT_SKIP_FLAG(has_outputs);
 143
 144         tdm_hwc *hwc = NULL;
 145         tdm_error error = TDM_ERROR_NONE;
 146         const tdm_prop *props;
 147         int count;
 148
 149         for (int o = 0; o < output_count; o++) {
 150                 hwc = tdm_output_get_hwc(outputs[o], &error);
 151                 if (hwc) {
 152                         error = tdm_hwc_get_video_available_properties(NULL, &props, &count);
 153                         EXPECT_NE(TDM_ERROR_NONE, error);
 154
 155                         error = tdm_hwc_get_video_available_properties(hwc, NULL, &count);
 156                         EXPECT_NE(TDM_ERROR_NONE, error);
 157
 158                         error = tdm_hwc_get_video_available_properties(hwc, &props, NULL);
 159                         EXPECT_NE(TDM_ERROR_NONE, error);
 160                 } else {
 161                         error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
 162                         EXPECT_NE(TDM_ERROR_NONE, error);
 163                 }
 164         }
 165 }
 166
 167 TEST_P(TDMHwc, GetAvailableVideoPropertiesSuccess)
 168 {
 169         TDM_UT_SKIP_FLAG(has_outputs);
 170
 171         tdm_hwc *hwc = NULL;
 172         tdm_error error = TDM_ERROR_NONE;
 173         const tdm_prop *props;
 174         int count;
 175
 176         for (int o = 0; o < output_count; o++) {
 177                 hwc = tdm_output_get_hwc(outputs[o], &error);
 178                 if (hwc) {
 179                         error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
 180                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 181                 } else {
 182                         error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
 183                         EXPECT_NE(TDM_ERROR_NONE, error);
 184                 }
 185         }
 186 }
 187
 188 /* tdm_hwc_get_capabilities() */
 189 TEST_P(TDMHwc, GetAvailableCapabilitiesFailNull)
 190 {
 191         TDM_UT_SKIP_FLAG(has_outputs);
 192
 193         tdm_hwc *hwc = NULL;
 194         tdm_error error = TDM_ERROR_NONE;
 195         tdm_hwc_capability hwc_caps;
 196
 197         for (int o = 0; o < output_count; o++) {
 198                 hwc = tdm_output_get_hwc(outputs[o], &error);
 199                 if (hwc) {
 200                         error = tdm_hwc_get_capabilities(NULL, &hwc_caps);
 201                         EXPECT_NE(TDM_ERROR_NONE, error);
 202
 203                         error = tdm_hwc_get_capabilities(hwc, NULL);
 204                         EXPECT_NE(TDM_ERROR_NONE, error);
 205                 } else {
 206                         error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
 207                         EXPECT_NE(TDM_ERROR_NONE, error);
 208                 }
 209         }
 210 }
 211
 212 TEST_P(TDMHwc, GetAvailableCapabilitiesSuccess)
 213 {
 214         TDM_UT_SKIP_FLAG(has_outputs);
 215
 216         tdm_hwc *hwc = NULL;
 217         tdm_error error = TDM_ERROR_NONE;
 218         tdm_hwc_capability hwc_caps;
 219
 220         for (int o = 0; o < output_count; o++) {
 221                 hwc = tdm_output_get_hwc(outputs[o], &error);
 222                 if (hwc) {
 223                         error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
 224                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 225                 } else {
 226                         error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
 227                         EXPECT_NE(TDM_ERROR_NONE, error);
 228                 }
 229         }
 230 }
 231
 232 /* tdm_hwc_get_available_properties() */
 233 TEST_P(TDMHwc, GetAvailablePropertiesFailNullWin)
 234 {
 235         TDM_UT_SKIP_FLAG(has_outputs);
 236
 237         tdm_hwc *hwc = NULL;
 238         tdm_error error = TDM_ERROR_NONE;
 239         const tdm_prop *props;
 240         int count;
 241
 242         for (int o = 0; o < output_count; o++) {
 243                 hwc = tdm_output_get_hwc(outputs[o], &error);
 244                 if (hwc) {
 245                         error = tdm_hwc_get_available_properties(NULL, &props, &count);
 246                         EXPECT_NE(TDM_ERROR_NONE, error);
 247
 248                         error = tdm_hwc_get_available_properties(hwc, NULL, &count);
 249                         EXPECT_NE(TDM_ERROR_NONE, error);
 250
 251                         error = tdm_hwc_get_available_properties(hwc, &props, NULL);
 252                         EXPECT_NE(TDM_ERROR_NONE, error);
 253                 } else {
 254                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 255                         EXPECT_NE(TDM_ERROR_NONE, error);
 256                 }
 257         }
 258 }
 259
 260 TEST_P(TDMHwc, GetAvailablePropertiesSuccess)
 261 {
 262         TDM_UT_SKIP_FLAG(has_outputs);
 263
 264         tdm_hwc *hwc = NULL;
 265         tdm_error error = TDM_ERROR_NONE;
 266         const tdm_prop *props;
 267         int count;
 268
 269         for (int o = 0; o < output_count; o++) {
 270                 hwc = tdm_output_get_hwc(outputs[o], &error);
 271                 if (hwc) {
 272                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 273                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 274                 } else {
 275                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 276                         EXPECT_NE(TDM_ERROR_NONE, error);
 277                 }
 278         }
 279
 280 }
 281
 282 /* tdm_hwc_get_client_target_buffer_queue() */
 283 TEST_P(TDMHwc, GetClientTargetBufferQueueFailNullObject)
 284 {
 285         TDM_UT_SKIP_FLAG(has_outputs);
 286
 287         tdm_hwc *hwc = NULL;
 288         tdm_error error = TDM_ERROR_NONE;
 289         tbm_surface_queue_h queue = NULL;
 290
 291         for (int o = 0; o < output_count; o++) {
 292                 hwc = tdm_output_get_hwc(outputs[o], &error);
 293                 if (hwc) {
 294                         queue = tdm_hwc_get_client_target_buffer_queue(NULL, &error);
 295                         EXPECT_NE(TDM_ERROR_NONE, error);
 296                         EXPECT_EQ(NULL, queue);
 297
 298                         queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL);
 299                         EXPECT_EQ(NULL, queue);
 300                 } else {
 301                         EXPECT_EQ(NULL, queue);
 302                 }
 303         }
 304 }
 305
 306 TEST_P(TDMHwc, GetClientTargetBufferQueueFailNoHwc)
 307 {
 308         TDM_UT_SKIP_FLAG(has_outputs);
 309
 310         tdm_hwc *hwc = NULL;
 311         tdm_error error = TDM_ERROR_NONE;
 312         tbm_surface_queue_h queue = NULL;
 313
 314         for (int o = 0; o < output_count; o++) {
 315                 hwc = tdm_output_get_hwc(outputs[o], &error);
 316                 if (hwc) {
 317                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 318                         EXPECT_NE(TDM_ERROR_NONE, error);
 319                         EXPECT_EQ(NULL, queue);
 320                 } else {
 321                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 322                         EXPECT_NE(TDM_ERROR_NONE, error);
 323                         EXPECT_EQ(NULL, queue);
 324                 }
 325         }
 326 }
 327
 328 TEST_P(TDMHwc, GetClientTargetBufferQueueSuccessful)
 329 {
 330         TDM_UT_SKIP_FLAG(has_outputs);
 331
 332         tdm_hwc *hwc = NULL;
 333         tdm_error error = TDM_ERROR_NONE;
 334         tbm_surface_queue_h queue = NULL;
 335
 336         for (int o = 0; o < output_count; o++) {
 337                 if (tc_tdm_output_is_connected(outputs[o]) == false)
 338                         continue;
 339                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 340                 hwc = tdm_output_get_hwc(outputs[o], &error);
 341                 if (hwc) {
 342                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 343                         tbm_surface_queue_destroy(queue);
 344                         EXPECT_EQ(TDM_ERROR_NONE, error);
 345                         EXPECT_NE(NULL, queue);
 346
 347                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
 348                         tbm_surface_queue_destroy(queue);
 349                         EXPECT_EQ(TDM_ERROR_NONE, error);
 350                         EXPECT_NE(NULL, queue);
 351                 } else {
 352                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 353                         EXPECT_NE(TDM_ERROR_NONE, error);
 354                         EXPECT_EQ(NULL, queue);
 355
 356                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
 357                         EXPECT_NE(TDM_ERROR_NONE, error);
 358                         EXPECT_EQ(NULL, queue);
 359                 }
 360         }
 361 }
 362
 363 /* tdm_hwc_set_client_target_buffer() */
 364 TEST_P(TDMHwc, SetClientTargetBufferFailNullOutput)
 365 {
 366         TDM_UT_SKIP_FLAG(has_outputs);
 367
 368         tdm_region damage = {.num_rects = 0, .rects = NULL};
 369         tbm_surface_h target_buff = NULL;
 370
 371         target_buff = tbm_surface_internal_create_with_flags(720, 1024,
 372                                                                         TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
 373         EXPECT_NE(NULL, target_buff);
 374
 375         error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage);
 376         tbm_surface_internal_destroy(target_buff);
 377         EXPECT_NE(TDM_ERROR_NONE, error);
 378 }
 379
 380 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
 381 {
 382         TDM_UT_SKIP_FLAG(has_outputs);
 383
 384         tdm_hwc *hwc = NULL;
 385         tdm_error error = TDM_ERROR_NONE;
 386         tdm_region damage = {.num_rects = 0, .rects = NULL};
 387         const tdm_output_mode *mode = NULL;
 388         tbm_surface_h target_buff = NULL;
 389
 390         for (int o = 0; o < output_count; o++) {
 391                 if (tc_tdm_output_is_connected(outputs[o]) == false)
 392                         continue;
 393                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 394                 hwc = tdm_output_get_hwc(outputs[o], &error);
 395                 if (hwc) {
 396                         EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
 397                         EXPECT_NE(mode, NULL);
 398                         target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
 399                                                                         TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
 400                         EXPECT_NE(NULL, target_buff);
 401
 402                         error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
 403                         tbm_surface_internal_destroy(target_buff);
 404                         EXPECT_EQ(TDM_ERROR_NONE, error);
 405                 } else {
 406                         error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
 407                         EXPECT_NE(TDM_ERROR_NONE, error);
 408                 }
 409         }
 410 }
 411
 412 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff)
 413 {
 414         TDM_UT_SKIP_FLAG(has_outputs);
 415
 416         tdm_hwc *hwc = NULL;
 417         tdm_error error = TDM_ERROR_NONE;
 418         tdm_region damage = {.num_rects = 0, .rects = NULL};
 419
 420         for (int o = 0; o < output_count; o++) {
 421                 if (tc_tdm_output_is_connected(outputs[o]) == false)
 422                         continue;
 423                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 424                 hwc = tdm_output_get_hwc(outputs[o], &error);
 425                 if (hwc) {
 426                         error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
 427                         EXPECT_EQ(TDM_ERROR_NONE, error);
 428                 } else {
 429                         error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
 430                         EXPECT_NE(TDM_ERROR_NONE, error);
 431                 }
 432         }
 433 }
 434
 435 /* tdm_hwc_validate() */
 436 TEST_P(TDMHwc, ValidateFailNull)
 437 {
 438         TDM_UT_SKIP_FLAG(has_outputs);
 439
 440         tdm_hwc *hwc = NULL;
 441         tdm_error error = TDM_ERROR_NONE;
 442         uint32_t num_types;
 443
 444         error = tdm_hwc_validate(NULL, NULL, 0, &num_types);
 445         EXPECT_NE(TDM_ERROR_NONE, error);
 446
 447         for (int o = 0; o < output_count; o++) {
 448                 hwc = tdm_output_get_hwc(outputs[o], &error);
 449                 if (hwc) {
 450                         error = tdm_hwc_validate(hwc, NULL, 0, NULL);
 451                         EXPECT_NE(TDM_ERROR_NONE, error);
 452                 } else {
 453                         error = tdm_hwc_validate(hwc, NULL, 0, NULL);
 454                         EXPECT_NE(TDM_ERROR_NONE, error);
 455                 }
 456         }
 457 }
 458
 459 /* tdm_hwc_get_changed_composition_types() */
 460 TEST_P(TDMHwc, GetChangedCompositionTypesFailNull)
 461 {
 462         TDM_UT_SKIP_FLAG(has_outputs);
 463
 464         tdm_hwc *hwc = NULL;
 465         tdm_error error = TDM_ERROR_NONE;
 466         uint32_t num_elements;
 467
 468         error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL);
 469         EXPECT_NE(TDM_ERROR_NONE, error);
 470
 471         for (int o = 0; o < output_count; o++) {
 472                 hwc = tdm_output_get_hwc(outputs[o], &error);
 473                 if (hwc) {
 474                         error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
 475                         EXPECT_NE(TDM_ERROR_NONE, error);
 476                 } else {
 477                         error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
 478                         EXPECT_NE(TDM_ERROR_NONE, error);
 479                 }
 480         }
 481 }
 482
 483 /* tdm_error tdm_hwc_accept_validation() */
 484 TEST_P(TDMHwc, AcceptChangesFailNull)
 485 {
 486         TDM_UT_SKIP_FLAG(has_outputs);
 487
 488         error = tdm_hwc_accept_validation(NULL);
 489         EXPECT_NE(TDM_ERROR_NONE, error);
 490 }
 491
 492 TEST_P(TDMHwc, AcceptChangesFailNoHwc)
 493 {
 494         tdm_hwc *hwc = NULL;
 495         tdm_error error = TDM_ERROR_NONE;
 496
 497         for (int o = 0; o < output_count; o++) {
 498                 hwc = tdm_output_get_hwc(outputs[o], &error);
 499                 if (hwc) {
 500                         error = tdm_hwc_accept_validation(hwc);
 501                         EXPECT_EQ(TDM_ERROR_NONE, error);
 502                 } else {
 503                         error = tdm_hwc_accept_validation(hwc);
 504                         EXPECT_NE(TDM_ERROR_NONE, error);
 505                 }
 506         }
 507 }
 508
 509 TEST_P(TDMHwc, AcceptChangesSuccessful)
 510 {
 511         TDM_UT_SKIP_FLAG(has_outputs);
 512
 513         tdm_hwc *hwc = NULL;
 514         tdm_error error = TDM_ERROR_NONE;
 515         tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
 516         tdm_hwc_window **changed_hwc_window = NULL;
 517         tdm_hwc_window_composition *composition_types = NULL;
 518         uint32_t num_types;
 519         uint32_t get_num = 0;
 520
 521         for (int o = 0; o < output_count; o++) {
 522                 if (tc_tdm_output_is_connected(outputs[o]) == false)
 523                         continue;
 524                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 525                 hwc = tdm_output_get_hwc(outputs[o], &error);
 526                 if (hwc) {
 527                         for (int w = 0; w < HWC_WIN_NUM; w++) {
 528                                 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
 529                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 530                                 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
 531                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 532                         }
 533
 534                         error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
 535                         EXPECT_EQ(TDM_ERROR_NONE, error);
 536
 537                         if (num_types > 0) {
 538                                 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
 539                                 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 540
 541                                 get_num = num_types;
 542                                 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
 543                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 544                                 EXPECT_EQ(get_num, num_types);
 545
 546                                 error = tdm_hwc_accept_validation(hwc);
 547                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 548
 549                                 free(composition_types);
 550                                 free(changed_hwc_window);
 551                         }
 552
 553                         for (int w = 0; w < HWC_WIN_NUM; w++)
 554                                 tdm_hwc_window_destroy(hwc_wnds[w]);
 555
 556                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 557                         }
 558         }
 559 }
 560
 561 /* tdm_error tdm_hwc_commit() */
 562 TEST_P(TDMHwc, CommitFailNull)
 563 {
 564         TDM_UT_SKIP_FLAG(has_outputs);
 565
 566         error = tdm_hwc_commit(NULL, 1, NULL, NULL);
 567         EXPECT_NE(TDM_ERROR_NONE, error);
 568 }
 569
 570 TEST_P(TDMHwc, CommitSuccessful)
 571 {
 572         TDM_UT_SKIP_FLAG(has_outputs);
 573
 574         tdm_hwc *hwc = NULL;
 575         tdm_error error = TDM_ERROR_NONE;
 576         tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
 577         tdm_hwc_window **changed_hwc_window = NULL;
 578         tdm_hwc_window_composition *composition_types = NULL;
 579         uint32_t num_types;
 580         uint32_t get_num = 0;
 581
 582         for (int o = 0; o < output_count; o++) {
 583                 if (tc_tdm_output_is_connected(outputs[o]) == false)
 584                         continue;
 585                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 586                 hwc = tdm_output_get_hwc(outputs[o], &error);
 587                 if (hwc) {
 588                         for (int w = 0; w < HWC_WIN_NUM; w++) {
 589                                 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
 590                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 591                                 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
 592                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 593                         }
 594
 595                         error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
 596                         EXPECT_EQ(TDM_ERROR_NONE, error);
 597
 598                         if (num_types > 0) {
 599                                 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
 600                                 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 601
 602                                 get_num = num_types;
 603                                 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
 604                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 605                                 EXPECT_EQ(get_num, num_types);
 606
 607                                 error =  tdm_hwc_accept_validation(hwc);
 608                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 609
 610                                 free(composition_types);
 611                                 free(changed_hwc_window);
 612                         }
 613
 614                         error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
 615                         EXPECT_EQ(TDM_ERROR_NONE, error);
 616
 617                         for (int w = 0; w < HWC_WIN_NUM; w++)
 618                                 tdm_hwc_window_destroy(hwc_wnds[w]);
 619
 620                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 621                         }
 622         }
 623 }
 624
 625 /* tdm_hwc_set_property() */
 626 TEST_P(TDMHwc, SetPropertyFailNull)
 627 {
 628         TDM_UT_SKIP_FLAG(has_outputs);
 629
 630         tdm_hwc *hwc = NULL;
 631         tdm_error error = TDM_ERROR_NONE;
 632         tdm_value value;
 633
 634         value.u32 = 0;
 635
 636         for (int o = 0; o < output_count; o++) {
 637                 hwc = tdm_output_get_hwc(outputs[o], &error);
 638                 if (hwc) {
 639                         error = tdm_hwc_set_property(NULL, 0, value);
 640                         EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 641                 } else {
 642                         error = tdm_hwc_set_property(hwc, 0, value);
 643                         EXPECT_NE(TDM_ERROR_NONE, error);
 644                 }
 645         }
 646 }
 647
 648 TEST_P(TDMHwc, SetPropertySuccess)
 649 {
 650         TDM_UT_SKIP_FLAG(has_outputs);
 651
 652         tdm_hwc *hwc = NULL;
 653         tdm_error error = TDM_ERROR_NONE;
 654         const tdm_prop *props;
 655         int count;
 656         tdm_value value;
 657
 658         value.u32 = 0;
 659
 660         for (int o = 0; o < output_count; o++) {
 661                 hwc = tdm_output_get_hwc(outputs[o], &error);
 662                 if (hwc) {
 663                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 664                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 665
 666                         if (count == 0) {
 667                                 error = tdm_hwc_set_property(hwc, 0, value);
 668                                 EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 669                         } else {
 670                                 error = tdm_hwc_set_property(hwc, props[0].id, value);
 671                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 672                         }
 673                 } else {
 674                         error = tdm_hwc_set_property(hwc, 0, value);
 675                         EXPECT_NE(TDM_ERROR_NONE, error);
 676                 }
 677         }
 678 }
 679
 680 /* tdm_hwc_get_property() */
 681 TEST_P(TDMHwc, GetPropertyFailNull)
 682 {
 683         TDM_UT_SKIP_FLAG(has_outputs);
 684
 685         tdm_hwc *hwc = NULL;
 686         tdm_error error = TDM_ERROR_NONE;
 687         tdm_value value;
 688
 689         for (int o = 0; o < output_count; o++) {
 690                 hwc = tdm_output_get_hwc(outputs[o], &error);
 691                 if (hwc) {
 692                         error = tdm_hwc_get_property(NULL, 0, &value);
 693                         EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 694                 } else {
 695                         error = tdm_hwc_get_property(hwc, 0, &value);
 696                         EXPECT_NE(TDM_ERROR_NONE, error);
 697                 }
 698         }
 699 }
 700
 701 TEST_P(TDMHwc, GetPropertySuccess)
 702 {
 703         TDM_UT_SKIP_FLAG(has_outputs);
 704
 705         tdm_hwc *hwc = NULL;
 706         tdm_error error = TDM_ERROR_NONE;
 707         const tdm_prop *props;
 708         int count;
 709         tdm_value value;
 710
 711         for (int o = 0; o < output_count; o++) {
 712                 hwc = tdm_output_get_hwc(outputs[o], &error);
 713
 714                 if (hwc) {
 715                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 716                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 717
 718                         if (count == 0) {
 719                                 error = tdm_hwc_get_property(hwc, 0, &value);
 720                                 EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 721                         } else {
 722                                 error = tdm_hwc_get_property(hwc, props[0].id, &value);
 723                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 724                         }
 725                 } else {
 726                         error = tdm_hwc_get_property(hwc, 0, &value);
 727                         EXPECT_NE(TDM_ERROR_NONE, error);
 728                 }
 729         }
 730 }
 731
 732 #ifdef TDM_UT_TEST_WITH_PARAMS
 733 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
 734                                                 TDMHwc,
 735                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 736 #else
 737 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
 738                                                 TDMHwc,
 739                                                 Values(TDM_DEFAULT_MODULE));
 740 #endif
 741
 742 /* LCOV_EXCL_END */