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 TEST_P(TDMClient, ClientOutputGetAvailableModes)
 806 {
 807         tdm_client_output_mode *modes;
 808         int i, count = 0;
 809
 810         ASSERT_EQ(PrepareClient(), true);
 811         ASSERT_EQ(PrepareOutput(), true);
 812
 813         ASSERT_EQ(tdm_client_output_get_available_modes(output, &modes, &count), TDM_ERROR_NONE);
 814         ASSERT_GT(count, 0);
 815
 816         for (i = 0; i < count; i++) {
 817                 tdm_client_output_mode *mode = (tdm_client_output_mode *)&modes[i];
 818                 ASSERT_GT(mode->hdisplay, 0);
 819                 ASSERT_GT(mode->vdisplay, 0);
 820                 ASSERT_GT(mode->vrefresh, 0);
 821         }
 822 }
 823
 824 TEST_P(TDMClient, ClientOutputGetAvailableModesNullObject)
 825 {
 826         tdm_client_output_mode *modes;
 827         int count = TDM_UT_INVALID_VALUE;
 828
 829         ASSERT_EQ(PrepareClient(), true);
 830         ASSERT_EQ(PrepareOutput(), true);
 831
 832         ASSERT_EQ(tdm_client_output_get_available_modes(NULL, &modes, &count), TDM_ERROR_INVALID_PARAMETER);
 833         ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
 834 }
 835
 836 TEST_P(TDMClient, ClientOutputGetAvailableModesNullOther)
 837 {
 838         ASSERT_EQ(PrepareClient(), true);
 839         ASSERT_EQ(PrepareOutput(), true);
 840
 841         ASSERT_EQ(tdm_client_output_get_available_modes(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 842 }
 843
 844 TEST_P(TDMClient, ClientOutputSetMode)
 845 {
 846         tdm_client_output_mode *modes;
 847         int count = 0;
 848
 849         ASSERT_EQ(PrepareClient(), true);
 850         ASSERT_EQ(PrepareOutput(), true);
 851
 852         ASSERT_EQ(tdm_client_output_get_available_modes(output, &modes, &count), TDM_ERROR_NONE);
 853         ASSERT_GT(count, -1);
 854
 855         printf("count:%d\n", count);
 856
 857         ASSERT_EQ(tdm_client_output_set_mode(output, count - 1), TDM_ERROR_NONE);
 858 }
 859
 860 TEST_P(TDMClient, ClientOutputSetModeiNullObject)
 861 {
 862         ASSERT_EQ(PrepareClient(), true);
 863         ASSERT_EQ(PrepareOutput(), true);
 864
 865         ASSERT_EQ(tdm_client_output_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER);
 866 }
 867
 868 TEST_P(TDMClient, ClientOutputSetModeInvalidIndex)
 869 {
 870         ASSERT_EQ(PrepareClient(), true);
 871         ASSERT_EQ(PrepareOutput(), true);
 872
 873         ASSERT_EQ(tdm_client_output_set_mode(output, -1), TDM_ERROR_INVALID_PARAMETER);
 874 }
 875
 876 /* tdm_client_output_create_vblank */
 877 TEST_P(TDMClient, ClientOutputCreateVblank)
 878 {
 879         tdm_error ret;
 880
 881         ASSERT_EQ(PrepareClient(), true);
 882         ASSERT_EQ(PrepareOutput(), true);
 883
 884         vblank = tdm_client_output_create_vblank(output, &ret);
 885         ASSERT_EQ(ret, TDM_ERROR_NONE);
 886         ASSERT_NE(vblank, NULL);
 887 }
 888
 889 TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
 890 {
 891         tdm_error ret;
 892
 893         vblank = tdm_client_output_create_vblank(NULL, &ret);
 894         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 895         ASSERT_EQ(vblank, NULL);
 896 }
 897
 898 TEST_P(TDMClient, ClientOutputCreateVblankNullOther)
 899 {
 900         ASSERT_EQ(PrepareClient(), true);
 901         ASSERT_EQ(PrepareOutput(), true);
 902
 903         vblank = tdm_client_output_create_vblank(output, NULL);
 904         ASSERT_NE(vblank, NULL);
 905 }
 906
 907 /* tdm_client_vblank_destroy */
 908 TEST_P(TDMClient, ClientVblankDestroy)
 909 {
 910         tdm_error ret;
 911
 912         ASSERT_EQ(PrepareClient(), true);
 913         ASSERT_EQ(PrepareOutput(), true);
 914
 915         vblank = tdm_client_output_create_vblank(output, &ret);
 916         ASSERT_EQ(ret, TDM_ERROR_NONE);
 917         ASSERT_NE(vblank, NULL);
 918
 919         tdm_client_vblank_destroy(vblank);
 920         vblank = NULL;
 921 }
 922
 923 TEST_P(TDMClient, ClientVblankDestroyNullObject)
 924 {
 925         tdm_client_vblank_destroy(NULL);
 926 }
 927
 928 /* tdm_client_vblank_set_name */
 929 TEST_P(TDMClient, ClientVblankSetName)
 930 {
 931         ASSERT_EQ(PrepareClient(), true);
 932         ASSERT_EQ(PrepareOutput(), true);
 933         ASSERT_EQ(PrepareVblank(), true);
 934
 935         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 936 }
 937
 938 TEST_P(TDMClient, ClientVblankSetNameTwice)
 939 {
 940         ASSERT_EQ(PrepareClient(), true);
 941         ASSERT_EQ(PrepareOutput(), true);
 942         ASSERT_EQ(PrepareVblank(), true);
 943
 944         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 945         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 946 }
 947
 948 TEST_P(TDMClient, ClientVblankSetNameNullObject)
 949 {
 950         ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 951 }
 952
 953 /* tdm_client_vblank_set_sync */
 954 TEST_P(TDMClient, ClientVblankSetSync)
 955 {
 956         ASSERT_EQ(PrepareClient(), true);
 957         ASSERT_EQ(PrepareOutput(), true);
 958         ASSERT_EQ(PrepareVblank(), true);
 959
 960         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 961 }
 962
 963 TEST_P(TDMClient, ClientVblankSetSyncTwice)
 964 {
 965         ASSERT_EQ(PrepareClient(), true);
 966         ASSERT_EQ(PrepareOutput(), true);
 967         ASSERT_EQ(PrepareVblank(), true);
 968
 969         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 970         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 971 }
 972
 973 TEST_P(TDMClient, ClientVblankSetSyncNullObject)
 974 {
 975         ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 976 }
 977
 978 /* tdm_client_vblank_set_fps */
 979 TEST_P(TDMClient, ClientVblankSetFps)
 980 {
 981         ASSERT_EQ(PrepareClient(), true);
 982         ASSERT_EQ(PrepareOutput(), true);
 983         ASSERT_EQ(PrepareVblank(), true);
 984
 985         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 986 }
 987
 988 TEST_P(TDMClient, ClientVblankSetFpsTwice)
 989 {
 990         ASSERT_EQ(PrepareClient(), true);
 991         ASSERT_EQ(PrepareOutput(), true);
 992         ASSERT_EQ(PrepareVblank(), true);
 993
 994         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 995         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 996 }
 997
 998 TEST_P(TDMClient, ClientVblankSetFpsNullObject)
 999 {
1000         ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
1001 }
1002
1003 /* tdm_client_vblank_set_offset */
1004 TEST_P(TDMClient, ClientVblankSetOffset)
1005 {
1006         ASSERT_EQ(PrepareClient(), true);
1007         ASSERT_EQ(PrepareOutput(), true);
1008         ASSERT_EQ(PrepareVblank(), true);
1009
1010         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
1011 }
1012
1013 TEST_P(TDMClient, ClientVblankSetOffsetTwice)
1014 {
1015         ASSERT_EQ(PrepareClient(), true);
1016         ASSERT_EQ(PrepareOutput(), true);
1017         ASSERT_EQ(PrepareVblank(), true);
1018
1019         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
1020         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
1021 }
1022
1023 TEST_P(TDMClient, ClientVblankSetOffsetNullObject)
1024 {
1025         ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
1026 }
1027
1028 /* tdm_client_vblank_set_enable_fake */
1029 TEST_P(TDMClient, ClientVblankSetEnableFake)
1030 {
1031         ASSERT_EQ(PrepareClient(), true);
1032         ASSERT_EQ(PrepareOutput(), true);
1033         ASSERT_EQ(PrepareVblank(), true);
1034
1035         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1036 }
1037
1038 TEST_P(TDMClient, ClientVblankSetEnableFakeTwice)
1039 {
1040         ASSERT_EQ(PrepareClient(), true);
1041         ASSERT_EQ(PrepareOutput(), true);
1042         ASSERT_EQ(PrepareVblank(), true);
1043
1044         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1045         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1046 }
1047
1048 TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject)
1049 {
1050         ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
1051 }
1052
1053 static void
1054 _tc_tdm_client_vblank_cb2(tdm_client_vblank *vblank,
1055                                                   tdm_error error,
1056                                                   unsigned int sequence,
1057                                                   unsigned int tv_sec,
1058                                                   unsigned int tv_usec,
1059                                                   void *user_data)
1060 {
1061         bool *done = (bool *)user_data;
1062         if (done)
1063                 *done = true;
1064 }
1065
1066 /* tdm_client_vblank_wait */
1067 TEST_P(TDMClient, ClientVblankWait)
1068 {
1069         bool done;
1070
1071         ASSERT_EQ(PrepareClient(), true);
1072         ASSERT_EQ(PrepareOutput(), true);
1073         ASSERT_EQ(PrepareVblank(), true);
1074
1075         done = false;
1076         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1077
1078         start = tdm_helper_get_time();
1079         while (!done)
1080                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1081         end = tdm_helper_get_time();
1082
1083         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1084         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1085 }
1086
1087 TEST_P(TDMClient, ClientVblankWaitFewTime)
1088 {
1089         bool done1, done2, done3;
1090
1091         ASSERT_EQ(PrepareClient(), true);
1092         ASSERT_EQ(PrepareOutput(), true);
1093         ASSERT_EQ(PrepareVblank(), true);
1094
1095         done1 = done2 = done3 = false;
1096         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
1097         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
1098         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
1099
1100         start = tdm_helper_get_time();
1101         while (!done1 || !done2 || !done3)
1102                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1103         end = tdm_helper_get_time();
1104
1105         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1106         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1107
1108 }
1109
1110 TEST_P(TDMClient, ClientVblankWaitInterval0)
1111 {
1112         ASSERT_EQ(PrepareClient(), true);
1113         ASSERT_EQ(PrepareOutput(), true);
1114         ASSERT_EQ(PrepareVblank(), true);
1115
1116         ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
1117 }
1118
1119 TEST_P(TDMClient, ClientVblankWaitInterval)
1120 {
1121         bool done;
1122
1123         ASSERT_EQ(PrepareClient(), true);
1124         ASSERT_EQ(PrepareOutput(), true);
1125         ASSERT_EQ(PrepareVblank(), true);
1126
1127         /* start from 1 */
1128         for (int t = 1; t < 10; t++) {
1129                 done = false;
1130                 ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1131
1132                 start = tdm_helper_get_time();
1133                 while (!done)
1134                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1135                 end = tdm_helper_get_time();
1136
1137                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1138                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1139                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1140         }
1141 }
1142
1143 static void
1144 _tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
1145                                                   tdm_error error,
1146                                                   unsigned int sequence,
1147                                                   unsigned int tv_sec,
1148                                                   unsigned int tv_usec,
1149                                                   void *user_data)
1150 {
1151         unsigned int *cur_seq = (unsigned int *)user_data;
1152         if (cur_seq)
1153                 *cur_seq = sequence;
1154 }
1155
1156 TEST_P(TDMClient, ClientVblankWaitSeq)
1157 {
1158         ASSERT_EQ(PrepareClient(), true);
1159         ASSERT_EQ(PrepareOutput(), true);
1160         ASSERT_EQ(PrepareVblank(), true);
1161
1162         for (int t = 0; t < 10; t++) {
1163                 unsigned int cur_seq = 0, temp = 0;
1164
1165                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1166                 while (cur_seq == 0)
1167                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1168
1169                 start = tdm_helper_get_time();
1170                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1171                 while (temp == 0)
1172                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1173                 end = tdm_helper_get_time();
1174
1175                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1176                 ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1177         }
1178 }
1179
1180 TEST_P(TDMClient, ClientVblankWaitSeqInterval)
1181 {
1182         ASSERT_EQ(PrepareClient(), true);
1183         ASSERT_EQ(PrepareOutput(), true);
1184         ASSERT_EQ(PrepareVblank(), true);
1185
1186         /* start from 1 */
1187         for (int t = 1; t < 10; t++) {
1188                 unsigned int cur_seq = 0, temp = 0;
1189
1190                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1191                 while (cur_seq == 0)
1192                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1193
1194                 start = tdm_helper_get_time();
1195                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1196                 while (temp == 0)
1197                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1198                 end = tdm_helper_get_time();
1199
1200                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1201                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1202                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1203         }
1204 }
1205
1206 TEST_P(TDMClient, ClientVblankWaitSetOffset)
1207 {
1208         bool done;
1209
1210         ASSERT_EQ(PrepareClient(), true);
1211         ASSERT_EQ(PrepareOutput(), true);
1212         ASSERT_EQ(PrepareVblank(), true);
1213
1214         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
1215
1216         done = false;
1217         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1218
1219         start = tdm_helper_get_time();
1220         while (!done)
1221                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1222         end = tdm_helper_get_time();
1223
1224         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1225         ASSERT_GT((end - start), (0.1));
1226         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
1227 }
1228
1229 TEST_P(TDMClient, ClientVblankWaitSetFps)
1230 {
1231         bool done;
1232         double interval;
1233         unsigned int fps = 10;
1234
1235         ASSERT_EQ(PrepareClient(), true);
1236         ASSERT_EQ(PrepareOutput(), true);
1237         ASSERT_EQ(PrepareVblank(), true);
1238
1239         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
1240         interval = 1.0 / (double)fps;
1241
1242         done = false;
1243         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1244
1245         start = tdm_helper_get_time();
1246         while (!done)
1247                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1248         end = tdm_helper_get_time();
1249
1250         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1251         ASSERT_GT((end - start), (interval - vrefresh_interval));
1252         ASSERT_LT((end - start), (interval + vrefresh_interval));
1253 }
1254
1255 #if 0
1256
1257 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1258 {
1259         TDM_UT_SKIP_FLAG(has_outputs);
1260
1261         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1262         double vrefresh_interval;
1263         unsigned int cur_seq[3];
1264         unsigned int global_fps = 5;
1265         double start, end, interval;
1266
1267         ASSERT_EQ(TestPrepareOutput(), true);
1268         ASSERT_EQ(TestCreateVblanks3(), true);
1269         ASSERT_EQ(vblank_count, 3);
1270
1271         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1272         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1273         vrefresh_interval = 1.0 / (double)fps;
1274
1275         for (int v = 0; v < 3; v++)
1276                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
1277
1278         /* enable test */
1279         tdm_vblank_enable_global_fps(1, global_fps);
1280         interval = 1.0 / (double)global_fps;
1281
1282         for (int v = 0; v < 3; v++) {
1283                 cur_seq[v] = 0;
1284                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1285         }
1286
1287         start = tdm_helper_get_time();
1288         while (cur_seq[0] == 0)
1289                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1290         end = tdm_helper_get_time();
1291
1292         ASSERT_NE(cur_seq[1], 0);
1293         ASSERT_NE(cur_seq[2], 0);
1294
1295         /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
1296         ASSERT_GT((end - start), (interval - vrefresh_interval));
1297         ASSERT_LT((end - start), (interval + vrefresh_interval));
1298
1299         /* disable test */
1300         tdm_vblank_enable_global_fps(0, 0);
1301
1302         for (int v = 0; v < 3; v++) {
1303                 cur_seq[v] = 0;
1304                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1305         }
1306
1307         while (cur_seq[0] == 0)
1308                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1309         ASSERT_EQ(cur_seq[1], 0);
1310         ASSERT_EQ(cur_seq[2], 0);
1311
1312         while (cur_seq[1] == 0)
1313                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1314         ASSERT_EQ(cur_seq[2], 0);
1315 }
1316
1317 TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
1318 {
1319         TDM_UT_SKIP_FLAG(has_outputs);
1320
1321         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1322         unsigned int cur_seq[3];
1323         unsigned int global_fps = 5;
1324         double start, end, interval;
1325
1326         ASSERT_EQ(TestPrepareOutput(), true);
1327         ASSERT_EQ(TestCreateVblanks3(), true);
1328         ASSERT_EQ(vblank_count, 3);
1329
1330         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1331         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1332         interval = 1.0 / (double)fps;
1333
1334         /* 2nd vblank will ignore the global fps. */
1335         ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
1336
1337         tdm_vblank_enable_global_fps(1, global_fps);
1338
1339         for (int v = 0; v < 3; v++) {
1340                 cur_seq[v] = 0;
1341                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1342         }
1343
1344         start = tdm_helper_get_time();
1345         while (cur_seq[1] == 0)
1346                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1347         end = tdm_helper_get_time();
1348
1349         ASSERT_EQ(cur_seq[0], 0);
1350         ASSERT_EQ(cur_seq[2], 0);
1351
1352         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1353         ASSERT_LT((end - start), (interval + interval));
1354
1355         while (cur_seq[0] == 0)
1356                 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1357         ASSERT_NE(cur_seq[2], 0);
1358 }
1359
1360 #endif
1361
1362 TEST_P(TDMClient, ClientVblankWaitNullObject)
1363 {
1364         unsigned int cur_seq = 0;
1365
1366         ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1367 }
1368
1369 TEST_P(TDMClient, ClientVblankWaitNullOther)
1370 {
1371         ASSERT_EQ(PrepareClient(), true);
1372         ASSERT_EQ(PrepareOutput(), true);
1373         ASSERT_EQ(PrepareVblank(), true);
1374
1375         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1376 }
1377
1378 TEST_P(TDMClient, ClientVblankWaitDpmsOff)
1379 {
1380         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1381
1382         ASSERT_EQ(PrepareClient(), true);
1383         ASSERT_EQ(PrepareOutput(), true);
1384         ASSERT_EQ(PrepareVblank(), true);
1385
1386         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1387         while (dpms != TDM_OUTPUT_DPMS_OFF)
1388                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1389         ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
1390
1391         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
1392
1393         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1394         while (dpms != TDM_OUTPUT_DPMS_ON)
1395                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1396 }
1397
1398 TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
1399 {
1400         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1401         bool done;
1402
1403         ASSERT_EQ(PrepareClient(), true);
1404         ASSERT_EQ(PrepareOutput(), true);
1405         ASSERT_EQ(PrepareVblank(), true);
1406
1407         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1408         while (dpms != TDM_OUTPUT_DPMS_OFF)
1409                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1410
1411         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1412
1413         done = false;
1414         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1415
1416         while (!done)
1417                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1418
1419         ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1420         while (dpms != TDM_OUTPUT_DPMS_ON)
1421                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1422 }
1423
1424 /* tdm_client_vblank_wait */
1425 TEST_P(TDMClient, ClientVblankIsWaiting)
1426 {
1427         bool done;
1428         unsigned int waiting;
1429
1430         ASSERT_EQ(PrepareClient(), true);
1431         ASSERT_EQ(PrepareOutput(), true);
1432         ASSERT_EQ(PrepareVblank(), true);
1433
1434         done = false;
1435         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1436
1437         waiting = tdm_client_vblank_is_waiting(vblank);
1438         ASSERT_EQ(waiting, 1);
1439
1440         start = tdm_helper_get_time();
1441         while (!done)
1442                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1443         end = tdm_helper_get_time();
1444
1445         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1446         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1447
1448         waiting = tdm_client_vblank_is_waiting(vblank);
1449         ASSERT_EQ(waiting, 0);
1450 }
1451
1452 /* tdm_client_vblank_wait */
1453 TEST_P(TDMClient, ClientVblankIsWaitingNullObject)
1454 {
1455         unsigned int waiting = tdm_client_vblank_is_waiting(NULL);
1456         ASSERT_EQ(waiting, 0);
1457 }
1458
1459 TEST_P(TDMClient, ClientCreateVOutput)
1460 {
1461         tdm_error ret;
1462         const char name[TDM_NAME_LEN] = "Virtual Output";
1463
1464         ASSERT_EQ(PrepareClient(), true);
1465
1466         voutput = tdm_client_create_voutput(client, name, &ret);
1467         ASSERT_EQ(ret, TDM_ERROR_NONE);
1468         ASSERT_NE(voutput, NULL);
1469
1470         tdm_client_voutput_destroy(voutput);
1471 }
1472
1473 class TDMVirtualOutput : public ::testing::Test
1474 {
1475 public:
1476         TDMVirtualOutput() {};
1477         ~TDMVirtualOutput() {};
1478
1479         static void SetUpTestCase();
1480         static void TearDownTestCase();
1481         static bool PrepareVOutput(void);
1482
1483 protected:
1484         static tdm_client *client;
1485         static tdm_client_voutput *voutput;
1486         const int MODE_COUNT = 2;
1487
1488 private:
1489         static pid_t server_pid;
1490
1491         /* 0: read, 1: write */
1492         static int pipe_parent[2];
1493         static int pipe_child[2];
1494
1495         static void ServerFork(void);
1496         static void ServerKill(void);
1497 };
1498
1499 pid_t TDMVirtualOutput::server_pid = -1;
1500 int TDMVirtualOutput::pipe_parent[2] = {-1, -1};
1501 int TDMVirtualOutput::pipe_child[2] = {-1, -1};
1502 tdm_client* TDMVirtualOutput::client = nullptr;
1503 tdm_client_voutput* TDMVirtualOutput::voutput = nullptr;
1504
1505 void TDMVirtualOutput::ServerKill(void)
1506 {
1507         if (pipe_child[0] >= 0)
1508                 close(pipe_child[0]);
1509         if (pipe_child[1] >= 0) {
1510                 if (server_pid > 0) {
1511                         bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
1512                         if (ret) {
1513                                 if (waitpid(server_pid, NULL, 0) == server_pid)
1514                                         TDM_INFO("*** server terminated ***");
1515                                 else
1516                                         TDM_ERR("*** failed to terminate server ***");
1517                         } else {
1518                                 if (kill(server_pid, 9) < 0)
1519                                         TDM_ERR("*** failed to kill server ***");
1520                         }
1521                 }
1522                 close(pipe_child[1]);
1523         }
1524
1525         if (pipe_parent[0] >= 0)
1526                 close(pipe_parent[0]);
1527         if (pipe_parent[1] >= 0)
1528                 close(pipe_parent[1]);
1529
1530         server_pid = -1;
1531         pipe_parent[0] = pipe_parent[1] = -1;
1532         pipe_child[0] = pipe_child[1] = -1;
1533 }
1534
1535 void TDMVirtualOutput::ServerFork(void)
1536 {
1537         if (server_pid > 0)
1538                 return;
1539
1540         server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child);
1541         ASSERT_GT(server_pid, 0);
1542 }
1543
1544 void TDMVirtualOutput::SetUpTestCase(void)
1545 {
1546         setenv("XDG_RUNTIME_DIR", "/run", 1);
1547         setenv("TBM_DISPLAY_SERVER", "1", 1);
1548
1549         if (server_pid == -1)
1550                 ServerFork();
1551
1552         ASSERT_EQ(PrepareVOutput(), true);
1553 }
1554
1555 void TDMVirtualOutput::TearDownTestCase(void)
1556 {
1557 //      TDM_UT_WAIT("check & press");
1558
1559         if (voutput)
1560                 tdm_client_voutput_destroy(voutput);
1561
1562         if (client)
1563                 tdm_client_destroy(client);
1564
1565         ServerKill();
1566
1567         unsetenv("XDG_RUNTIME_DIR");
1568         unsetenv("TBM_DISPLAY_SERVER");
1569 }
1570
1571 bool TDMVirtualOutput::PrepareVOutput(void)
1572 {
1573         tdm_error ret;
1574         const char name[TDM_NAME_LEN] = "Virtual Output";
1575
1576         client = tdm_client_create(&ret);
1577         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
1578         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
1579
1580
1581         voutput = tdm_client_create_voutput(client, name, &ret);
1582         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
1583         TDM_UT_RETURN_FALSE_IF_FAIL(voutput != NULL);
1584
1585 //      TDM_UT_WAIT("check & press");
1586
1587         return true;
1588 }
1589
1590 static void
1591 _tc_tdm_client_virutual_make_available_mode(tdm_client_output_mode *modes, int count)
1592 {
1593         int i;
1594
1595         for (i = 0; i < count; i++) {
1596                 modes[i].clock = 25200;
1597                 modes[i].hdisplay = 640;
1598                 modes[i].hsync_start = 656;
1599                 modes[i].hsync_end = 752;
1600                 modes[i].htotal = 800;
1601                 modes[i].hskew = 0;
1602                 modes[i].vdisplay = 480;
1603                 modes[i].vsync_start = 490;
1604                 modes[i].vsync_end = 492;
1605                 modes[i].vtotal = 525;
1606                 modes[i].vscan = 0;
1607                 modes[i].vrefresh = 30;
1608                 modes[i].flags = 0;
1609                 modes[i].type = 0;
1610                 snprintf(modes[i].name, TDM_NAME_LEN, "%dx%d_%d", modes[i].hdisplay, modes[i].vdisplay, i);
1611         }
1612 }
1613
1614 TEST_F(TDMVirtualOutput, SetAvailableModes)
1615 {
1616         tdm_error ret;
1617         tdm_client_output_mode modes[this->MODE_COUNT];
1618         int count = this->MODE_COUNT;
1619
1620         _tc_tdm_client_virutual_make_available_mode(modes, count);
1621
1622         ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
1623         ASSERT_EQ(ret, TDM_ERROR_NONE);
1624 }
1625
1626 TEST_F(TDMVirtualOutput, FailTestSetAvailableModes)
1627 {
1628         tdm_error ret;
1629         tdm_client_output_mode modes[this->MODE_COUNT];
1630         int count = this->MODE_COUNT;
1631
1632         ret = tdm_client_voutput_set_available_modes(NULL, modes, count);
1633         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1634
1635         ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count);
1636         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1637 }
1638
1639 TEST_F(TDMVirtualOutput, SetPhysicalSize)
1640 {
1641         tdm_error ret;
1642         unsigned int mmWidth = 1234, mmHeight = 1234;
1643
1644         ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
1645         ASSERT_EQ(ret, TDM_ERROR_NONE);
1646 }
1647
1648 TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize)
1649 {
1650         tdm_error ret;
1651         unsigned int invalid_mmWidth = 0, invalid_mmHeight = 0;
1652
1653         ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight);
1654         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1655 }
1656
1657 static void
1658 _tc_tdm_client_voutput_commit_handler(tdm_client_voutput *voutput, tbm_surface_h buffer, void *user_data)
1659 {
1660         int *flag;
1661         flag = (int *)user_data;
1662         *flag = 1;
1663 }
1664
1665 TEST_F(TDMVirtualOutput, AddCommitHandler)
1666 {
1667         tdm_error ret;
1668         int flag_callback_called = 0;
1669
1670         ret = tdm_client_voutput_add_commit_handler(this->voutput,
1671                                                                                                 _tc_tdm_client_voutput_commit_handler,
1672                                                                                                 &flag_callback_called);
1673         ASSERT_EQ(ret, TDM_ERROR_NONE);
1674 //      ASSERT_EQ(flag_callback_called, 1);
1675
1676         tdm_client_voutput_remove_commit_handler(this->voutput,
1677                                                                                          _tc_tdm_client_voutput_commit_handler,
1678                                                                                          &flag_callback_called);
1679 }
1680
1681 TEST_F(TDMVirtualOutput, CommitDone)
1682 {
1683         tdm_error ret;
1684
1685         ret = tdm_client_voutput_commit_done(this->voutput);
1686         ASSERT_EQ(ret, TDM_ERROR_NONE);
1687 }
1688
1689 TEST_F(TDMVirtualOutput, GetClientOutput)
1690 {
1691         tdm_error ret;
1692         tdm_client_output *output;
1693
1694         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1695         ASSERT_EQ(ret, TDM_ERROR_NONE);
1696         ASSERT_NE(output, NULL);
1697 }
1698
1699 TEST_F(TDMVirtualOutput, Connect)
1700 {
1701         tdm_error ret;
1702         tdm_client_output *output;
1703         unsigned int mmWidth = 300, mmHeight = 150;
1704         tdm_client_output_mode modes[this->MODE_COUNT];
1705         int count = this->MODE_COUNT;
1706
1707         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1708         ASSERT_EQ(ret, TDM_ERROR_NONE);
1709         ASSERT_NE(output, NULL);
1710
1711         ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight);
1712         ASSERT_EQ(ret, TDM_ERROR_NONE);
1713
1714         _tc_tdm_client_virutual_make_available_mode(modes, count);
1715         ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count);
1716         ASSERT_EQ(ret, TDM_ERROR_NONE);
1717
1718         ret = tdm_client_output_connect(output);
1719         ASSERT_EQ(ret, TDM_ERROR_NONE);
1720
1721         tdm_client_handle_events_timeout(this->client, 0);
1722 }
1723
1724 TEST_F(TDMVirtualOutput, Disconnect)
1725 {
1726         tdm_error ret;
1727         tdm_client_output *output;
1728
1729 //      TDM_UT_WAIT("check & press");
1730
1731         output = tdm_client_voutput_get_client_output(this->voutput, &ret);
1732         ASSERT_EQ(ret, TDM_ERROR_NONE);
1733         ASSERT_NE(output, NULL);
1734
1735         ret = tdm_client_output_disconnect(output);
1736         ASSERT_EQ(ret, TDM_ERROR_NONE);
1737
1738         tdm_client_handle_events_timeout(this->client, 0);
1739 }
1740
1741 #if 0
1742 TEST_F(TDMVirtualOutput, FailTestGetClientOutput)
1743 {
1744         tdm_error ret;
1745 }
1746
1747 TEST_F(TDMVirtualOutput, SetBufferQueue)
1748 {
1749         tdm_error ret;
1750 }
1751
1752 TEST_F(TDMVirtualOutput, FailTestSetBufferQueue)
1753 {
1754         tdm_error ret;
1755 }
1756
1757 #endif
1758
1759 #ifdef TDM_UT_TEST_WITH_PARAMS
1760 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1761                                                 TDMClient,
1762                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1763 #else
1764 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1765                                                 TDMClient,
1766                                                 Values(TDM_DEFAULT_MODULE));
1767 #endif
1768
1769 /* LCOV_EXCL_END */