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