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, DisplayUpdateWrongDpy)
 123 {
 124         EXPECT_EXIT({
 125                 tdm_display *wrong_dpy = (tdm_display *)TDM_UT_INVALID_VALUE;
 126                 tdm_display_update(wrong_dpy);
 127                 exit(0);
 128         }, ::testing::ExitedWithCode(0), "");
 129 }
 130
 131 TEST_P(TDMDisplay, DisplayUpdateNullObject)
 132 {
 133         ASSERT_EQ(tdm_display_update(NULL), TDM_ERROR_INVALID_PARAMETER);
 134 }
 135
 136 TEST_P(TDMDisplay, DisplayGetFDSuccesful)
 137 {
 138         int fd = TDM_UT_INVALID_VALUE;
 139         ASSERT_EQ(tdm_display_get_fd(dpy, &fd), TDM_ERROR_NONE);
 140         ASSERT_NE(fd, TDM_UT_INVALID_VALUE);
 141 }
 142
 143 TEST_P(TDMDisplay, DisplayGetFDNullObject)
 144 {
 145         int fd = TDM_UT_INVALID_VALUE;
 146         ASSERT_EQ(tdm_display_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
 147         ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
 148 }
 149
 150 TEST_P(TDMDisplay, DisplayGetFDNullFD)
 151 {
 152         ASSERT_EQ(tdm_display_get_fd(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 153 }
 154
 155 TEST_P(TDMDisplay, DisplayGetFDWrongDpy)
 156 {
 157         tdm_display *wrong_dpy = (tdm_display *)TDM_UT_INVALID_VALUE;
 158         int fd = TDM_UT_INVALID_VALUE;
 159
 160         ASSERT_EQ(tdm_display_get_fd(wrong_dpy, &fd), TDM_ERROR_INVALID_PARAMETER);
 161         ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
 162 }
 163
 164 /* DISABLED */
 165 TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents)
 166 {
 167         /* TODO Generate events*/
 168         ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 169 }
 170
 171 TEST_P(TDMDisplay, DisplayFlush)
 172 {
 173         tdm_display_flush(dpy);
 174 }
 175
 176 TEST_P(TDMDisplay, DisplayFlushNullObject)
 177 {
 178         tdm_display_flush(NULL);
 179 }
 180
 181 TEST_P(TDMDisplay, DisplayGetBackendInfo)
 182 {
 183         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 184         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 185         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 186
 187         ASSERT_EQ(tdm_display_get_backend_info(dpy, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 188         ASSERT_NE(name, (const char*)TDM_UT_INVALID_VALUE);
 189         ASSERT_NE(vendor, (const char*)TDM_UT_INVALID_VALUE);
 190         ASSERT_NE(major, TDM_UT_INVALID_VALUE);
 191         ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
 192 }
 193
 194 TEST_P(TDMDisplay, DisplayGetBackendInfoNullObject)
 195 {
 196         const char *name = (const char*)TDM_UT_INVALID_VALUE;
 197         const char *vendor = (const char*)TDM_UT_INVALID_VALUE;
 198         int major = TDM_UT_INVALID_VALUE, minor = TDM_UT_INVALID_VALUE;
 199
 200         ASSERT_EQ(tdm_display_get_backend_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 201         ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
 202         ASSERT_EQ(vendor, (const char*)TDM_UT_INVALID_VALUE);
 203         ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
 204         ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
 205 }
 206
 207 TEST_P(TDMDisplay, DisplayGetBackendInfoNullOther)
 208 {
 209         ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 210 }
 211
 212 TEST_P(TDMDisplay, DisplayGetCapabilities)
 213 {
 214         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 215         ASSERT_EQ(tdm_display_get_capabilities(dpy, &capabilities), TDM_ERROR_NONE);
 216         ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
 217 }
 218
 219 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullObject)
 220 {
 221         tdm_display_capability capabilities = (tdm_display_capability)TDM_UT_INVALID_VALUE;
 222         ASSERT_EQ(tdm_display_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 223         ASSERT_EQ(capabilities, (tdm_display_capability)TDM_UT_INVALID_VALUE);
 224 }
 225
 226 TEST_P(TDMDisplay, DisplayGetCapabilitiesNullOther)
 227 {
 228         ASSERT_EQ(tdm_display_get_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 229 }
 230
 231 TEST_P(TDMDisplay, DisplayGetPPCapabilities)
 232 {
 233         tdm_pp_capability capabilities = (tdm_pp_capability) TDM_UT_INVALID_VALUE;
 234         tdm_error ret;
 235         if (!has_pp_cap)
 236                 return;
 237         ret = tdm_display_get_pp_capabilities(dpy, &capabilities);
 238         ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 239
 240         if (ret == TDM_ERROR_NONE)
 241                 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
 242 }
 243
 244 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullObject)
 245 {
 246         tdm_pp_capability capabilities = (tdm_pp_capability)TDM_UT_INVALID_VALUE;
 247         ASSERT_EQ(tdm_display_get_pp_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 248         ASSERT_EQ(capabilities, (tdm_pp_capability)TDM_UT_INVALID_VALUE);
 249 }
 250
 251 TEST_P(TDMDisplay, DisplayGetPPCapabilitiesNullOther)
 252 {
 253         ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 254 }
 255
 256 TEST_P(TDMDisplay, DisplayGetCaptureCapabilities)
 257 {
 258         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 259         tdm_error ret;
 260
 261         if (!has_capture_cap)
 262                 return;
 263
 264         ret = tdm_display_get_capture_capabilities(dpy, &capabilities);
 265         ASSERT_TRUE(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_CAPABILITY);
 266
 267         if (ret == TDM_ERROR_NONE)
 268                 ASSERT_NE(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 269 }
 270
 271 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullObject)
 272 {
 273         tdm_capture_capability capabilities = (tdm_capture_capability)TDM_UT_INVALID_VALUE;
 274         ASSERT_EQ(tdm_display_get_capture_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 275         ASSERT_EQ(capabilities, (tdm_capture_capability)TDM_UT_INVALID_VALUE);
 276 }
 277
 278 TEST_P(TDMDisplay, DisplayGetCaptureCapabilitiesNullOther)
 279 {
 280         ASSERT_EQ(tdm_display_get_capture_capabilities(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 281 }
 282
 283 TEST_P(TDMDisplay, DisplayGetMaxLayerCount)
 284 {
 285         int max_count = TDM_UT_INVALID_VALUE;
 286         ASSERT_EQ(tdm_display_get_max_layer_count(dpy, &max_count), TDM_ERROR_NONE);
 287         ASSERT_NE(max_count, TDM_UT_INVALID_VALUE);
 288 }
 289
 290 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullObject)
 291 {
 292         int max_count = TDM_UT_INVALID_VALUE;
 293         ASSERT_EQ(tdm_display_get_max_layer_count(NULL, &max_count), TDM_ERROR_INVALID_PARAMETER);
 294         ASSERT_EQ(max_count, TDM_UT_INVALID_VALUE);
 295 }
 296
 297 TEST_P(TDMDisplay, DisplayGetMaxLayerCountNullOther)
 298 {
 299         ASSERT_EQ(tdm_display_get_max_layer_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 300 }
 301
 302 TEST_P(TDMDisplay, DisplayGetOutputCount)
 303 {
 304         int count = TDM_UT_INVALID_VALUE;
 305         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 306         ASSERT_NE(count, TDM_UT_INVALID_VALUE);
 307 }
 308
 309 TEST_P(TDMDisplay, DisplayGetOutputCountNullObject)
 310 {
 311         int count = TDM_UT_INVALID_VALUE;
 312         ASSERT_EQ(tdm_display_get_output_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
 313         ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
 314 }
 315
 316 TEST_P(TDMDisplay, DisplayGetOutputCountNullOther)
 317 {
 318         ASSERT_EQ(tdm_display_get_output_count(dpy, NULL), TDM_ERROR_INVALID_PARAMETER);
 319 }
 320
 321 TEST_P(TDMDisplay, DisplayGetOutput)
 322 {
 323         tdm_output *output;
 324         int o, count = TDM_UT_INVALID_VALUE;
 325         tdm_error ret;
 326
 327         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 328         ASSERT_GT(count, 0);
 329
 330         for (o = 0; o < count; o++) {
 331                 output = tdm_display_get_output(dpy, o, &ret);
 332                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 333                 ASSERT_NE(output, NULL);
 334         }
 335 }
 336
 337 TEST_P(TDMDisplay, DisplayGetOutputNullAll)
 338 {
 339         tdm_output *output;
 340         int o, count = TDM_UT_INVALID_VALUE;
 341
 342         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 343         ASSERT_GT(count, 0);
 344
 345         for (o = 0; o < count; o++) {
 346                 output = tdm_display_get_output(NULL, o, NULL);
 347                 ASSERT_EQ(output, NULL);
 348         }
 349 }
 350
 351 TEST_P(TDMDisplay, DisplayGetOutputNullObject)
 352 {
 353         tdm_output *output;
 354         tdm_error ret;
 355
 356         output = tdm_display_get_output(NULL, 0, &ret);
 357         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 358         ASSERT_EQ(output, NULL);
 359 }
 360
 361 TEST_P(TDMDisplay, DisplayGetOutputNullOther)
 362 {
 363         tdm_output *output;
 364         int o, count = TDM_UT_INVALID_VALUE;
 365
 366         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 367         ASSERT_GT(count, 0);
 368
 369         for (o = 0; o < count; o++) {
 370                 output = tdm_display_get_output(dpy, o, NULL);
 371                 ASSERT_NE(output, NULL);
 372         }
 373 }
 374
 375 TEST_P(TDMDisplay, DisplayGetOutputWrongIndex)
 376 {
 377         tdm_output *output;
 378         tdm_error ret;
 379
 380         output = tdm_display_get_output(dpy, -1, &ret);
 381         ASSERT_EQ(ret, TDM_ERROR_NONE);
 382         ASSERT_EQ(output, NULL);
 383
 384         output = tdm_display_get_output(dpy, INT_MAX, &ret);
 385         ASSERT_EQ(ret, TDM_ERROR_NONE);
 386         ASSERT_EQ(output, NULL);
 387 }
 388
 389 TEST_P(TDMDisplay, DisplayCreatePp)
 390 {
 391         tdm_pp *pp;
 392         tdm_error ret;
 393
 394         if (!has_pp_cap)
 395                 return;
 396
 397         pp = tdm_display_create_pp(dpy, &ret);
 398         ASSERT_EQ(ret, TDM_ERROR_NONE);
 399         ASSERT_NE(pp, NULL);
 400
 401         tdm_pp_destroy(pp);
 402 }
 403
 404 TEST_P(TDMDisplay, DisplayCreatePpNullObject)
 405 {
 406         tdm_pp *pp;
 407         tdm_error ret;
 408
 409         if (!has_pp_cap)
 410                 return;
 411
 412         pp = tdm_display_create_pp(NULL, &ret);
 413         ASSERT_NE(ret, TDM_ERROR_NONE);
 414         ASSERT_EQ(pp, NULL);
 415 }
 416
 417 TEST_P(TDMDisplay, ModuleGetInfo)
 418 {
 419         tdm_output *output;
 420         int o, count = TDM_UT_INVALID_VALUE;
 421         tdm_error ret;
 422
 423         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 424         ASSERT_GT(count, 0);
 425
 426         for (o = 0; o < count; o++) {
 427                 tdm_module *module;
 428                 const char *name = (const char *)TDM_UT_INVALID_VALUE;
 429                 const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 430                 int major = TDM_UT_INVALID_VALUE;
 431                 int minor = TDM_UT_INVALID_VALUE;
 432
 433                 output = tdm_display_get_output(dpy, o, &ret);
 434                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 435                 ASSERT_NE(output, NULL);
 436
 437                 module = tdm_output_get_backend_module(output, &ret);
 438                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 439                 ASSERT_NE(module, NULL);
 440
 441                 ASSERT_EQ(tdm_module_get_info(module, &name, &vendor, &major, &minor), TDM_ERROR_NONE);
 442                 ASSERT_NE(name, (const char *)TDM_UT_INVALID_VALUE);
 443                 ASSERT_NE(vendor, (const char *)TDM_UT_INVALID_VALUE);
 444                 ASSERT_NE(major, TDM_UT_INVALID_VALUE);
 445                 ASSERT_NE(minor, TDM_UT_INVALID_VALUE);
 446         }
 447 }
 448
 449 TEST_P(TDMDisplay, ModuleGetInfoNullObject)
 450 {
 451         const char *name = (const char *)TDM_UT_INVALID_VALUE;
 452         const char *vendor = (const char *)TDM_UT_INVALID_VALUE;
 453         int major = TDM_UT_INVALID_VALUE;
 454         int minor = TDM_UT_INVALID_VALUE;
 455
 456         ASSERT_EQ(tdm_module_get_info(NULL, &name, &vendor, &major, &minor), TDM_ERROR_INVALID_PARAMETER);
 457         ASSERT_EQ(name, (const char *)TDM_UT_INVALID_VALUE);
 458         ASSERT_EQ(vendor, (const char *)TDM_UT_INVALID_VALUE);
 459         ASSERT_EQ(major, TDM_UT_INVALID_VALUE);
 460         ASSERT_EQ(minor, TDM_UT_INVALID_VALUE);
 461 }
 462
 463 TEST_P(TDMDisplay, ModuleGetInfoNullOther)
 464 {
 465         tdm_output *output;
 466         int o, count = TDM_UT_INVALID_VALUE;
 467         tdm_error ret;
 468
 469         ASSERT_EQ(tdm_display_get_output_count(dpy, &count), TDM_ERROR_NONE);
 470         ASSERT_GT(count, 0);
 471
 472         for (o = 0; o < count; o++) {
 473                 tdm_module *module;
 474
 475                 output = tdm_display_get_output(dpy, o, &ret);
 476                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 477                 ASSERT_NE(output, NULL);
 478
 479                 module = tdm_output_get_backend_module(output, &ret);
 480                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 481                 ASSERT_NE(module, NULL);
 482
 483                 ASSERT_EQ(tdm_module_get_info(module, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
 484         }
 485 }
 486
 487 #ifdef TDM_UT_TEST_WITH_PARAMS
 488 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 489                                                 TDMDisplay,
 490                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 491 #else
 492 INSTANTIATE_TEST_CASE_P(TDMDisplayParams,
 493                                                 TDMDisplay,
 494                                                 Values(TDM_DEFAULT_MODULE));
 495 #endif