utests/src/ut_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 "ut_tdm.h"
  32
  33 TDMDisplay::TDMDisplay()
  34 {
  35         dpy = NULL;
  36         bufmgr = NULL;
  37         has_pp_cap = false;
  38         has_capture_cap = false;
  39 }
  40
  41 void TDMDisplay::SetUp(void)
  42 {
  43         tdm_error ret;
  44         int count = TDM_UT_INVALID_VALUE;
  45         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
  46
  47         TDMEnv::SetUp();
  48
  49         dpy = tdm_display_init(&ret);
  50         ASSERT_EQ(ret, TDM_ERROR_NONE);
  51         ASSERT_NE(dpy, NULL);
  52
  53         bufmgr = tbm_bufmgr_init(-1);
  54         ASSERT_NE(bufmgr, NULL);
  55
  56         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
  57         ASSERT_GT(count, 0);
  58
  59         ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
  60         has_pp_cap = capabilities & TDM_DISPLAY_CAPABILITY_PP;
  61         has_capture_cap = capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
  62 }
  63
  64 void TDMDisplay::TearDown(void)
  65 {
  66         tbm_bufmgr_deinit(bufmgr);
  67         tdm_display_deinit(dpy);
  68
  69         ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
  70
  71         TDMEnv::TearDown();
  72 }
  73
  74 tdm_error
  75 ut_tdm_display_handle_events(tdm_display *dpy)
  76 {
  77         struct pollfd fds;
  78         int fd = -1;
  79         tdm_error ret;
  80         int result;
  81
  82         ret = tdm_display_get_fd(dpy, &fd);
  83         TDM_UT_RETURN_VAL_IF_FAIL(fd >= 0, ret);
  84
  85         fds.events = POLLIN;
  86         fds.fd = fd;
  87         fds.revents = 0;
  88
  89         do {
  90                 result = poll(&fds, 1, 3000);
  91         } while (result == -1 && errno == EINTR);
  92
  93         if (result == 0) {
  94                 TDM_UT_ERR("polling tdm_fd timeout.");
  95                 return TDM_ERROR_TIMEOUT;
  96         }
  97
  98         return tdm_display_handle_events(dpy);
  99 }
 100
 101 bool
 102 ut_tdm_display_has_pp_capability(tdm_display *dpy)
 103 {
 104         tdm_display_capability capabilities = (tdm_display_capability)0;
 105         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
 106         return capabilities & TDM_DISPLAY_CAPABILITY_PP;
 107 }
 108
 109 bool
 110 ut_tdm_display_has_capture_capability(tdm_display *dpy)
 111 {
 112         tdm_display_capability capabilities = (tdm_display_capability)0;
 113         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE);
 114         return capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE;
 115 }
 116
 117 TEST_P(TDMDisplay, DisplayUpdate)
 118 {
 119         ASSERT_EQ(tdm_display_update(dpy), TDM_ERROR_NONE);
 120 }
 121
 122 TEST_P(TDMDisplay, DisplayUpdateNullObject)
 123 {
 124         ASSERT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER);
 125 }
 126
 127 TEST_P(TDMDisplay, DisplayGetFDSuccesful)
 128 {
 129         int fd = TDM_UT_INVALID_VALUE;
 130         ASSERT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE);
 131         ASSERT_NE(fd, TDM_UT_INVALID_VALUE);
 132 }
 133
 134 TEST_P(TDMDisplay, DisplayGetFDNullObject)
 135 {
 136         int fd = TDM_UT_INVALID_VALUE;
 137         ASSERT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
 138         ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
 139 }
 140
 141 TEST_P(TDMDisplay, DisplayGetFDNullFD)
 142 {
 143         ASSERT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 144 }
 145
 146 /* DISABLED */
 147 TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents)
 148 {
 149         /* TODO Generate events*/
 150         ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 151 }
 152
 153 TEST_P(TDMDisplay, DisplayFlush)
 154 {
 155         tdm_display_flush(dpy);
 156 }
 157
 158 TEST_P(TDMDisplay, DisplayFlushNullObject)
 159 {
 160         tdm_display_flush(NULL);
 161 }
 162
 163 TEST_P(TDMDisplay, DisplayGetBackendInfo)
 164 {
 165         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 166         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 167         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 168
 169         ASSERT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 170         ASSERT_NE(name, (const char*)TDM_UT_INVALID_VALUE);
 171         ASSERT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE);
 172         ASSERT_NE(major, TDM_UT_INVALID_VALUE);
 173         ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
 174 }
 175
 176 TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject)
 177 {
 178         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 179         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 180         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 181
 182         ASSERT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 183         ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
 184         ASSERT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE);
 185         ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
 186         ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
 187 }
 188
 189 TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther)
 190 {
 191         ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 192 }
 193
 194 TEST_P(TDMDisplay, DisplayGetCapabilities)
 195 {
 196         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 197         ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
 198         ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
 199 }
 200
 201 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject)
 202 {
 203         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 204         ASSERT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 205         ASSERT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE);
 206 }
 207
 208 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther)
 209 {
 210         ASSERT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 211 }
 212
 213 TEST_P(TDMDisplay, DisplayGetPPCapabilities)
 214 {
 215         tdm_pp_capability capabilities = (tdm_pp_capability) TDM_UT_INVALID_VALUE;
 216         tdm_error ret;
 217         if (!has_pp_cap)
 218                 return;
 219         ret = tdm_display_get_pp_capabilities(dpy, &capabilities);
 220         ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 221
 222         if (ret == TDM_ERROR_NONE)
 223                 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
 224 }
 225
 226 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject)
 227 {
 228         tdm_pp_capability capabilities = (tdm_pp_capability)TDM_UT_INVALID_VALUE;
 229         ASSERT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 230         ASSERT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE);
 231 }
 232
 233 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther)
 234 {
 235         ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 236 }
 237
 238 TEST_P(TDMDisplay, DisplayGetCaptureCapabilities)
 239 {
 240         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 241         tdm_error ret;
 242
 243         if (!has_capture_cap)
 244                 return;
 245
 246         ret = tdm_display_get_capture_capabilities(dpy, &capabilities);
 247         ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 248
 249         if (ret == TDM_ERROR_NONE)
 250                 ASSERT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 251 }
 252
 253 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullObject)
 254 {
 255         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 256         ASSERT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 257         ASSERT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 258 }
 259
 260 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther)
 261 {
 262         ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 263 }
 264
 265 TEST_P(TDMDisplay, DisplayGetMaxLayerCount)
 266 {
 267         int max_count = TDM_UT_INVALID_VALUE;
 268         ASSERT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE);
 269         ASSERT_NE(max_count, TDM_UT_INVALID_VALUE);
 270 }
 271
 272 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject)
 273 {
 274         int max_count = TDM_UT_INVALID_VALUE;
 275         ASSERT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER);
 276         ASSERT_EQ(max_count, TDM_UT_INVALID_VALUE);
 277 }
 278
 279 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther)
 280 {
 281         ASSERT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 282 }
 283
 284 TEST_P(TDMDisplay, DisplayGetOutputCount)
 285 {
 286         int count = TDM_UT_INVALID_VALUE;
 287         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 288         ASSERT_NE(count, TDM_UT_INVALID_VALUE);
 289 }
 290
 291 TEST_P(TDMDisplay, DisplayGetOutputCountNullObject)
 292 {
 293         int count = TDM_UT_INVALID_VALUE;
 294         ASSERT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
 295         ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
 296 }
 297
 298 TEST_P(TDMDisplay, DisplayGetOutputCountNullOther)
 299 {
 300         ASSERT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 301 }
 302
 303 TEST_P(TDMDisplay, DisplayGetOutput)
 304 {
 305         tdm_output *output;
 306         int o, count = TDM_UT_INVALID_VALUE;
 307         tdm_error ret;
 308
 309         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 310         ASSERT_GT(count, 0);
 311
 312         for (o = 0; o < count; o++) {
 313                 output = tdm_display_get_output(dpy, o, &ret);
 314                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 315                 ASSERT_NE(output, NULL);
 316         }
 317 }
 318
 319 TEST_P(TDMDisplay, DisplayGetOutputNullAll)
 320 {
 321         tdm_output *output;
 322         int o, count = TDM_UT_INVALID_VALUE;
 323
 324         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 325         ASSERT_GT(count, 0);
 326
 327         for (o = 0; o < count; o++) {
 328                 output = tdm_display_get_output(NULL, o, NULL);
 329                 ASSERT_EQ(output, NULL);
 330         }
 331 }
 332
 333 TEST_P(TDMDisplay, DisplayGetOutputNullObject)
 334 {
 335         tdm_output *output;
 336         tdm_error ret;
 337
 338         output = tdm_display_get_output(NULL, 0, &ret);
 339         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 340         ASSERT_EQ(output, NULL);
 341 }
 342
 343 TEST_P(TDMDisplay, DisplayGetOutputNullOther)
 344 {
 345         tdm_output *output;
 346         int o, count = TDM_UT_INVALID_VALUE;
 347
 348         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 349         ASSERT_GT(count, 0);
 350
 351         for (o = 0; o < count; o++) {
 352                 output = tdm_display_get_output(dpy, o, NULL);
 353                 ASSERT_NE(output, NULL);
 354         }
 355 }
 356
 357 TEST_P(TDMDisplay, DisplayGetOutputWrongIndex)
 358 {
 359         tdm_output *output;
 360         tdm_error ret;
 361
 362         output = tdm_display_get_output(dpy, -1, &ret);
 363         ASSERT_EQ(ret, TDM_ERROR_NONE);
 364         ASSERT_EQ(output, NULL);
 365
 366         output = tdm_display_get_output(dpy, INT_MAX, &ret);
 367         ASSERT_EQ(ret, TDM_ERROR_NONE);
 368         ASSERT_EQ(output, NULL);
 369 }
 370
 371 TEST_P(TDMDisplay, DisplayCreatePp)
 372 {
 373         tdm_pp *pp;
 374         tdm_error ret;
 375
 376         if (!has_pp_cap)
 377                 return;
 378
 379         pp = tdm_display_create_pp(dpy, &ret);
 380         ASSERT_EQ(ret, TDM_ERROR_NONE);
 381         ASSERT_NE(pp, NULL);
 382
 383         tdm_pp_destroy(pp);
 384 }
 385
 386 TEST_P(TDMDisplay, DisplayCreatePpNullObject)
 387 {
 388         tdm_pp *pp;
 389         tdm_error ret;
 390
 391         if (!has_pp_cap)
 392                 return;
 393
 394         pp = tdm_display_create_pp(NULL, &ret);
 395         ASSERT_NE(ret, TDM_ERROR_NONE);
 396         ASSERT_EQ(pp, NULL);
 397 }
 398
 399 TEST_P(TDMDisplay, ModuleGetInfo)
 400 {
 401         tdm_output *output;
 402         int o, count = TDM_UT_INVALID_VALUE;
 403         tdm_error ret;
 404
 405         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 406         ASSERT_GT(count, 0);
 407
 408         for (o = 0; o < count; o++) {
 409                 tdm_module *module;
 410                 const char *name = (const char *)TDM_UT_INVALID_VALUE;
 411                 const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 412                 int major = TDM_UT_INVALID_VALUE;
 413                 int minor = TDM_UT_INVALID_VALUE;
 414
 415                 output = tdm_display_get_output(dpy, o, &ret);
 416                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 417                 ASSERT_NE(output, NULL);
 418
 419                 module = tdm_output_get_backend_module(output, &ret);
 420                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 421                 ASSERT_NE(module, NULL);
 422
 423                 ASSERT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 424                 ASSERT_NE(name, (const char *)TDM_UT_INVALID_VALUE);
 425                 ASSERT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE);
 426                 ASSERT_NE(major, TDM_UT_INVALID_VALUE);
 427                 ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
 428         }
 429 }
 430
 431 TEST_P(TDMDisplay, ModuleGetInfoNullObject)
 432 {
 433         const char *name = (const char *)TDM_UT_INVALID_VALUE;
 434         const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 435         int major = TDM_UT_INVALID_VALUE;
 436         int minor = TDM_UT_INVALID_VALUE;
 437
 438         ASSERT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 439         ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
 440         ASSERT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE);
 441         ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
 442         ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
 443 }
 444
 445 TEST_P(TDMDisplay, ModuleGetInfoNullOther)
 446 {
 447         tdm_output *output;
 448         int o, count = TDM_UT_INVALID_VALUE;
 449         tdm_error ret;
 450
 451         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 452         ASSERT_GT(count, 0);
 453
 454         for (o = 0; o < count; o++) {
 455                 tdm_module *module;
 456
 457                 output = tdm_display_get_output(dpy, o, &ret);
 458                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 459                 ASSERT_NE(output, NULL);
 460
 461                 module = tdm_output_get_backend_module(output, &ret);
 462                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 463                 ASSERT_NE(module, NULL);
 464
 465                 ASSERT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 466         }
 467 }
 468
 469 #ifdef TDM_UT_TEST_WITH_PARAMS
 470 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 471                                                 TDMDisplay,
 472                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 473 #else
 474 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 475                                                 TDMDisplay,
 476                                                 Values(TDM_DEFAULT_MODULE));
 477 #endif