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                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 338                 hwc = tdm_output_get_hwc(outputs[o], &error);
 339                 if (hwc) {
 340                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 341                         tbm_surface_queue_destroy(queue);
 342                         EXPECT_EQ(TDM_ERROR_NONE, error);
 343                         EXPECT_NE(NULL, queue);
 344
 345                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
 346                         tbm_surface_queue_destroy(queue);
 347                         EXPECT_EQ(TDM_ERROR_NONE, error);
 348                         EXPECT_NE(NULL, queue);
 349                 } else {
 350                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
 351                         EXPECT_NE(TDM_ERROR_NONE, error);
 352                         EXPECT_EQ(NULL, queue);
 353
 354                         queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
 355                         EXPECT_NE(TDM_ERROR_NONE, error);
 356                         EXPECT_EQ(NULL, queue);
 357                 }
 358         }
 359 }
 360
 361 /* tdm_hwc_set_client_target_buffer() */
 362 TEST_P(TDMHwc, SetClientTargetBufferFailNullOutput)
 363 {
 364         TDM_UT_SKIP_FLAG(has_outputs);
 365
 366         tdm_region damage = {.num_rects = 0, .rects = NULL};
 367         tbm_surface_h target_buff = NULL;
 368
 369         target_buff = tbm_surface_internal_create_with_flags(720, 1024,
 370                                                                         TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
 371         EXPECT_NE(NULL, target_buff);
 372
 373         error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage);
 374         tbm_surface_internal_destroy(target_buff);
 375         EXPECT_NE(TDM_ERROR_NONE, error);
 376 }
 377
 378 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
 379 {
 380         TDM_UT_SKIP_FLAG(has_outputs);
 381
 382         tdm_hwc *hwc = NULL;
 383         tdm_error error = TDM_ERROR_NONE;
 384         tdm_region damage = {.num_rects = 0, .rects = NULL};
 385         const tdm_output_mode *mode = NULL;
 386         tbm_surface_h target_buff = NULL;
 387
 388         for (int o = 0; o < output_count; o++) {
 389                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 390                 hwc = tdm_output_get_hwc(outputs[o], &error);
 391                 if (hwc) {
 392                         EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
 393                         EXPECT_NE(mode, NULL);
 394                         target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
 395                                                                         TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
 396                         EXPECT_NE(NULL, target_buff);
 397
 398                         error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
 399                         tbm_surface_internal_destroy(target_buff);
 400                         EXPECT_EQ(TDM_ERROR_NONE, error);
 401                 } else {
 402                         error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
 403                         EXPECT_NE(TDM_ERROR_NONE, error);
 404                 }
 405         }
 406 }
 407
 408 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff)
 409 {
 410         TDM_UT_SKIP_FLAG(has_outputs);
 411
 412         tdm_hwc *hwc = NULL;
 413         tdm_error error = TDM_ERROR_NONE;
 414         tdm_region damage = {.num_rects = 0, .rects = NULL};
 415
 416         for (int o = 0; o < output_count; o++) {
 417                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 418                 hwc = tdm_output_get_hwc(outputs[o], &error);
 419                 if (hwc) {
 420                         error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
 421                         EXPECT_EQ(TDM_ERROR_NONE, error);
 422                 } else {
 423                         error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
 424                         EXPECT_NE(TDM_ERROR_NONE, error);
 425                 }
 426         }
 427 }
 428
 429 /* tdm_hwc_validate() */
 430 TEST_P(TDMHwc, ValidateFailNull)
 431 {
 432         TDM_UT_SKIP_FLAG(has_outputs);
 433
 434         tdm_hwc *hwc = NULL;
 435         tdm_error error = TDM_ERROR_NONE;
 436         uint32_t num_types;
 437
 438         error = tdm_hwc_validate(NULL, NULL, 0, &num_types);
 439         EXPECT_NE(TDM_ERROR_NONE, error);
 440
 441         for (int o = 0; o < output_count; o++) {
 442                 hwc = tdm_output_get_hwc(outputs[o], &error);
 443                 if (hwc) {
 444                         error = tdm_hwc_validate(hwc, NULL, 0, NULL);
 445                         EXPECT_NE(TDM_ERROR_NONE, error);
 446                 } else {
 447                         error = tdm_hwc_validate(hwc, NULL, 0, NULL);
 448                         EXPECT_NE(TDM_ERROR_NONE, error);
 449                 }
 450         }
 451 }
 452
 453 /* tdm_hwc_get_changed_composition_types() */
 454 TEST_P(TDMHwc, GetChangedCompositionTypesFailNull)
 455 {
 456         TDM_UT_SKIP_FLAG(has_outputs);
 457
 458         tdm_hwc *hwc = NULL;
 459         tdm_error error = TDM_ERROR_NONE;
 460         uint32_t num_elements;
 461
 462         error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL);
 463         EXPECT_NE(TDM_ERROR_NONE, error);
 464
 465         for (int o = 0; o < output_count; o++) {
 466                 hwc = tdm_output_get_hwc(outputs[o], &error);
 467                 if (hwc) {
 468                         error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
 469                         EXPECT_NE(TDM_ERROR_NONE, error);
 470                 } else {
 471                         error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
 472                         EXPECT_NE(TDM_ERROR_NONE, error);
 473                 }
 474         }
 475 }
 476
 477 /* tdm_error tdm_hwc_accept_validation() */
 478 TEST_P(TDMHwc, AcceptChangesFailNull)
 479 {
 480         TDM_UT_SKIP_FLAG(has_outputs);
 481
 482         error = tdm_hwc_accept_validation(NULL);
 483         EXPECT_NE(TDM_ERROR_NONE, error);
 484 }
 485
 486 TEST_P(TDMHwc, AcceptChangesFailNoHwc)
 487 {
 488         tdm_hwc *hwc = NULL;
 489         tdm_error error = TDM_ERROR_NONE;
 490
 491         for (int o = 0; o < output_count; o++) {
 492                 hwc = tdm_output_get_hwc(outputs[o], &error);
 493                 if (hwc) {
 494                         error = tdm_hwc_accept_validation(hwc);
 495                         EXPECT_EQ(TDM_ERROR_NONE, error);
 496                 } else {
 497                         error = tdm_hwc_accept_validation(hwc);
 498                         EXPECT_NE(TDM_ERROR_NONE, error);
 499                 }
 500         }
 501 }
 502
 503 TEST_P(TDMHwc, AcceptChangesSuccessful)
 504 {
 505         TDM_UT_SKIP_FLAG(has_outputs);
 506
 507         tdm_hwc *hwc = NULL;
 508         tdm_error error = TDM_ERROR_NONE;
 509         tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
 510         tdm_hwc_window **changed_hwc_window = NULL;
 511         tdm_hwc_window_composition *composition_types = NULL;
 512         uint32_t num_types;
 513         uint32_t get_num = 0;
 514
 515         for (int o = 0; o < output_count; o++) {
 516                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 517                 hwc = tdm_output_get_hwc(outputs[o], &error);
 518                 if (hwc) {
 519                         for (int w = 0; w < HWC_WIN_NUM; w++) {
 520                                 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
 521                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 522                                 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
 523                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 524                         }
 525
 526                         error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
 527                         EXPECT_EQ(TDM_ERROR_NONE, error);
 528
 529                         if (num_types > 0) {
 530                                 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
 531                                 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 532
 533                                 get_num = num_types;
 534                                 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
 535                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 536                                 EXPECT_EQ(get_num, num_types);
 537
 538                                 error = tdm_hwc_accept_validation(hwc);
 539                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 540
 541                                 free(composition_types);
 542                                 free(changed_hwc_window);
 543                         }
 544
 545                         for (int w = 0; w < HWC_WIN_NUM; w++)
 546                                 tdm_hwc_window_destroy(hwc_wnds[w]);
 547
 548                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 549                         }
 550         }
 551 }
 552
 553 /* tdm_error tdm_hwc_commit() */
 554 TEST_P(TDMHwc, CommitFailNull)
 555 {
 556         TDM_UT_SKIP_FLAG(has_outputs);
 557
 558         error = tdm_hwc_commit(NULL, 1, NULL, NULL);
 559         EXPECT_NE(TDM_ERROR_NONE, error);
 560 }
 561
 562 TEST_P(TDMHwc, CommitSuccessful)
 563 {
 564         TDM_UT_SKIP_FLAG(has_outputs);
 565
 566         tdm_hwc *hwc = NULL;
 567         tdm_error error = TDM_ERROR_NONE;
 568         tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
 569         tdm_hwc_window **changed_hwc_window = NULL;
 570         tdm_hwc_window_composition *composition_types = NULL;
 571         uint32_t num_types;
 572         uint32_t get_num = 0;
 573
 574         for (int o = 0; o < output_count; o++) {
 575                 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
 576                 hwc = tdm_output_get_hwc(outputs[o], &error);
 577                 if (hwc) {
 578                         for (int w = 0; w < HWC_WIN_NUM; w++) {
 579                                 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
 580                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 581                                 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
 582                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 583                         }
 584
 585                         error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
 586                         EXPECT_EQ(TDM_ERROR_NONE, error);
 587
 588                         if (num_types > 0) {
 589                                 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
 590                                 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
 591
 592                                 get_num = num_types;
 593                                 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
 594                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 595                                 EXPECT_EQ(get_num, num_types);
 596
 597                                 error =  tdm_hwc_accept_validation(hwc);
 598                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 599
 600                                 free(composition_types);
 601                                 free(changed_hwc_window);
 602                         }
 603
 604                         error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
 605                         EXPECT_EQ(TDM_ERROR_NONE, error);
 606
 607                         for (int w = 0; w < HWC_WIN_NUM; w++)
 608                                 tdm_hwc_window_destroy(hwc_wnds[w]);
 609
 610                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 611                         }
 612         }
 613 }
 614
 615 /* tdm_hwc_set_property() */
 616 TEST_P(TDMHwc, SetPropertyFailNull)
 617 {
 618         TDM_UT_SKIP_FLAG(has_outputs);
 619
 620         tdm_hwc *hwc = NULL;
 621         tdm_error error = TDM_ERROR_NONE;
 622         tdm_value value;
 623
 624         value.u32 = 0;
 625
 626         for (int o = 0; o < output_count; o++) {
 627                 hwc = tdm_output_get_hwc(outputs[o], &error);
 628                 if (hwc) {
 629                         error = tdm_hwc_set_property(NULL, 0, value);
 630                         EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 631                 } else {
 632                         error = tdm_hwc_set_property(hwc, 0, value);
 633                         EXPECT_NE(TDM_ERROR_NONE, error);
 634                 }
 635         }
 636 }
 637
 638 TEST_P(TDMHwc, SetPropertySuccess)
 639 {
 640         TDM_UT_SKIP_FLAG(has_outputs);
 641
 642         tdm_hwc *hwc = NULL;
 643         tdm_error error = TDM_ERROR_NONE;
 644         const tdm_prop *props;
 645         int count;
 646         tdm_value value;
 647
 648         value.u32 = 0;
 649
 650         for (int o = 0; o < output_count; o++) {
 651                 hwc = tdm_output_get_hwc(outputs[o], &error);
 652                 if (hwc) {
 653                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 654                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 655
 656                         if (count == 0) {
 657                                 error = tdm_hwc_set_property(hwc, 0, value);
 658                                 EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 659                         } else {
 660                                 error = tdm_hwc_set_property(hwc, props[0].id, value);
 661                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 662                         }
 663                 } else {
 664                         error = tdm_hwc_set_property(hwc, 0, value);
 665                         EXPECT_NE(TDM_ERROR_NONE, error);
 666                 }
 667         }
 668 }
 669
 670 /* tdm_hwc_get_property() */
 671 TEST_P(TDMHwc, GetPropertyFailNull)
 672 {
 673         TDM_UT_SKIP_FLAG(has_outputs);
 674
 675         tdm_hwc *hwc = NULL;
 676         tdm_error error = TDM_ERROR_NONE;
 677         tdm_value value;
 678
 679         for (int o = 0; o < output_count; o++) {
 680                 hwc = tdm_output_get_hwc(outputs[o], &error);
 681                 if (hwc) {
 682                         error = tdm_hwc_get_property(NULL, 0, &value);
 683                         EXPECT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
 684                 } else {
 685                         error = tdm_hwc_get_property(hwc, 0, &value);
 686                         EXPECT_NE(TDM_ERROR_NONE, error);
 687                 }
 688         }
 689 }
 690
 691 TEST_P(TDMHwc, GetPropertySuccess)
 692 {
 693         TDM_UT_SKIP_FLAG(has_outputs);
 694
 695         tdm_hwc *hwc = NULL;
 696         tdm_error error = TDM_ERROR_NONE;
 697         const tdm_prop *props;
 698         int count;
 699         tdm_value value;
 700
 701         for (int o = 0; o < output_count; o++) {
 702                 hwc = tdm_output_get_hwc(outputs[o], &error);
 703
 704                 if (hwc) {
 705                         error = tdm_hwc_get_available_properties(hwc, &props, &count);
 706                         EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 707
 708                         if (count == 0) {
 709                                 error = tdm_hwc_get_property(hwc, 0, &value);
 710                                 EXPECT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
 711                         } else {
 712                                 error = tdm_hwc_get_property(hwc, props[0].id, &value);
 713                                 EXPECT_EQ(TDM_ERROR_NONE, error);
 714                         }
 715                 } else {
 716                         error = tdm_hwc_get_property(hwc, 0, &value);
 717                         EXPECT_NE(TDM_ERROR_NONE, error);
 718                 }
 719         }
 720 }
 721
 722 #ifdef TDM_UT_TEST_WITH_PARAMS
 723 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
 724                                                 TDMHwc,
 725                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 726 #else
 727 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
 728                                                 TDMHwc,
 729                                                 Values(TDM_DEFAULT_MODULE));
 730 #endif
 731
 732 /* LCOV_EXCL_END */