utests/src/ut_tdm_helper.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 class TDMHelper : public TDMOutput {
  34 public:
  35         TDMHelper();
  36         void SetUp(void);
  37         void TearDown(void);
  38 };
  39
  40 TDMHelper::TDMHelper()
  41 {
  42 }
  43
  44 void TDMHelper::SetUp(void)
  45 {
  46         TDMOutput::SetUp();
  47 }
  48
  49 void TDMHelper::TearDown(void)
  50 {
  51         TDMOutput::TearDown();
  52 }
  53
  54 TEST_P(TDMHelper, HelperGetTime)
  55 {
  56         ASSERT_GT(tdm_helper_get_time(), 0.0);
  57 }
  58
  59 TEST_P(TDMHelper, HelperDumpBuffer)
  60 {
  61         tbm_surface_h buffer;
  62
  63         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
  64         ASSERT_NE(buffer, NULL);
  65
  66         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
  67
  68         char filename[256];
  69         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
  70         tdm_helper_dump_buffer(buffer, (const char*)filename);
  71
  72         tbm_surface_destroy(buffer);
  73 }
  74
  75 TEST_P(TDMHelper, HelperDumpBufferNullObject)
  76 {
  77         char filename[256];
  78         tdm_helper_dump_buffer(NULL, (const char*)filename);
  79 }
  80
  81 TEST_P(TDMHelper, HelperDumpBufferNullOther)
  82 {
  83         tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
  84         tdm_helper_dump_buffer(buffer, NULL);
  85 }
  86
  87 TEST_P(TDMHelper, HelperClearBufferPos)
  88 {
  89         tbm_surface_h buffer;
  90         tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
  91
  92         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
  93         ASSERT_NE(buffer, NULL);
  94
  95         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
  96
  97         tdm_helper_clear_buffer_pos(buffer, &pos);
  98
  99         char filename[256];
 100         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 101         tdm_helper_dump_buffer(buffer, (const char*)filename);
 102
 103         tbm_surface_destroy(buffer);
 104 }
 105
 106 TEST_P(TDMHelper, HelperClearBufferColor)
 107 {
 108         tbm_surface_h buffer;
 109         tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
 110         unsigned int color = 0xffffff00;
 111
 112         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 113         ASSERT_NE(buffer, NULL);
 114
 115         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 116
 117         tdm_helper_clear_buffer_color(buffer, &pos, color);
 118
 119         char filename[256];
 120         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 121         tdm_helper_dump_buffer(buffer, (const char*)filename);
 122
 123         tbm_surface_destroy(buffer);
 124 }
 125
 126 TEST_P(TDMHelper, HelperClearBufferARGB)
 127 {
 128         tbm_surface_h buffer;
 129
 130         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 131         ASSERT_NE(buffer, NULL);
 132
 133         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 134
 135         tdm_helper_clear_buffer(buffer);
 136
 137         char filename[256];
 138         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 139         tdm_helper_dump_buffer(buffer, (const char*)filename);
 140
 141         tbm_surface_destroy(buffer);
 142 }
 143
 144 TEST_P(TDMHelper, HelperClearBufferXRGB)
 145 {
 146         tbm_surface_h buffer;
 147
 148         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
 149         ASSERT_NE(buffer, NULL);
 150
 151         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 152
 153         tdm_helper_clear_buffer(buffer);
 154
 155         char filename[256];
 156         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 157         tdm_helper_dump_buffer(buffer, (const char*)filename);
 158
 159         tbm_surface_destroy(buffer);
 160 }
 161
 162 TEST_P(TDMHelper, HelperClearBufferYUV420)
 163 {
 164         tbm_surface_h buffer;
 165
 166         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
 167         ASSERT_NE(buffer, NULL);
 168
 169         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 170
 171         tdm_helper_clear_buffer(buffer);
 172
 173         char filename[256];
 174         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 175         tdm_helper_dump_buffer(buffer, (const char*)filename);
 176
 177         tbm_surface_destroy(buffer);
 178 }
 179
 180 TEST_P(TDMHelper, HelperClearBufferNV12)
 181 {
 182         tbm_surface_h buffer;
 183
 184         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV12);
 185         ASSERT_NE(buffer, NULL);
 186
 187         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 188
 189         tdm_helper_clear_buffer(buffer);
 190
 191         char filename[256];
 192         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 193         tdm_helper_dump_buffer(buffer, (const char*)filename);
 194
 195         tbm_surface_destroy(buffer);
 196 }
 197
 198 TEST_P(TDMHelper, HelperClearBufferNV21)
 199 {
 200         tbm_surface_h buffer;
 201
 202         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV21);
 203         ASSERT_NE(buffer, NULL);
 204
 205         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 206
 207         tdm_helper_clear_buffer(buffer);
 208
 209         char filename[256];
 210         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 211         tdm_helper_dump_buffer(buffer, (const char*)filename);
 212
 213         tbm_surface_destroy(buffer);
 214 }
 215
 216 TEST_P(TDMHelper, HelperClearBufferYUYV)
 217 {
 218         tbm_surface_h buffer;
 219
 220         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUYV);
 221         ASSERT_NE(buffer, NULL);
 222
 223         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 224
 225         tdm_helper_clear_buffer(buffer);
 226
 227         char filename[256];
 228         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 229         tdm_helper_dump_buffer(buffer, (const char*)filename);
 230
 231         tbm_surface_destroy(buffer);
 232 }
 233
 234 TEST_P(TDMHelper, HelperClearBufferUYVY)
 235 {
 236         tbm_surface_h buffer;
 237
 238         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_UYVY);
 239         ASSERT_NE(buffer, NULL);
 240
 241         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 242
 243         tdm_helper_clear_buffer(buffer);
 244
 245         char filename[256];
 246         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 247         tdm_helper_dump_buffer(buffer, (const char*)filename);
 248
 249         tbm_surface_destroy(buffer);
 250 }
 251
 252 TEST_P(TDMHelper, HelperGetBufferFullSize)
 253 {
 254         tbm_surface_h buffer;
 255         int w = TDM_UT_INVALID_VALUE, h = TDM_UT_INVALID_VALUE;
 256
 257         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 258         ASSERT_NE(buffer, NULL);
 259
 260         tdm_helper_get_buffer_full_size(buffer, &w, &h);
 261         ASSERT_NE(w, TDM_UT_INVALID_VALUE);
 262         ASSERT_GE(w, tbm_surface_get_width(buffer));
 263         ASSERT_NE(h, TDM_UT_INVALID_VALUE);
 264         ASSERT_GE(h, tbm_surface_get_height(buffer));
 265
 266         tbm_surface_destroy(buffer);
 267 }
 268
 269 TEST_P(TDMHelper, HelperConvertBufferRotate0)
 270 {
 271         tbm_surface_h buffer, temp;
 272         tdm_pos sp, dp;
 273
 274         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 275         ASSERT_NE(buffer, NULL);
 276         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 277
 278         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 279         ASSERT_NE(temp, NULL);
 280
 281         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 282         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 283
 284         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE);
 285
 286         char filename[256];
 287         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 288         tdm_helper_dump_buffer(temp, (const char*)filename);
 289
 290         tbm_surface_destroy(buffer);
 291         tbm_surface_destroy(temp);
 292 }
 293
 294 TEST_P(TDMHelper, HelperConvertBufferRotate0Flip)
 295 {
 296         tbm_surface_h buffer, temp;
 297         tdm_pos sp, dp;
 298
 299         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 300         ASSERT_NE(buffer, NULL);
 301         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 302
 303         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 304         ASSERT_NE(temp, NULL);
 305
 306         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 307         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 308
 309         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE);
 310
 311         char filename[256];
 312         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 313         tdm_helper_dump_buffer(temp, (const char*)filename);
 314
 315         tbm_surface_destroy(buffer);
 316         tbm_surface_destroy(temp);
 317 }
 318
 319 TEST_P(TDMHelper, HelperConvertBufferRotate90)
 320 {
 321         tbm_surface_h buffer, temp;
 322         tdm_pos sp, dp;
 323
 324         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 325         ASSERT_NE(buffer, NULL);
 326         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 327
 328         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 329         ASSERT_NE(temp, NULL);
 330
 331         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 332         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 333
 334         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE);
 335
 336         char filename[256];
 337         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 338         tdm_helper_dump_buffer(temp, (const char*)filename);
 339
 340         tbm_surface_destroy(buffer);
 341         tbm_surface_destroy(temp);
 342 }
 343
 344 TEST_P(TDMHelper, HelperConvertBufferRotate180)
 345 {
 346         tbm_surface_h buffer, temp;
 347         tdm_pos sp, dp;
 348
 349         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 350         ASSERT_NE(buffer, NULL);
 351         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 352
 353         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 354         ASSERT_NE(temp, NULL);
 355
 356         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 357         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 358
 359         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE);
 360
 361         char filename[256];
 362         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 363         tdm_helper_dump_buffer(temp, (const char*)filename);
 364
 365         tbm_surface_destroy(buffer);
 366         tbm_surface_destroy(temp);
 367 }
 368
 369 TEST_P(TDMHelper, HelperConvertBufferRotate270)
 370 {
 371         tbm_surface_h buffer, temp;
 372         tdm_pos sp, dp;
 373
 374         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 375         ASSERT_NE(buffer, NULL);
 376         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 377
 378         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 379         ASSERT_NE(temp, NULL);
 380
 381         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 382         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 383
 384         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE);
 385
 386         char filename[256];
 387         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 388         tdm_helper_dump_buffer(temp, (const char*)filename);
 389
 390         tbm_surface_destroy(buffer);
 391         tbm_surface_destroy(temp);
 392 }
 393
 394 TEST_P(TDMHelper, HelperConvertBufferYUV420)
 395 {
 396         tbm_surface_h buffer, temp;
 397         tdm_pos sp, dp;
 398
 399         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
 400         ASSERT_NE(buffer, NULL);
 401         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 402
 403         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_YUV420);
 404         ASSERT_NE(temp, NULL);
 405
 406         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 407         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 408
 409         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED);
 410
 411         tbm_surface_destroy(buffer);
 412         tbm_surface_destroy(temp);
 413 }
 414
 415 TEST_P(TDMHelper, HelperGetFD)
 416 {
 417         int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
 418         ASSERT_GE(fd, 0);
 419         close(fd);
 420         fd = tdm_helper_get_fd("BLURBLUR");
 421         ASSERT_EQ(fd, -1);
 422 }
 423
 424 TEST_P(TDMHelper, HelperSetFD)
 425 {
 426         tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
 427         tdm_helper_set_fd("BLURBLUR", -1);
 428 }
 429
 430 TEST_P(TDMHelper, HelperDumpStart)
 431 {
 432         char path[256];
 433         int count = 0;
 434         snprintf(path, sizeof path, "blurblur");
 435         tdm_helper_dump_start(path, &count);
 436         tdm_helper_dump_stop();
 437 }
 438
 439 static void
 440 _ut_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data)
 441 {
 442 }
 443
 444 TEST_P(TDMHelper, HelperCaptureOutput)
 445 {
 446         tdm_error ret;
 447         tdm_output *output;
 448
 449         for (int o = 0; o < output_count; o++) {
 450                 tbm_surface_h dump;
 451
 452                 output = tdm_display_get_output(dpy, o, &ret);
 453                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 454                 ASSERT_NE(output, NULL);
 455
 456                 if (!ut_tdm_output_is_connected(output))
 457                         continue;
 458
 459                 ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
 460
 461                 dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 462                 ASSERT_NE(dump, NULL);
 463
 464                 ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 465                                         _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE);
 466
 467                 char filename[256];
 468                 snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
 469                 tdm_helper_dump_buffer(dump, (const char*)filename);
 470
 471                 tbm_surface_destroy(dump);
 472         }
 473 }
 474
 475
 476 TEST_P(TDMHelper, HelperCaptureOutputNullObject)
 477 {
 478         tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 479
 480         ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 481                                 _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 482 }
 483
 484 TEST_P(TDMHelper, HelperCaptureOutputNullOther)
 485 {
 486         for (int o = 0; o < output_count; o++) {
 487                 tdm_error ret;
 488                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 489                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 490                 ASSERT_NE(output, NULL);
 491                 tdm_helper_output_commit_per_vblank_enabled(output);
 492         }
 493
 494         tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 495
 496         ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 497                                 _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 498 }
 499
 500 TEST_P(TDMHelper, HelperGetDisplayInformation)
 501 {
 502         char reply[8192];
 503         int len = sizeof reply;
 504
 505         for (int o = 0; o < output_count; o++) {
 506                 tdm_error ret;
 507                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 508                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 509                 ASSERT_NE(output, NULL);
 510                 if (!ut_tdm_output_is_connected(output))
 511                         continue;
 512                 ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
 513         }
 514
 515         tdm_helper_get_display_information(dpy, reply, &len);
 516         TDM_INFO("%s", reply);
 517 }
 518
 519 TEST_P(TDMHelper, HelperGetDisplayInformationNullObject)
 520 {
 521         char reply[8192];
 522         int len = sizeof reply;
 523
 524         tdm_helper_get_display_information(NULL, reply, &len);
 525 }
 526
 527 TEST_P(TDMHelper, HelperGetDisplayInformationNullOther)
 528 {
 529         tdm_helper_get_display_information(dpy, NULL, NULL);
 530 }
 531
 532 TEST_P(TDMHelper, HelperCommitPerVblankEnabled)
 533 {
 534         tdm_helper_commit_per_vblank_enabled(dpy);
 535 }
 536
 537 TEST_P(TDMHelper, HelperCommitPerVblankEnabledNullOBject)
 538 {
 539         tdm_helper_commit_per_vblank_enabled(NULL);
 540 }
 541
 542 TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabled)
 543 {
 544         for (int o = 0; o < output_count; o++) {
 545                 tdm_error ret;
 546                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 547                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 548                 ASSERT_NE(output, NULL);
 549                 tdm_helper_output_commit_per_vblank_enabled(output);
 550         }
 551 }
 552
 553 TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject)
 554 {
 555         tdm_helper_output_commit_per_vblank_enabled(NULL);
 556 }
 557
 558 #ifdef TDM_UT_TEST_WITH_PARAMS
 559 INSTANTIATE_TEST_CASE_P(TDMHelperParams,
 560                                                 TDMHelper,
 561                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 562 #else
 563 INSTANTIATE_TEST_CASE_P(TDMHelperParams,
 564                                                 TDMHelper,
 565                                                 Values(TDM_DEFAULT_MODULE));
 566 #endif