haltests/src/tc_tdm_client.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2017 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  * Contact: Sergey Sizonov <s.sizonov@samsung.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the
  12  * "Software"), to deal in the Software without restriction, including
  13  * without limitation the rights to use, copy, modify, merge, publish,
  14  * distribute, sub license, and/or sell copies of the Software, and to
  15  * permit persons to whom the Software is furnished to do so, subject to
  16  * the following conditions:
  17  *
  18  * The above copyright notice and this permission notice (including the
  19  * next paragraph) shall be included in all copies or substantial portions
  20  * of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  25  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  26  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29  *
  30 **************************************************************************/
  31
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <sys/signalfd.h>
  35 #include <poll.h>
  36 #include <sys/prctl.h>
  37
  38 #include "tc_tdm.h"
  39 #include "tdm_client.h"
  40
  41 /* LCOV_EXCL_START */
  42
  43 enum {
  44         TDM_UT_PIPE_MSG_NONE,
  45         TDM_UT_PIPE_MSG_REPLY,
  46         TDM_UT_PIPE_MSG_SERVER_READY,
  47         TDM_UT_PIPE_MSG_SERVER_FAILED,
  48         TDM_UT_PIPE_MSG_DPMS_ON,
  49         TDM_UT_PIPE_MSG_DPMS_OFF,
  50         TDM_UT_PIPE_MSG_TERMINATE_SERVER,
  51 };
  52
  53 #define TDM_UT_WAIT(fmt, ...) \
  54         do { \
  55                 char ch; \
  56                 do { \
  57                         printf(fmt" [n]):next ", ##__VA_ARGS__); \
  58                         ch = tc_tdm_getchar(); \
  59                 } while(ch != 'n'); \
  60         } while (0)
  61
  62 static int _tc_tdm_pipe_read_msg(int fd);
  63 static bool _tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg);
  64 static pid_t _tc_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child);
  65
  66 class TDMClient : public TDMEnv
  67 {
  68 public:
  69         static pid_t server_pid;
  70
  71         /* 0: read, 1: write */
  72         static int pipe_parent[2];
  73         static int pipe_child[2];
  74
  75         tdm_client *client;
  76         tdm_client_output *output;
  77         tdm_client_vblank *vblank;
  78         tdm_client_voutput *voutput;
  79
  80         double vrefresh_interval, start, end;
  81
  82         TDMClient();
  83
  84         void SetUp(void);
  85         void TearDown(void);
  86         bool PrepareClient(void);
  87         bool PrepareOutput(void);
  88         bool PrepareVblank(void);
  89
  90         static void TearDownTestCase(void);
  91         static void ServerFork(void);
  92         static void ServerKill(void);
  93 };
  94
  95 pid_t TDMClient::server_pid = -1;
  96 int TDMClient::pipe_parent[2] = {-1, -1};
  97 int TDMClient::pipe_child[2] = {-1, -1};
  98
  99 void TDMClient::TearDownTestCase(void)
 100 {
 101         ServerKill();
 102 }
 103
 104 void TDMClient::ServerFork(void)
 105 {
 106         if (server_pid > 0)
 107                 return;
 108
 109         server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
 110         ASSERT_GT(server_pid, 0);
 111 }
 112
 113 void TDMClient::ServerKill(void)
 114 {
 115         if (pipe_child[0] >= 0)
 116                 close(pipe_child[0]);
 117         if (pipe_child[1] >= 0) {
 118                 if (server_pid > 0) {
 119                         bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
 120                         if (ret) {
 121                                 if (waitpid(server_pid, NULL, 0) == server_pid)
 122                                         TDM_INFO("*** server terminated ***");
 123                                 else
 124                                         TDM_ERR("*** failed to terminate server ***");
 125                         } else {
 126                                 if (kill(server_pid, 9) < 0)
 127                                         TDM_ERR("*** failed to kill server ***");
 128                         }
 129                 }
 130                 close(pipe_child[1]);
 131         }
 132
 133         if (pipe_parent[0] >= 0)
 134                 close(pipe_parent[0]);
 135         if (pipe_parent[1] >= 0)
 136                 close(pipe_parent[1]);
 137
 138         server_pid = -1;
 139         pipe_parent[0] = pipe_parent[1] = -1;
 140         pipe_child[0] = pipe_child[1] = -1;
 141 }
 142
 143 TDMClient::TDMClient()
 144 {
 145         client = NULL;
 146         output = NULL;
 147         vblank = NULL;
 148         vrefresh_interval = start = end = 0.0;
 149 }
 150
 151 void TDMClient::SetUp(void)
 152 {
 153         TDMEnv::SetUp();
 154
 155         if (server_pid == -1)
 156                 ServerFork();
 157 }
 158
 159 void TDMClient::TearDown(void)
 160 {
 161         if (vblank)
 162                 tdm_client_vblank_destroy(vblank);
 163         if (client)
 164                 tdm_client_destroy(client);
 165
 166         TDMEnv::TearDown();
 167 }
 168
 169 bool TDMClient::PrepareClient(void)
 170 {
 171         tdm_error ret;
 172         client = tdm_client_create(&ret);
 173         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 174         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
 175
 176         return true;
 177 }
 178
 179 bool TDMClient::PrepareOutput(void)
 180 {
 181         tdm_error ret;
 182
 183         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
 184
 185         output = tdm_client_get_output(client, NULL, &ret);
 186         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 187         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 188
 189         return true;
 190 }
 191
 192 bool TDMClient::PrepareVblank(void)
 193 {
 194         tdm_error ret;
 195         unsigned int refresh;
 196
 197         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 198
 199         vblank = tdm_client_output_create_vblank(output, &ret);
 200         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 201         TDM_UT_RETURN_FALSE_IF_FAIL(vblank != NULL);
 202
 203         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_client_output_get_refresh_rate(output, &refresh) == TDM_ERROR_NONE);
 204         TDM_UT_RETURN_FALSE_IF_FAIL(refresh > 0);
 205
 206         vrefresh_interval = 1.0 / (double)refresh;
 207         TDM_UT_RETURN_FALSE_IF_FAIL(vrefresh_interval > 0);
 208
 209         return true;
 210 }
 211
 212 char
 213 tc_tdm_getchar(void)
 214 {
 215         int c = getchar();
 216         int ch = c;
 217
 218         if (ch == '\n' || ch == '\r')
 219                 ch = 'y';
 220         else if (ch < 'a')
 221                 ch += ('a' - 'A');
 222
 223         while (c != '\n' && c != EOF)
 224                 c = getchar();
 225
 226         return ch;
 227 }
 228
 229 static int
 230 _tc_tdm_pipe_read_msg(int fd)
 231 {
 232         ssize_t len;
 233         int msg;
 234
 235         do {
 236                 len = read(fd, &msg, sizeof msg);
 237         } while (len < 0 && errno == EINTR);
 238
 239         if (len <= 0)
 240                 msg = TDM_UT_PIPE_MSG_NONE;
 241
 242         return msg;
 243 }
 244
 245 static bool
 246 _tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg)
 247 {
 248         ssize_t len = write(fd, &msg, sizeof msg);
 249         TDM_UT_RETURN_FALSE_IF_FAIL(len == sizeof msg);
 250
 251         if (reply_fd >= 0) {
 252                 int reply = _tc_tdm_pipe_read_msg(reply_fd);
 253                 TDM_UT_RETURN_FALSE_IF_FAIL(reply == TDM_UT_PIPE_MSG_REPLY);
 254         }
 255
 256         return true;
 257 }
 258
 259 static bool
 260 _tc_tdm_server_set_output_dpms(tdm_display *dpy, int msg)
 261 {
 262         tdm_error ret;
 263         tdm_output *output;
 264         tdm_output_dpms dpms;
 265
 266         output = tdm_display_find_output(dpy, "primary", &ret);
 267         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 268         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 269
 270         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_dpms(output, &dpms) == TDM_ERROR_NONE);
 271
 272         switch (msg) {
 273         case TDM_UT_PIPE_MSG_DPMS_ON:
 274                 if (dpms != TDM_OUTPUT_DPMS_ON)
 275                         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
 276                 break;
 277         case TDM_UT_PIPE_MSG_DPMS_OFF:
 278                 if (dpms != TDM_OUTPUT_DPMS_OFF)
 279                         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
 280                 break;
 281         default:
 282                 break;
 283         }
 284
 285         return true;
 286 }
 287
 288 static void
 289 _tc_tdm_server_run(int *pipe_parent, int *pipe_child)
 290 {
 291         tdm_display *dpy = NULL;
 292         tdm_error ret;
 293         struct pollfd fds[2];
 294         int tdm_fd, err;
 295         int output_count = 0;
 296
 297         dpy = tdm_display_init(&ret);
 298         TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
 299         TDM_UT_GOTO_IF_FAIL(dpy != NULL, failed);
 300
 301         TDM_UT_GOTO_IF_FAIL(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE, failed);
 302
 303         for (int o = 0; o < output_count; o++) {
 304                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 305                 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
 306                 TDM_UT_GOTO_IF_FAIL(output != NULL, failed);
 307
 308                 if (!tc_tdm_output_is_connected(output))
 309                         continue;
 310
 311                 TDM_UT_GOTO_IF_FAIL(tc_tdm_output_prepare(dpy, output, true) == true, failed);
 312         }
 313
 314         TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done);
 315
 316         TDM_INFO("*** server ready ***");
 317
 318         ret = tdm_display_get_fd(dpy, &tdm_fd);
 319         TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done);
 320
 321         fds[0].events = POLLIN;
 322         fds[0].fd = tdm_fd;
 323         fds[0].revents = 0;
 324
 325         fds[1].events = POLLIN;
 326         fds[1].fd = pipe_child[0];
 327         fds[1].revents = 0;
 328
 329         while (1) {
 330                 /* make sure all events are flushed to clients before falling in sleep */
 331                 tdm_display_flush(dpy);
 332
 333                 err = poll(fds, 2, -1);
 334                 if (err < 0) {
 335                         if (errno == EINTR || errno == EAGAIN) {
 336                                 continue;
 337                         } else {
 338                                 TDM_ERR("server-process: poll failed: %m\n");
 339                                 goto done;
 340                         }
 341                 }
 342
 343                 if (fds[0].revents & POLLIN)
 344                         ret = tc_tdm_display_handle_events(dpy);
 345
 346                 if (fds[1].revents & POLLIN) {
 347                         int msg = _tc_tdm_pipe_read_msg(pipe_child[0]);
 348                         _tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY);
 349
 350                         switch (msg) {
 351                         case TDM_UT_PIPE_MSG_DPMS_ON:
 352                         case TDM_UT_PIPE_MSG_DPMS_OFF:
 353                                 _tc_tdm_server_set_output_dpms(dpy, msg);
 354                                 break;
 355                         case TDM_UT_PIPE_MSG_TERMINATE_SERVER:
 356                                 goto done;
 357                         default:
 358                                 break;
 359                         }
 360                 }
 361         }
 362
 363 done:
 364         if (dpy)
 365                 tdm_display_deinit(dpy);
 366         return;
 367
 368 failed:
 369         TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done);
 370         TDM_INFO("*** server failed ***");
 371
 372         if (dpy)
 373                 tdm_display_deinit(dpy);
 374         return;
 375
 376 }
 377
 378 static void _tc_tdm_client_sig_handler(int sig)
 379 {
 380         TDM_UT_ERR("got signal: %d", sig);
 381         kill(TDMClient::server_pid, 9);
 382         abort();
 383 }
 384
 385 static pid_t
 386 _tc_tdm_client_server_fork(int *pipe_parent, int *pipe_child)
 387 {
 388         pid_t pid;
 389         int msg;
 390
 391         TDM_UT_GOTO_IF_FAIL(pipe(pipe_parent) == 0, failed);
 392         TDM_UT_GOTO_IF_FAIL(pipe(pipe_child) == 0, failed);
 393
 394         signal(SIGCHLD, SIG_IGN);
 395         signal(SIGSEGV, _tc_tdm_client_sig_handler);
 396
 397         prctl(PR_SET_PDEATHSIG, SIGHUP);
 398
 399         pid = fork();
 400         TDM_UT_GOTO_IF_FAIL(pid >= 0, failed);
 401
 402         if (pid == 0) {
 403                 _tc_tdm_server_run(pipe_parent, pipe_child);
 404                 close(pipe_child[0]);
 405                 close(pipe_child[1]);
 406                 close(pipe_parent[0]);
 407                 close(pipe_parent[1]);
 408
 409 #ifdef TIZEN_TEST_GCOV
 410                 __gcov_flush();
 411 #endif
 412
 413                 exit(0);
 414         }
 415
 416         msg = _tc_tdm_pipe_read_msg(pipe_parent[0]);
 417         TDM_UT_GOTO_IF_FAIL(msg == TDM_UT_PIPE_MSG_SERVER_READY, failed);
 418
 419         TDM_INFO("*** server fork done ***");
 420
 421         return pid;
 422
 423 failed:
 424         return -1;
 425 }
 426
 427 TEST_P(TDMClient, ClientCreate)
 428 {
 429         tdm_error ret;
 430
 431         client = tdm_client_create(&ret);
 432         ASSERT_EQ(ret, TDM_ERROR_NONE);
 433         ASSERT_NE(client, NULL);
 434 }
 435
 436 TEST_P(TDMClient, ClientCreateNullOther)
 437 {
 438         client = tdm_client_create(NULL);
 439         ASSERT_NE(client, NULL);
 440 }
 441
 442 TEST_P(TDMClient, ClientDestroy)
 443 {
 444         tdm_error ret;
 445
 446         client = tdm_client_create(&ret);
 447         ASSERT_EQ(ret, TDM_ERROR_NONE);
 448         ASSERT_NE(client, NULL);
 449
 450         tdm_client_destroy(client);
 451         client = NULL;
 452 }
 453
 454 TEST_P(TDMClient, ClientNullObject)
 455 {
 456         tdm_client_destroy(NULL);
 457 }
 458
 459 /* tdm_client_get_fd */
 460 TEST_P(TDMClient, ClientGetFd)
 461 {
 462         int fd = TDM_UT_INVALID_VALUE;
 463
 464         ASSERT_EQ(PrepareClient(), true);
 465
 466         ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
 467         ASSERT_GE(fd, 0);
 468 }
 469
 470 TEST_P(TDMClient, ClientGetFdNullObject)
 471 {
 472         int fd = TDM_UT_INVALID_VALUE;
 473         ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
 474         ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
 475 }
 476
 477 TEST_P(TDMClient, ClientGetFdNullOther)
 478 {
 479         ASSERT_EQ(PrepareClient(), true);
 480
 481         ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
 482 }
 483
 484 static void
 485 _tc_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 486 {
 487         bool *done = (bool *)user_data;
 488         if (done)
 489                 *done = true;
 490 }
 491
 492 /* tdm_client_handle_events_timeout */
 493 TEST_P(TDMClient, ClientHandleEvent)
 494 {
 495         bool done = false;
 496
 497         ASSERT_EQ(PrepareClient(), true);
 498
 499         ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
 500         ASSERT_EQ(done, false);
 501
 502         while (!done)
 503                 ASSERT_EQ(tdm_client_handle_events(client), TDM_ERROR_NONE);
 504 }
 505
 506 TEST_P(TDMClient, ClientHandleEventNullObject)
 507 {
 508         ASSERT_EQ(tdm_client_handle_events(NULL), TDM_ERROR_INVALID_PARAMETER);
 509 }
 510
 511 /* tdm_client_wait_vblank, deprecated */
 512 TEST_P(TDMClient, ClientWaitVblank)
 513 {
 514         bool done = false;
 515
 516         ASSERT_EQ(PrepareClient(), true);
 517
 518         ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
 519         ASSERT_EQ(done, false);
 520
 521         while (!done)
 522                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 523 }
 524
 525 /* tdm_client_get_output */
 526 TEST_P(TDMClient, ClientGetOutput)
 527 {
 528         tdm_error ret;
 529
 530         ASSERT_EQ(PrepareClient(), true);
 531
 532         output = tdm_client_get_output(client, NULL, &ret);
 533         ASSERT_EQ(ret, TDM_ERROR_NONE);
 534         ASSERT_NE(output, NULL);
 535 }
 536
 537 TEST_P(TDMClient, ClientGetOutputPrimary)
 538 {
 539         tdm_error ret;
 540
 541         ASSERT_EQ(PrepareClient(), true);
 542
 543         output = tdm_client_get_output(client, (char*)"primary", &ret);
 544         ASSERT_EQ(ret, TDM_ERROR_NONE);
 545         ASSERT_NE(output, NULL);
 546 }
 547
 548 TEST_P(TDMClient, ClientGetOutputDefault)
 549 {
 550         tdm_error ret;
 551
 552         ASSERT_EQ(PrepareClient(), true);
 553
 554         output = tdm_client_get_output(client, (char*)"default", &ret);
 555         ASSERT_EQ(ret, TDM_ERROR_NONE);
 556         ASSERT_NE(output, NULL);
 557 }
 558
 559 TEST_P(TDMClient, ClientGetOutputInvalidName)
 560 {
 561         tdm_error ret;
 562
 563         ASSERT_EQ(PrepareClient(), true);
 564
 565         output = tdm_client_get_output(client, (char*)"invalid", &ret);
 566         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 567         ASSERT_EQ(output, NULL);
 568 }
 569
 570 TEST_P(TDMClient, ClientGetOutputNullObject)
 571 {
 572         tdm_error ret;
 573
 574         output = tdm_client_get_output(NULL, NULL, &ret);
 575         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 576         ASSERT_EQ(output, NULL);
 577 }
 578
 579 TEST_P(TDMClient, ClientGetOutputNullOther)
 580 {
 581         ASSERT_EQ(PrepareClient(), true);
 582
 583         output = tdm_client_get_output(client, NULL, NULL);
 584         ASSERT_NE(output, NULL);
 585 }
 586
 587 static void
 588 _tc_tdm_client_output_change_dpms_cb(tdm_client_output *output,
 589                                                                          tdm_output_change_type type,
 590                                                                          tdm_value value,
 591                                                                          void *user_data)
 592 {
 593         bool *done = (bool *)user_data;
 594
 595         switch (type) {
 596         case TDM_OUTPUT_CHANGE_DPMS:
 597                 if (done)
 598                         *done = true;
 599                 break;
 600         default:
 601                 break;
 602         }
 603 }
 604
 605 /* tdm_client_output_add_change_handler */
 606 TEST_P(TDMClient, ClientOutputAddChangeHandler)
 607 {
 608         bool done = false;
 609         tdm_output_dpms dpms;
 610
 611         ASSERT_EQ(PrepareClient(), true);
 612         ASSERT_EQ(PrepareOutput(), true);
 613
 614         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
 615         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
 616
 617         while (!done)
 618                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 619
 620         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 621         ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
 622
 623         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
 624         while (dpms != TDM_OUTPUT_DPMS_ON) {
 625                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 626                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 627         }
 628 }
 629
 630 TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice)
 631 {
 632         ASSERT_EQ(PrepareClient(), true);
 633         ASSERT_EQ(PrepareOutput(), true);
 634
 635         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
 636         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
 637 }
 638
 639 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject)
 640 {
 641         ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 642 }
 643
 644 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther)
 645 {
 646         ASSERT_EQ(PrepareClient(), true);
 647         ASSERT_EQ(PrepareOutput(), true);
 648
 649         ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 650 }
 651
 652 /* tdm_client_output_remove_change_handler */
 653 TEST_P(TDMClient, ClientOutputRemoveChangeHandler)
 654 {
 655         ASSERT_EQ(PrepareClient(), true);
 656         ASSERT_EQ(PrepareOutput(), true);
 657
 658         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
 659         tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
 660 }
 661
 662 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData)
 663 {
 664         bool done = (bool)TDM_UT_INVALID_VALUE;
 665
 666         ASSERT_EQ(PrepareClient(), true);
 667         ASSERT_EQ(PrepareOutput(), true);
 668
 669         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
 670         tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL);
 671 }
 672
 673 static void
 674 _tc_tdm_client_output_change_dpms_cb2(tdm_client_output *output,
 675                                                                           tdm_output_change_type type,
 676                                                                           tdm_value value,
 677                                                                           void *user_data)
 678 {
 679         switch (type) {
 680         case TDM_OUTPUT_CHANGE_DPMS:
 681                 tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, user_data);
 682                 break;
 683         default:
 684                 break;
 685         }
 686 }
 687
 688 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler)
 689 {
 690         tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
 691
 692         ASSERT_EQ(PrepareClient(), true);
 693         ASSERT_EQ(PrepareOutput(), true);
 694
 695         ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
 696         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
 697         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 698         while (dpms != TDM_OUTPUT_DPMS_OFF) {
 699                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 700                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 701         }
 702
 703         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
 704         while (dpms != TDM_OUTPUT_DPMS_ON)
 705                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 706 }
 707
 708 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
 709 {
 710         tdm_client_output_remove_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL);
 711 }
 712
 713 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther)
 714 {
 715         ASSERT_EQ(PrepareClient(), true);
 716         ASSERT_EQ(PrepareOutput(), true);
 717
 718         tdm_client_output_remove_change_handler(output, NULL, NULL);
 719 }
 720
 721 /* tdm_client_output_get_refresh_rate */
 722 TEST_P(TDMClient, ClientOutputGetRefreshRate)
 723 {
 724         unsigned int refresh = 0;
 725
 726         ASSERT_EQ(PrepareClient(), true);
 727         ASSERT_EQ(PrepareOutput(), true);
 728
 729         ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
 730         ASSERT_GT(refresh, 0);
 731 }
 732
 733 TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject)
 734 {
 735         unsigned int refresh = (unsigned int)TDM_UT_INVALID_VALUE;
 736
 737         ASSERT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
 738         ASSERT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
 739 }
 740
 741 TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther)
 742 {
 743         ASSERT_EQ(PrepareClient(), true);
 744         ASSERT_EQ(PrepareOutput(), true);
 745
 746         ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 747 }
 748
 749 /* tdm_client_output_get_refresh_rate */
 750 TEST_P(TDMClient, ClientOutputGetConnStatus)
 751 {
 752         tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 753
 754         ASSERT_EQ(PrepareClient(), true);
 755         ASSERT_EQ(PrepareOutput(), true);
 756
 757         ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
 758         ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 759 }
 760
 761 TEST_P(TDMClient, ClientOutputGetConnStatusNullObject)
 762 {
 763         tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 764
 765         ASSERT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
 766         ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 767 }
 768
 769 TEST_P(TDMClient, ClientOutputGetConnStatusNullOther)
 770 {
 771         ASSERT_EQ(PrepareClient(), true);
 772         ASSERT_EQ(PrepareOutput(), true);
 773
 774         ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 775 }
 776
 777 /* tdm_client_output_get_dpms */
 778 TEST_P(TDMClient, ClientOutputGetDpms)
 779 {
 780         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 781
 782         ASSERT_EQ(PrepareClient(), true);
 783         ASSERT_EQ(PrepareOutput(), true);
 784
 785         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 786         ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 787 }
 788
 789 TEST_P(TDMClient, ClientOutputGetDpmsNullObject)
 790 {
 791         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 792
 793         ASSERT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
 794         ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 795 }
 796
 797 TEST_P(TDMClient, ClientOutputGetDpmsNullOther)
 798 {
 799         ASSERT_EQ(PrepareClient(), true);
 800         ASSERT_EQ(PrepareOutput(), true);
 801
 802         ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 803 }
 804
 805 /* tdm_client_output_create_vblank */
 806 TEST_P(TDMClient, ClientOutputCreateVblank)
 807 {
 808         tdm_error ret;
 809
 810         ASSERT_EQ(PrepareClient(), true);
 811         ASSERT_EQ(PrepareOutput(), true);
 812
 813         vblank = tdm_client_output_create_vblank(output, &ret);
 814         ASSERT_EQ(ret, TDM_ERROR_NONE);
 815         ASSERT_NE(vblank, NULL);
 816 }
 817
 818 TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
 819 {
 820         tdm_error ret;
 821
 822         vblank = tdm_client_output_create_vblank(NULL, &ret);
 823         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 824         ASSERT_EQ(vblank, NULL);
 825 }
 826
 827 TEST_P(TDMClient, ClientOutputCreateVblankNullOther)
 828 {
 829         ASSERT_EQ(PrepareClient(), true);
 830         ASSERT_EQ(PrepareOutput(), true);
 831
 832         vblank = tdm_client_output_create_vblank(output, NULL);
 833         ASSERT_NE(vblank, NULL);
 834 }
 835
 836 /* tdm_client_vblank_destroy */
 837 TEST_P(TDMClient, ClientVblankDestroy)
 838 {
 839         tdm_error ret;
 840
 841         ASSERT_EQ(PrepareClient(), true);
 842         ASSERT_EQ(PrepareOutput(), true);
 843
 844         vblank = tdm_client_output_create_vblank(output, &ret);
 845         ASSERT_EQ(ret, TDM_ERROR_NONE);
 846         ASSERT_NE(vblank, NULL);
 847
 848         tdm_client_vblank_destroy(vblank);
 849         vblank = NULL;
 850 }
 851
 852 TEST_P(TDMClient, ClientVblankDestroyNullObject)
 853 {
 854         tdm_client_vblank_destroy(NULL);
 855 }
 856
 857 /* tdm_client_vblank_set_name */
 858 TEST_P(TDMClient, ClientVblankSetName)
 859 {
 860         ASSERT_EQ(PrepareClient(), true);
 861         ASSERT_EQ(PrepareOutput(), true);
 862         ASSERT_EQ(PrepareVblank(), true);
 863
 864         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 865 }
 866
 867 TEST_P(TDMClient, ClientVblankSetNameTwice)
 868 {
 869         ASSERT_EQ(PrepareClient(), true);
 870         ASSERT_EQ(PrepareOutput(), true);
 871         ASSERT_EQ(PrepareVblank(), true);
 872
 873         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 874         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 875 }
 876
 877 TEST_P(TDMClient, ClientVblankSetNameNullObject)
 878 {
 879         ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 880 }
 881
 882 /* tdm_client_vblank_set_sync */
 883 TEST_P(TDMClient, ClientVblankSetSync)
 884 {
 885         ASSERT_EQ(PrepareClient(), true);
 886         ASSERT_EQ(PrepareOutput(), true);
 887         ASSERT_EQ(PrepareVblank(), true);
 888
 889         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 890 }
 891
 892 TEST_P(TDMClient, ClientVblankSetSyncTwice)
 893 {
 894         ASSERT_EQ(PrepareClient(), true);
 895         ASSERT_EQ(PrepareOutput(), true);
 896         ASSERT_EQ(PrepareVblank(), true);
 897
 898         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 899         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 900 }
 901
 902 TEST_P(TDMClient, ClientVblankSetSyncNullObject)
 903 {
 904         ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 905 }
 906
 907 /* tdm_client_vblank_set_fps */
 908 TEST_P(TDMClient, ClientVblankSetFps)
 909 {
 910         ASSERT_EQ(PrepareClient(), true);
 911         ASSERT_EQ(PrepareOutput(), true);
 912         ASSERT_EQ(PrepareVblank(), true);
 913
 914         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 915 }
 916
 917 TEST_P(TDMClient, ClientVblankSetFpsTwice)
 918 {
 919         ASSERT_EQ(PrepareClient(), true);
 920         ASSERT_EQ(PrepareOutput(), true);
 921         ASSERT_EQ(PrepareVblank(), true);
 922
 923         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 924         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 925 }
 926
 927 TEST_P(TDMClient, ClientVblankSetFpsNullObject)
 928 {
 929         ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
 930 }
 931
 932 /* tdm_client_vblank_set_offset */
 933 TEST_P(TDMClient, ClientVblankSetOffset)
 934 {
 935         ASSERT_EQ(PrepareClient(), true);
 936         ASSERT_EQ(PrepareOutput(), true);
 937         ASSERT_EQ(PrepareVblank(), true);
 938
 939         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 940 }
 941
 942 TEST_P(TDMClient, ClientVblankSetOffsetTwice)
 943 {
 944         ASSERT_EQ(PrepareClient(), true);
 945         ASSERT_EQ(PrepareOutput(), true);
 946         ASSERT_EQ(PrepareVblank(), true);
 947
 948         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 949         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 950 }
 951
 952 TEST_P(TDMClient, ClientVblankSetOffsetNullObject)
 953 {
 954         ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 955 }
 956
 957 /* tdm_client_vblank_set_enable_fake */
 958 TEST_P(TDMClient, ClientVblankSetEnableFake)
 959 {
 960         ASSERT_EQ(PrepareClient(), true);
 961         ASSERT_EQ(PrepareOutput(), true);
 962         ASSERT_EQ(PrepareVblank(), true);
 963
 964         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 965 }
 966
 967 TEST_P(TDMClient, ClientVblankSetEnableFakeTwice)
 968 {
 969         ASSERT_EQ(PrepareClient(), true);
 970         ASSERT_EQ(PrepareOutput(), true);
 971         ASSERT_EQ(PrepareVblank(), true);
 972
 973         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 974         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 975 }
 976
 977 TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject)
 978 {
 979         ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 980 }
 981
 982 static void
 983 _tc_tdm_client_vblank_cb2(tdm_client_vblank *vblank,
 984                                                   tdm_error error,
 985                                                   unsigned int sequence,
 986                                                   unsigned int tv_sec,
 987                                                   unsigned int tv_usec,
 988                                                   void *user_data)
 989 {
 990         bool *done = (bool *)user_data;
 991         if (done)
 992                 *done = true;
 993 }
 994
 995 /* tdm_client_vblank_wait */
 996 TEST_P(TDMClient, ClientVblankWait)
 997 {
 998         bool done;
 999
1000         ASSERT_EQ(PrepareClient(), true);
1001         ASSERT_EQ(PrepareOutput(), true);
1002         ASSERT_EQ(PrepareVblank(), true);
1003
1004         done = false;
1005         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1006
1007         start = tdm_helper_get_time();
1008         while (!done)
1009                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1010         end = tdm_helper_get_time();
1011
1012         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1013         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1014 }
1015
1016 TEST_P(TDMClient, ClientVblankWaitFewTime)
1017 {
1018         bool done1, done2, done3;
1019
1020         ASSERT_EQ(PrepareClient(), true);
1021         ASSERT_EQ(PrepareOutput(), true);
1022         ASSERT_EQ(PrepareVblank(), true);
1023
1024         done1 = done2 = done3 = false;
1025         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
1026         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
1027         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
1028
1029         start = tdm_helper_get_time();
1030         while (!done1 || !done2 || !done3)
1031                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1032         end = tdm_helper_get_time();
1033
1034         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1035         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1036
1037 }
1038
1039 TEST_P(TDMClient, ClientVblankWaitInterval0)
1040 {
1041         ASSERT_EQ(PrepareClient(), true);
1042         ASSERT_EQ(PrepareOutput(), true);
1043         ASSERT_EQ(PrepareVblank(), true);
1044
1045         ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
1046 }
1047
1048 TEST_P(TDMClient, ClientVblankWaitInterval)
1049 {
1050         bool done;
1051
1052         ASSERT_EQ(PrepareClient(), true);
1053         ASSERT_EQ(PrepareOutput(), true);
1054         ASSERT_EQ(PrepareVblank(), true);
1055
1056         /* start from 1 */
1057         for (int t = 1; t < 10; t++) {
1058                 done = false;
1059                 ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1060
1061                 start = tdm_helper_get_time();
1062                 while (!done)
1063                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1064                 end = tdm_helper_get_time();
1065
1066                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1067                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1068                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1069         }
1070 }
1071
1072 static void
1073 _tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
1074                                                   tdm_error error,
1075                                                   unsigned int sequence,
1076                                                   unsigned int tv_sec,
1077                                                   unsigned int tv_usec,
1078                                                   void *user_data)
1079 {
1080         unsigned int *cur_seq = (unsigned int *)user_data;
1081         if (cur_seq)
1082                 *cur_seq = sequence;
1083 }
1084
1085 TEST_P(TDMClient, ClientVblankWaitSeq)
1086 {
1087         ASSERT_EQ(PrepareClient(), true);
1088         ASSERT_EQ(PrepareOutput(), true);
1089         ASSERT_EQ(PrepareVblank(), true);
1090
1091         for (int t = 0; t < 10; t++) {
1092                 unsigned int cur_seq = 0, temp = 0;
1093
1094                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1095                 while (cur_seq == 0)
1096                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1097
1098                 start = tdm_helper_get_time();
1099                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1100                 while (temp == 0)
1101                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1102                 end = tdm_helper_get_time();
1103
1104                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1105                 ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1106         }
1107 }
1108
1109 TEST_P(TDMClient, ClientVblankWaitSeqInterval)
1110 {
1111         ASSERT_EQ(PrepareClient(), true);
1112         ASSERT_EQ(PrepareOutput(), true);
1113         ASSERT_EQ(PrepareVblank(), true);
1114
1115         /* start from 1 */
1116         for (int t = 1; t < 10; t++) {
1117                 unsigned int cur_seq = 0, temp = 0;
1118
1119                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1120                 while (cur_seq == 0)
1121                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1122
1123                 start = tdm_helper_get_time();
1124                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1125                 while (temp == 0)
1126                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1127                 end = tdm_helper_get_time();
1128
1129                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1130                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1131                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1132         }
1133 }
1134
1135 TEST_P(TDMClient, ClientVblankWaitSetOffset)
1136 {
1137         bool done;
1138
1139         ASSERT_EQ(PrepareClient(), true);
1140         ASSERT_EQ(PrepareOutput(), true);
1141         ASSERT_EQ(PrepareVblank(), true);
1142
1143         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
1144
1145         done = false;
1146         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1147
1148         start = tdm_helper_get_time();
1149         while (!done)
1150                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1151         end = tdm_helper_get_time();
1152
1153         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1154         ASSERT_GT((end - start), (0.1));
1155         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
1156 }
1157
1158 TEST_P(TDMClient, ClientVblankWaitSetFps)
1159 {
1160         bool done;
1161         double interval;
1162         unsigned int fps = 10;
1163
1164         ASSERT_EQ(PrepareClient(), true);
1165         ASSERT_EQ(PrepareOutput(), true);
1166         ASSERT_EQ(PrepareVblank(), true);
1167
1168         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
1169         interval = 1.0 / (double)fps;
1170
1171         done = false;
1172         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1173
1174         start = tdm_helper_get_time();
1175         while (!done)
1176                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1177         end = tdm_helper_get_time();
1178
1179         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1180         ASSERT_GT((end - start), (interval - vrefresh_interval));
1181         ASSERT_LT((end - start), (interval + vrefresh_interval));
1182 }
1183
1184 #if 0
1185
1186 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1187 {
1188         TDM_UT_SKIP_FLAG(has_outputs);
1189
1190         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1191         double vrefresh_interval;
1192         unsigned int cur_seq[3];
1193         unsigned int global_fps = 5;
1194         double start, end, interval;
1195
1196         ASSERT_EQ(TestPrepareOutput(), true);
1197         ASSERT_EQ(TestCreateVblanks3(), true);
1198         ASSERT_EQ(vblank_count, 3);
1199
1200         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1201         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1202         vrefresh_interval = 1.0 / (double)fps;
1203
1204         for (int v = 0; v < 3; v++)
1205                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
1206
1207         /* enable test */
1208         tdm_vblank_enable_global_fps(1, global_fps);
1209         interval = 1.0 / (double)global_fps;
1210
1211         for (int v = 0; v < 3; v++) {
1212                 cur_seq[v] = 0;
1213                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1214         }
1215
1216         start = tdm_helper_get_time();
1217         while (cur_seq[0] == 0)
1218                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1219         end = tdm_helper_get_time();
1220
1221         ASSERT_NE(cur_seq[1], 0);
1222         ASSERT_NE(cur_seq[2], 0);
1223
1224         /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
1225         ASSERT_GT((end - start), (interval - vrefresh_interval));
1226         ASSERT_LT((end - start), (interval + vrefresh_interval));
1227
1228         /* disable test */
1229         tdm_vblank_enable_global_fps(0, 0);
1230
1231         for (int v = 0; v < 3; v++) {
1232                 cur_seq[v] = 0;
1233                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1234         }
1235
1236         while (cur_seq[0] == 0)
1237                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1238         ASSERT_EQ(cur_seq[1], 0);
1239         ASSERT_EQ(cur_seq[2], 0);
1240
1241         while (cur_seq[1] == 0)
1242                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1243         ASSERT_EQ(cur_seq[2], 0);
1244 }
1245
1246 TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
1247 {
1248         TDM_UT_SKIP_FLAG(has_outputs);
1249
1250         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1251         unsigned int cur_seq[3];
1252         unsigned int global_fps = 5;
1253         double start, end, interval;
1254
1255         ASSERT_EQ(TestPrepareOutput(), true);
1256         ASSERT_EQ(TestCreateVblanks3(), true);
1257         ASSERT_EQ(vblank_count, 3);
1258
1259         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1260         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1261         interval = 1.0 / (double)fps;
1262
1263         /* 2nd vblank will ignore the global fps. */
1264         ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
1265
1266         tdm_vblank_enable_global_fps(1, global_fps);
1267
1268         for (int v = 0; v < 3; v++) {
1269                 cur_seq[v] = 0;
1270                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1271         }
1272
1273         start = tdm_helper_get_time();
1274         while (cur_seq[1] == 0)
1275                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1276         end = tdm_helper_get_time();
1277
1278         ASSERT_EQ(cur_seq[0], 0);
1279         ASSERT_EQ(cur_seq[2], 0);
1280
1281         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1282         ASSERT_LT((end - start), (interval + interval));
1283
1284         while (cur_seq[0] == 0)
1285                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1286         ASSERT_NE(cur_seq[2], 0);
1287 }
1288
1289 #endif
1290
1291 TEST_P(TDMClient, ClientVblankWaitNullObject)
1292 {
1293         unsigned int cur_seq = 0;
1294
1295         ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1296 }
1297
1298 TEST_P(TDMClient, ClientVblankWaitNullOther)
1299 {
1300         ASSERT_EQ(PrepareClient(), true);
1301         ASSERT_EQ(PrepareOutput(), true);
1302         ASSERT_EQ(PrepareVblank(), true);
1303
1304         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1305 }
1306
1307 TEST_P(TDMClient, ClientVblankWaitDpmsOff)
1308 {
1309         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1310
1311         ASSERT_EQ(PrepareClient(), true);
1312         ASSERT_EQ(PrepareOutput(), true);
1313         ASSERT_EQ(PrepareVblank(), true);
1314
1315         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1316         while (dpms != TDM_OUTPUT_DPMS_OFF)
1317                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1318         ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
1319
1320         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
1321
1322         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1323         while (dpms != TDM_OUTPUT_DPMS_ON)
1324                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1325 }
1326
1327 TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
1328 {
1329         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1330         bool done;
1331
1332         ASSERT_EQ(PrepareClient(), true);
1333         ASSERT_EQ(PrepareOutput(), true);
1334         ASSERT_EQ(PrepareVblank(), true);
1335
1336         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1337         while (dpms != TDM_OUTPUT_DPMS_OFF)
1338                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1339
1340         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1341
1342         done = false;
1343         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1344
1345         while (!done)
1346                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1347
1348         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1349         while (dpms != TDM_OUTPUT_DPMS_ON)
1350                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1351 }
1352
1353 /* tdm_client_vblank_wait */
1354 TEST_P(TDMClient, ClientVblankIsWaiting)
1355 {
1356         bool done;
1357         unsigned int waiting;
1358
1359         ASSERT_EQ(PrepareClient(), true);
1360         ASSERT_EQ(PrepareOutput(), true);
1361         ASSERT_EQ(PrepareVblank(), true);
1362
1363         done = false;
1364         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1365
1366         waiting = tdm_client_vblank_is_waiting(vblank);
1367         ASSERT_EQ(waiting, 1);
1368
1369         start = tdm_helper_get_time();
1370         while (!done)
1371                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1372         end = tdm_helper_get_time();
1373
1374         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1375         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1376
1377         waiting = tdm_client_vblank_is_waiting(vblank);
1378         ASSERT_EQ(waiting, 0);
1379 }
1380
1381 /* tdm_client_vblank_wait */
1382 TEST_P(TDMClient, ClientVblankIsWaitingNullObject)
1383 {
1384         unsigned int waiting = tdm_client_vblank_is_waiting(NULL);
1385         ASSERT_EQ(waiting, 0);
1386 }
1387
1388 TEST_P(TDMClient, ClientCreateVOutput)
1389 {
1390         tdm_error ret;
1391         const char name[TDM_NAME_LEN] = "Virtual Output";
1392
1393         ASSERT_EQ(PrepareClient(), true);
1394
1395         voutput = tdm_client_create_voutput(client, name, &ret);
1396         ASSERT_EQ(ret, TDM_ERROR_NONE);
1397         ASSERT_NE(voutput, NULL);
1398
1399         tdm_client_voutput_destroy(voutput);
1400 }
1401
1402 class TDMVirtualOutput : public ::testing::Test
1403 {
1404 public:
1405         TDMVirtualOutput() {};
1406         ~TDMVirtualOutput() {};
1407
1408         static void SetUpTestCase();
1409         static void TearDownTestCase();
1410         static bool PrepareVOutput(void);
1411
1412 protected:
1413         static tdm_client *client;
1414         static tdm_client_voutput *voutput;
1415         const int MODE_COUNT = 2;
1416
1417 private:
1418         static pid_t server_pid;
1419
1420         /* 0: read, 1: write */
1421         static int pipe_parent[2];
1422         static int pipe_child[2];
1423
1424         static void ServerFork(void);
1425         static void ServerKill(void);
1426 };
1427
1428 pid_t TDMVirtualOutput::server_pid = -1;
1429 int TDMVirtualOutput::pipe_parent[2] = {-1, -1};
1430 int TDMVirtualOutput::pipe_child[2] = {-1, -1};
1431 tdm_client* TDMVirtualOutput::client = nullptr;
1432 tdm_client_voutput* TDMVirtualOutput::voutput = nullptr;
1433
1434 void TDMVirtualOutput::ServerKill(void)
1435 {
1436         if (pipe_child[0] >= 0)
1437                 close(pipe_child[0]);
1438         if (pipe_child[1] >= 0) {
1439                 if (server_pid > 0) {
1440                         bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
1441                         if (ret) {
1442                                 if (waitpid(server_pid, NULL, 0) == server_pid)
1443                                         TDM_INFO("*** server terminated ***");
1444                                 else
1445                                         TDM_ERR("*** failed to terminate server ***");
1446                         } else {
1447                                 if (kill(server_pid, 9) < 0)
1448                                         TDM_ERR("*** failed to kill server ***");
1449                         }
1450                 }
1451                 close(pipe_child[1]);
1452         }
1453
1454         if (pipe_parent[0] >= 0)
1455                 close(pipe_parent[0]);
1456         if (pipe_parent[1] >= 0)
1457                 close(pipe_parent[1]);
1458
1459         server_pid = -1;
1460         pipe_parent[0] = pipe_parent[1] = -1;
1461         pipe_child[0] = pipe_child[1] = -1;
1462 }
1463
1464 void TDMVirtualOutput::ServerFork(void)
1465 {
1466         if (server_pid > 0)
1467                 return;
1468
1469         server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
1470         ASSERT_GT(server_pid, 0);
1471 }
1472
1473 void TDMVirtualOutput::SetUpTestCase(void)
1474 {
1475         setenv("XDG_RUNTIME_DIR", "/run", 1);
1476         setenv("TBM_DISPLAY_SERVER", "1", 1);
1477
1478         if (server_pid == -1)
1479                 ServerFork();
1480
1481         ASSERT_EQ(PrepareVOutput(), true);
1482 }
1483
1484 void TDMVirtualOutput::TearDownTestCase(void)
1485 {
1486 //      TDM_UT_WAIT("check & press");
1487
1488         if (voutput)
1489                 tdm_client_voutput_destroy(voutput);
1490
1491         if (client)
1492                 tdm_client_destroy(client);
1493
1494         ServerKill();
1495
1496         unsetenv("XDG_RUNTIME_DIR");
1497         unsetenv("TBM_DISPLAY_SERVER");
1498 }
1499
1500 bool TDMVirtualOutput::PrepareVOutput(void)
1501 {
1502         tdm_error ret;
1503         const char name[TDM_NAME_LEN] = "Virtual Output";
1504
1505         client = tdm_client_create(&ret);
1506         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
1507         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
1508
1509
1510         voutput = tdm_client_create_voutput(client, name, &ret);
1511         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
1512         TDM_UT_RETURN_FALSE_IF_FAIL(voutput != NULL);
1513
1514 //      TDM_UT_WAIT("check & press");
1515
1516         return true;
1517 }
1518
1519 static void
1520 _tc_tdm_client_virutual_make_available_mode(tdm_client_output_mode *modes, int count)
1521 {
1522         int i;
1523
1524         for (i = 0; i < count; i++) {
1525                 modes[i].clock = 25200;
1526                 modes[i].hdisplay = 640;
1527                 modes[i].hsync_start = 656;
1528                 modes[i].hsync_end = 752;
1529                 modes[i].htotal = 800;
1530                 modes[i].hskew = 0;
1531                 modes[i].vdisplay = 480;
1532                 modes[i].vsync_start = 490;
1533                 modes[i].vsync_end = 492;
1534                 modes[i].vtotal = 525;
1535                 modes[i].vscan = 0;
1536                 modes[i].vrefresh = 30;
1537                 modes[i].flags = 0;
1538                 modes[i].type = 0;
1539                 snprintf(modes[i].name, TDM_NAME_LEN, "%dx%d_%d", modes[i].hdisplay, modes[i].vdisplay, i);
1540         }
1541 }
1542
1543 TEST_F(TDMVirtualOutput, SetAvailableModes)
1544 {
1545         tdm_error ret;
1546         tdm_client_output_mode modes[this->MODE_COUNT];
1547         int count = this->MODE_COUNT;
1548
1549         _tc_tdm_client_virutual_make_available_mode(modes, count);
1550
1551         ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
1552         ASSERT_EQ(ret, TDM_ERROR_NONE);
1553 }
1554
1555 TEST_F(TDMVirtualOutput, FailTestSetAvailableModes)
1556 {
1557         tdm_error ret;
1558         tdm_client_output_mode modes[this->MODE_COUNT];
1559         int count = this->MODE_COUNT;
1560
1561         ret = tdm_client_voutput_set_available_modes(NULL, modes, count);
1562         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1563
1564         ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count);
1565         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1566 }
1567
1568 TEST_F(TDMVirtualOutput, SetPhysicalSize)
1569 {
1570         tdm_error ret;
1571         unsigned int mmWidth = 1234, mmHeight = 1234;
1572
1573         ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
1574         ASSERT_EQ(ret, TDM_ERROR_NONE);
1575 }
1576
1577 TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize)
1578 {
1579         tdm_error ret;
1580         unsigned int invalid_mmWidth = 0, invalid_mmHeight = 0;
1581
1582         ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight);
1583         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1584 }
1585
1586 static void
1587 _tc_tdm_client_voutput_commit_handler(tdm_client_voutput *voutput, tbm_surface_h buffer, void *user_data)
1588 {
1589         int *flag;
1590         flag = (int *)user_data;
1591         *flag = 1;
1592 }
1593
1594 TEST_F(TDMVirtualOutput, AddCommitHandler)
1595 {
1596         tdm_error ret;
1597         int flag_callback_called = 0;
1598
1599         ret = tdm_client_voutput_add_commit_handler(this->voutput,
1600                                                                                                 _tc_tdm_client_voutput_commit_handler,
1601                                                                                                 &flag_callback_called);
1602         ASSERT_EQ(ret, TDM_ERROR_NONE);
1603 //      ASSERT_EQ(flag_callback_called, 1);
1604
1605         tdm_client_voutput_remove_commit_handler(this->voutput,
1606                                                                                          _tc_tdm_client_voutput_commit_handler,
1607                                                                                          &flag_callback_called);
1608 }
1609
1610 TEST_F(TDMVirtualOutput, CommitDone)
1611 {
1612         tdm_error ret;
1613
1614         ret = tdm_client_voutput_commit_done(this->voutput);
1615         ASSERT_EQ(ret, TDM_ERROR_NONE);
1616 }
1617
1618 TEST_F(TDMVirtualOutput, GetClientOutput)
1619 {
1620         tdm_error ret;
1621         tdm_client_output *output;
1622
1623         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1624         ASSERT_EQ(ret, TDM_ERROR_NONE);
1625         ASSERT_NE(output, NULL);
1626 }
1627
1628 TEST_F(TDMVirtualOutput, Connect)
1629 {
1630         tdm_error ret;
1631         tdm_client_output *output;
1632         unsigned int mmWidth = 300, mmHeight = 150;
1633         tdm_client_output_mode modes[this->MODE_COUNT];
1634         int count = this->MODE_COUNT;
1635
1636         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1637         ASSERT_EQ(ret, TDM_ERROR_NONE);
1638         ASSERT_NE(output, NULL);
1639
1640         ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
1641         ASSERT_EQ(ret, TDM_ERROR_NONE);
1642
1643         _tc_tdm_client_virutual_make_available_mode(modes, count);
1644         ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
1645         ASSERT_EQ(ret, TDM_ERROR_NONE);
1646
1647         ret = tdm_client_output_connect(output);
1648         ASSERT_EQ(ret, TDM_ERROR_NONE);
1649
1650         tdm_client_handle_events_timeout(this->client, 0);
1651 }
1652
1653 TEST_F(TDMVirtualOutput, Disconnect)
1654 {
1655         tdm_error ret;
1656         tdm_client_output *output;
1657
1658 //      TDM_UT_WAIT("check & press");
1659
1660         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1661         ASSERT_EQ(ret, TDM_ERROR_NONE);
1662         ASSERT_NE(output, NULL);
1663
1664         ret = tdm_client_output_disconnect(output);
1665         ASSERT_EQ(ret, TDM_ERROR_NONE);
1666
1667         tdm_client_handle_events_timeout(this->client, 0);
1668 }
1669
1670 #if 0
1671 TEST_F(TDMVirtualOutput, FailTestGetClientOutput)
1672 {
1673         tdm_error ret;
1674 }
1675
1676 TEST_F(TDMVirtualOutput, SetBufferQueue)
1677 {
1678         tdm_error ret;
1679 }
1680
1681 TEST_F(TDMVirtualOutput, FailTestSetBufferQueue)
1682 {
1683         tdm_error ret;
1684 }
1685
1686 #endif
1687
1688 #ifdef TDM_UT_TEST_WITH_PARAMS
1689 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1690                                                 TDMClient,
1691                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1692 #else
1693 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1694                                                 TDMClient,
1695                                                 Values(TDM_DEFAULT_MODULE));
1696 #endif
1697
1698 /* LCOV_EXCL_END */