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