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