haltests/src/tc_tdm_display.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "tc_tdm.h"
  32
  33 /* LCOV_EXCL_START */
  34
  35 TDMDisplay::TDMDisplay()
  36 {
  37         dpy = NULL;
  38         bufmgr = NULL;
  39         has_pp_cap = false;
  40         has_capture_cap = false;
  41 }
  42
  43 void TDMDisplay::SetUp(void)
  44 {
  45         tdm_error ret;
  46         int count = TDM_UT_INVALID_VALUE;
  47         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
  48
  49         TDMEnv::SetUp();
  50
  51         dpy = tdm_display_init(&ret);
  52         EXPECT_EQ(ret, TDM_ERROR_NONE);
  53         EXPECT_NE(dpy, NULL);
  54
  55         bufmgr = tbm_bufmgr_init(-1);
  56         EXPECT_NE(bufmgr, NULL);
  57
  58         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
  59         EXPECT_GT(count, 0);
  60
  61         EXPECT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
  62         has_pp_cap = capabilities & TDM_DISPLAY_CAPABILITY_PP;
  63         has_capture_cap = capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
  64 }
  65
  66 void TDMDisplay::TearDown(void)
  67 {
  68         tbm_bufmgr_deinit(bufmgr);
  69         tdm_display_deinit(dpy);
  70
  71         EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
  72
  73         TDMEnv::TearDown();
  74 }
  75
  76 tdm_error
  77 tc_tdm_display_handle_events(tdm_display *dpy)
  78 {
  79         struct pollfd fds;
  80         int fd = -1;
  81         tdm_error ret;
  82         int result;
  83
  84         ret = tdm_display_get_fd(dpy, &fd);
  85         TDM_UT_RETURN_VAL_IF_FAIL(fd >= 0, ret);
  86
  87         fds.events = POLLIN;
  88         fds.fd = fd;
  89         fds.revents = 0;
  90
  91         do {
  92                 result = poll(&fds, 1, 3000);
  93         } while (result == -1 && errno == EINTR);
  94
  95         if (result == 0) {
  96                 TDM_UT_ERR("polling tdm_fd timeout.");
  97                 return TDM_ERROR_TIMEOUT;
  98         }
  99
 100         return tdm_display_handle_events(dpy);
 101 }
 102
 103 bool
 104 tc_tdm_display_has_pp_capability(tdm_display *dpy)
 105 {
 106         tdm_display_capability capabilities = (tdm_display_capability)0;
 107         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
 108         return capabilities & TDM_DISPLAY_CAPABILITY_PP;
 109 }
 110
 111 bool
 112 tc_tdm_display_has_capture_capability(tdm_display *dpy)
 113 {
 114         tdm_display_capability capabilities = (tdm_display_capability)0;
 115         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
 116         return capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
 117 }
 118
 119 TEST_P(TDMDisplay, DisplayUpdate)
 120 {
 121         EXPECT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE);
 122 }
 123
 124 TEST_P(TDMDisplay, DisplayUpdateNullObject)
 125 {
 126         EXPECT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER);
 127 }
 128
 129 TEST_P(TDMDisplay, DisplayGetFDSuccesful)
 130 {
 131         int fd = TDM_UT_INVALID_VALUE;
 132         EXPECT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE);
 133         EXPECT_NE(fd, TDM_UT_INVALID_VALUE);
 134 }
 135
 136 TEST_P(TDMDisplay, DisplayGetFDNullObject)
 137 {
 138         int fd = TDM_UT_INVALID_VALUE;
 139         EXPECT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
 140         EXPECT_EQ(fd, TDM_UT_INVALID_VALUE);
 141 }
 142
 143 TEST_P(TDMDisplay, DisplayGetFDNullFD)
 144 {
 145         EXPECT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 146 }
 147
 148 /* DISABLED */
 149 TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents)
 150 {
 151         /* TODO Generate events*/
 152         EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 153 }
 154
 155 TEST_P(TDMDisplay, DisplayFlush)
 156 {
 157         tdm_display_flush(dpy);
 158 }
 159
 160 TEST_P(TDMDisplay, DisplayFlushNullObject)
 161 {
 162         tdm_display_flush(NULL);
 163 }
 164
 165 TEST_P(TDMDisplay, DisplayGetBackendInfo)
 166 {
 167         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 168         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 169         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 170
 171         EXPECT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 172         EXPECT_NE(name, (const char*)TDM_UT_INVALID_VALUE);
 173         EXPECT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE);
 174         EXPECT_NE(major, TDM_UT_INVALID_VALUE);
 175         EXPECT_NE(minor, TDM_UT_INVALID_VALUE);
 176 }
 177
 178 TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject)
 179 {
 180         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 181         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 182         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 183
 184         EXPECT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 185         EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
 186         EXPECT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE);
 187         EXPECT_EQ(major, TDM_UT_INVALID_VALUE);
 188         EXPECT_EQ(minor, TDM_UT_INVALID_VALUE);
 189 }
 190
 191 TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther)
 192 {
 193         EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 194 }
 195
 196 TEST_P(TDMDisplay, DisplayGetCapabilities)
 197 {
 198         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 199         EXPECT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
 200         EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
 201 }
 202
 203 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject)
 204 {
 205         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 206         EXPECT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 207         EXPECT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE);
 208 }
 209
 210 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther)
 211 {
 212         EXPECT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 213 }
 214
 215 TEST_P(TDMDisplay, DisplayGetPPCapabilities)
 216 {
 217         tdm_pp_capability capabilities = (tdm_pp_capability) TDM_UT_INVALID_VALUE;
 218         tdm_error ret;
 219         if (!has_pp_cap)
 220                 return;
 221         ret = tdm_display_get_pp_capabilities(dpy, &capabilities);
 222         EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 223
 224         if (ret == TDM_ERROR_NONE)
 225                 EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
 226 }
 227
 228 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject)
 229 {
 230         tdm_pp_capability capabilities = (tdm_pp_capability)TDM_UT_INVALID_VALUE;
 231         EXPECT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 232         EXPECT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE);
 233 }
 234
 235 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther)
 236 {
 237         EXPECT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 238 }
 239
 240 TEST_P(TDMDisplay, DisplayGetCaptureCapabilities)
 241 {
 242         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 243         tdm_error ret;
 244
 245         if (!has_capture_cap)
 246                 return;
 247
 248         ret = tdm_display_get_capture_capabilities(dpy, &capabilities);
 249         EXPECT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 250
 251         if (ret == TDM_ERROR_NONE)
 252                 EXPECT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 253 }
 254
 255 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullObject)
 256 {
 257         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 258         EXPECT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 259         EXPECT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 260 }
 261
 262 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther)
 263 {
 264         EXPECT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 265 }
 266
 267 TEST_P(TDMDisplay, DisplayGetMaxLayerCount)
 268 {
 269         int max_count = TDM_UT_INVALID_VALUE;
 270         EXPECT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE);
 271         EXPECT_NE(max_count, TDM_UT_INVALID_VALUE);
 272 }
 273
 274 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject)
 275 {
 276         int max_count = TDM_UT_INVALID_VALUE;
 277         EXPECT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER);
 278         EXPECT_EQ(max_count, TDM_UT_INVALID_VALUE);
 279 }
 280
 281 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther)
 282 {
 283         EXPECT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 284 }
 285
 286 TEST_P(TDMDisplay, DisplayGetOutputCount)
 287 {
 288         int count = TDM_UT_INVALID_VALUE;
 289         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 290         EXPECT_NE(count, TDM_UT_INVALID_VALUE);
 291 }
 292
 293 TEST_P(TDMDisplay, DisplayGetOutputCountNullObject)
 294 {
 295         int count = TDM_UT_INVALID_VALUE;
 296         EXPECT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
 297         EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
 298 }
 299
 300 TEST_P(TDMDisplay, DisplayGetOutputCountNullOther)
 301 {
 302         EXPECT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 303 }
 304
 305 TEST_P(TDMDisplay, DisplayGetOutput)
 306 {
 307         tdm_output *output;
 308         int o, count = TDM_UT_INVALID_VALUE;
 309         tdm_error ret;
 310
 311         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 312         EXPECT_GT(count, 0);
 313
 314         for (o = 0; o < count; o++) {
 315                 output = tdm_display_get_output(dpy, o, &ret);
 316                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 317                 EXPECT_NE(output, NULL);
 318         }
 319 }
 320
 321 TEST_P(TDMDisplay, DisplayGetOutputNullAll)
 322 {
 323         tdm_output *output;
 324         int o, count = TDM_UT_INVALID_VALUE;
 325
 326         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 327         EXPECT_GT(count, 0);
 328
 329         for (o = 0; o < count; o++) {
 330                 output = tdm_display_get_output(NULL, o, NULL);
 331                 EXPECT_EQ(output, NULL);
 332         }
 333 }
 334
 335 TEST_P(TDMDisplay, DisplayGetOutputNullObject)
 336 {
 337         tdm_output *output;
 338         tdm_error ret;
 339
 340         output = tdm_display_get_output(NULL, 0, &ret);
 341         EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 342         EXPECT_EQ(output, NULL);
 343 }
 344
 345 TEST_P(TDMDisplay, DisplayGetOutputNullOther)
 346 {
 347         tdm_output *output;
 348         int o, count = TDM_UT_INVALID_VALUE;
 349
 350         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 351         EXPECT_GT(count, 0);
 352
 353         for (o = 0; o < count; o++) {
 354                 output = tdm_display_get_output(dpy, o, NULL);
 355                 EXPECT_NE(output, NULL);
 356         }
 357 }
 358
 359 TEST_P(TDMDisplay, DisplayGetOutputWrongIndex)
 360 {
 361         tdm_output *output;
 362         tdm_error ret;
 363
 364         output = tdm_display_get_output(dpy, -1, &ret);
 365         EXPECT_EQ(ret, TDM_ERROR_NONE);
 366         EXPECT_EQ(output, NULL);
 367
 368         output = tdm_display_get_output(dpy, INT_MAX, &ret);
 369         EXPECT_EQ(ret, TDM_ERROR_NONE);
 370         EXPECT_EQ(output, NULL);
 371 }
 372
 373 TEST_P(TDMDisplay, DisplayFindOutput)
 374 {
 375         tdm_output *output;
 376         int count = TDM_UT_INVALID_VALUE;
 377         tdm_error ret;
 378
 379         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 380         EXPECT_GT(count, 0);
 381
 382         output = tdm_display_find_output(dpy, "primary", &ret);
 383         EXPECT_EQ(ret, TDM_ERROR_NONE);
 384         EXPECT_NE(output, NULL);
 385
 386         output = tdm_display_find_output(dpy, "invalid", &ret);
 387         EXPECT_EQ(ret, TDM_ERROR_NONE);
 388         EXPECT_EQ(output, NULL);
 389 }
 390
 391 TEST_P(TDMDisplay, DisplayCreatePp)
 392 {
 393         tdm_pp *pp;
 394         tdm_error ret;
 395
 396         if (!has_pp_cap)
 397                 return;
 398
 399         pp = tdm_display_create_pp(dpy, &ret);
 400         EXPECT_EQ(ret, TDM_ERROR_NONE);
 401         EXPECT_NE(pp, NULL);
 402
 403         tdm_pp_destroy(pp);
 404 }
 405
 406 TEST_P(TDMDisplay, DisplayCreatePpNullObject)
 407 {
 408         tdm_pp *pp;
 409         tdm_error ret;
 410
 411         if (!has_pp_cap)
 412                 return;
 413
 414         pp = tdm_display_create_pp(NULL, &ret);
 415         EXPECT_NE(ret, TDM_ERROR_NONE);
 416         EXPECT_EQ(pp, NULL);
 417 }
 418
 419 TEST_P(TDMDisplay, ModuleGetInfo)
 420 {
 421         tdm_output *output;
 422         int o, count = TDM_UT_INVALID_VALUE;
 423         tdm_error ret;
 424
 425         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 426         EXPECT_GT(count, 0);
 427
 428         for (o = 0; o < count; o++) {
 429                 tdm_module *module;
 430                 const char *name = (const char *)TDM_UT_INVALID_VALUE;
 431                 const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 432                 int major = TDM_UT_INVALID_VALUE;
 433                 int minor = TDM_UT_INVALID_VALUE;
 434
 435                 output = tdm_display_get_output(dpy, o, &ret);
 436                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 437                 EXPECT_NE(output, NULL);
 438
 439                 module = tdm_output_get_backend_module(output, &ret);
 440                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 441                 EXPECT_NE(module, NULL);
 442
 443                 EXPECT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 444                 EXPECT_NE(name, (const char *)TDM_UT_INVALID_VALUE);
 445                 EXPECT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE);
 446                 EXPECT_NE(major, TDM_UT_INVALID_VALUE);
 447                 EXPECT_NE(minor, TDM_UT_INVALID_VALUE);
 448         }
 449 }
 450
 451 TEST_P(TDMDisplay, ModuleGetInfoNullObject)
 452 {
 453         const char *name = (const char *)TDM_UT_INVALID_VALUE;
 454         const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 455         int major = TDM_UT_INVALID_VALUE;
 456         int minor = TDM_UT_INVALID_VALUE;
 457
 458         EXPECT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 459         EXPECT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
 460         EXPECT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE);
 461         EXPECT_EQ(major, TDM_UT_INVALID_VALUE);
 462         EXPECT_EQ(minor, TDM_UT_INVALID_VALUE);
 463 }
 464
 465 TEST_P(TDMDisplay, ModuleGetInfoNullOther)
 466 {
 467         tdm_output *output;
 468         int o, count = TDM_UT_INVALID_VALUE;
 469         tdm_error ret;
 470
 471         EXPECT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 472         EXPECT_GT(count, 0);
 473
 474         for (o = 0; o < count; o++) {
 475                 tdm_module *module;
 476
 477                 output = tdm_display_get_output(dpy, o, &ret);
 478                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 479                 EXPECT_NE(output, NULL);
 480
 481                 module = tdm_output_get_backend_module(output, &ret);
 482                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 483                 EXPECT_NE(module, NULL);
 484
 485                 EXPECT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 486         }
 487 }
 488
 489 #ifdef TDM_UT_TEST_WITH_PARAMS
 490 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 491                                                 TDMDisplay,
 492                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 493 #else
 494 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 495                                                 TDMDisplay,
 496                                                 Values(TDM_DEFAULT_MODULE));
 497 #endif
 498
 499 /* LCOV_EXCL_END */