utests/src/ut_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 "ut_tdm.h"
  39 #include "tdm_client.h"
  40
  41 enum {
  42         TDM_UT_PIPE_MSG_NONE,
  43         TDM_UT_PIPE_MSG_REPLY,
  44         TDM_UT_PIPE_MSG_SERVER_READY,
  45         TDM_UT_PIPE_MSG_SERVER_FAILED,
  46         TDM_UT_PIPE_MSG_DPMS_ON,
  47         TDM_UT_PIPE_MSG_DPMS_OFF,
  48         TDM_UT_PIPE_MSG_TERMINATE_SERVER,
  49 };
  50
  51 static int _ut_tdm_pipe_read_msg(int fd);
  52 static bool _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg);
  53 static pid_t _ut_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child);
  54
  55 class TDMClient : public TDMEnv
  56 {
  57 public:
  58         static pid_t server_pid;
  59
  60         /* 0: read, 1: write */
  61         static int pipe_parent[2];
  62         static int pipe_child[2];
  63
  64         tdm_client *client;
  65         tdm_client_output *output;
  66         tdm_client_vblank *vblank;
  67
  68         double vrefresh_interval, start, end;
  69
  70         TDMClient();
  71
  72         void SetUp(void);
  73         void TearDown(void);
  74         bool PrepareClient(void);
  75         bool PrepareOutput(void);
  76         bool PrepareVblank(void);
  77
  78         static void TearDownTestCase(void);
  79         static void ServerFork(void);
  80         static void ServerKill(void);
  81 };
  82
  83 pid_t TDMClient::server_pid = -1;
  84 int TDMClient::pipe_parent[2] = {-1, -1};
  85 int TDMClient::pipe_child[2] = {-1, -1};
  86
  87 void TDMClient::TearDownTestCase(void)
  88 {
  89         ServerKill();
  90 }
  91
  92 void TDMClient::ServerFork(void)
  93 {
  94         if (server_pid > 0)
  95                 return;
  96
  97         server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child);
  98         ASSERT_GT(server_pid, 0);
  99 }
 100
 101 void TDMClient::ServerKill(void)
 102 {
 103         if (pipe_child[0] >= 0)
 104                 close(pipe_child[0]);
 105         if (pipe_child[1] >= 0) {
 106                 if (server_pid > 0) {
 107                         _ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER);
 108                         waitpid(server_pid, NULL, 0);
 109                         TDM_INFO("*** server terminated ***");
 110                 }
 111                 close(pipe_child[1]);
 112         }
 113
 114         if (pipe_parent[0] >= 0)
 115                 close(pipe_parent[0]);
 116         if (pipe_parent[1] >= 0)
 117                 close(pipe_parent[1]);
 118
 119         server_pid = -1;
 120         pipe_parent[0] = pipe_parent[1] = -1;
 121         pipe_child[0] = pipe_child[1] = -1;
 122 }
 123
 124 TDMClient::TDMClient()
 125 {
 126         client = NULL;
 127         output = NULL;
 128         vblank = NULL;
 129         vrefresh_interval = start = end = 0.0;
 130 }
 131
 132 void TDMClient::SetUp(void)
 133 {
 134         TDMEnv::SetUp();
 135
 136         if (server_pid == -1)
 137                 ServerFork();
 138 }
 139
 140 void TDMClient::TearDown(void)
 141 {
 142         if (vblank)
 143                 tdm_client_vblank_destroy(vblank);
 144         if (client)
 145                 tdm_client_destroy(client);
 146
 147         TDMEnv::TearDown();
 148 }
 149
 150 bool TDMClient::PrepareClient(void)
 151 {
 152         tdm_error ret;
 153         client = tdm_client_create(&ret);
 154         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 155         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
 156
 157         return true;
 158 }
 159
 160 bool TDMClient::PrepareOutput(void)
 161 {
 162         tdm_error ret;
 163
 164         TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL);
 165
 166         output = tdm_client_get_output(client, NULL, &ret);
 167         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 168         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 169
 170         return true;
 171 }
 172
 173 bool TDMClient::PrepareVblank(void)
 174 {
 175         tdm_error ret;
 176         unsigned int refresh;
 177
 178         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 179
 180         vblank = tdm_client_output_create_vblank(output, &ret);
 181         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 182         TDM_UT_RETURN_FALSE_IF_FAIL(vblank != NULL);
 183
 184         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_client_output_get_refresh_rate(output, &refresh) == TDM_ERROR_NONE);
 185         TDM_UT_RETURN_FALSE_IF_FAIL(refresh > 0);
 186
 187         vrefresh_interval = 1.0 / (double)refresh;
 188         TDM_UT_RETURN_FALSE_IF_FAIL(vrefresh_interval > 0);
 189
 190         return true;
 191 }
 192
 193 static int
 194 _ut_tdm_pipe_read_msg(int fd)
 195 {
 196         ssize_t len;
 197         int msg;
 198
 199         do {
 200                 len = read(fd, &msg, sizeof msg);
 201         } while (len < 0 && errno == EINTR);
 202
 203         if (len <= 0)
 204                 msg = TDM_UT_PIPE_MSG_NONE;
 205
 206         return msg;
 207 }
 208
 209 static bool
 210 _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg)
 211 {
 212         ssize_t len = write(fd, &msg, sizeof msg);
 213         TDM_UT_RETURN_FALSE_IF_FAIL(len == sizeof msg);
 214
 215         if (reply_fd >= 0) {
 216                 int reply = _ut_tdm_pipe_read_msg(reply_fd);
 217                 TDM_UT_RETURN_FALSE_IF_FAIL(reply == TDM_UT_PIPE_MSG_REPLY);
 218         }
 219
 220         return true;
 221 }
 222
 223 static bool
 224 _ut_tdm_server_set_output_dpms(tdm_display *dpy, int msg)
 225 {
 226         tdm_error ret;
 227         tdm_output *output;
 228         tdm_output_dpms dpms;
 229
 230         output = tdm_display_find_output(dpy, "primary", &ret);
 231         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 232         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 233
 234         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_dpms(output, &dpms) == TDM_ERROR_NONE);
 235
 236         switch (msg) {
 237         case TDM_UT_PIPE_MSG_DPMS_ON:
 238                 if (dpms != TDM_OUTPUT_DPMS_ON)
 239                         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
 240                 break;
 241         case TDM_UT_PIPE_MSG_DPMS_OFF:
 242                 if (dpms != TDM_OUTPUT_DPMS_OFF)
 243                         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
 244                 break;
 245         default:
 246                 break;
 247         }
 248
 249         return true;
 250 }
 251
 252 static void
 253 _ut_tdm_server_run(int *pipe_parent, int *pipe_child)
 254 {
 255         tdm_display *dpy = NULL;
 256         tdm_error ret;
 257         struct pollfd fds[2];
 258         int tdm_fd, err;
 259         int output_count = 0;
 260
 261         dpy = tdm_display_init(&ret);
 262         TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
 263         TDM_UT_GOTO_IF_FAIL(dpy != NULL, failed);
 264
 265         TDM_UT_GOTO_IF_FAIL(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE, failed);
 266
 267         for (int o = 0; o < output_count; o++) {
 268                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 269                 TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed);
 270                 TDM_UT_GOTO_IF_FAIL(output != NULL, failed);
 271
 272                 if (!ut_tdm_output_is_connected(output))
 273                         continue;
 274
 275                 TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, failed);
 276         }
 277
 278         TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done);
 279
 280         TDM_INFO("*** server ready ***");
 281
 282         ret = tdm_display_get_fd(dpy, &tdm_fd);
 283         TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done);
 284
 285         fds[0].events = POLLIN;
 286         fds[0].fd = tdm_fd;
 287         fds[0].revents = 0;
 288
 289         fds[1].events = POLLIN;
 290         fds[1].fd = pipe_child[0];
 291         fds[1].revents = 0;
 292
 293         while (1) {
 294                 /* make sure all events are flushed to clients before falling in sleep */
 295                 tdm_display_flush(dpy);
 296
 297                 err = poll(fds, 2, -1);
 298                 if (err < 0) {
 299                         if (errno == EINTR || errno == EAGAIN) {
 300                                 continue;
 301                         } else {
 302                                 TDM_ERR("server-process: poll failed: %m\n");
 303                                 goto done;
 304                         }
 305                 }
 306
 307                 if (fds[0].revents & POLLIN)
 308                         ret = ut_tdm_display_handle_events(dpy);
 309
 310                 if (fds[1].revents & POLLIN) {
 311                         int msg = _ut_tdm_pipe_read_msg(pipe_child[0]);
 312                         _ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY);
 313
 314                         switch (msg) {
 315                         case TDM_UT_PIPE_MSG_DPMS_ON:
 316                         case TDM_UT_PIPE_MSG_DPMS_OFF:
 317                                 _ut_tdm_server_set_output_dpms(dpy, msg);
 318                                 break;
 319                         case TDM_UT_PIPE_MSG_TERMINATE_SERVER:
 320                                 goto done;
 321                         default:
 322                                 break;
 323                         }
 324                 }
 325         }
 326
 327 done:
 328         if (dpy)
 329                 tdm_display_deinit(dpy);
 330         return;
 331
 332 failed:
 333         TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done);
 334         TDM_INFO("*** server failed ***");
 335
 336         if (dpy)
 337                 tdm_display_deinit(dpy);
 338         return;
 339
 340 }
 341
 342 static void _ut_tdm_client_sig_handler(int sig)
 343 {
 344         TDM_UT_ERR("got signal: %d", sig);
 345         kill(TDMClient::server_pid, 9);
 346         abort();
 347 }
 348
 349 static pid_t
 350 _ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child)
 351 {
 352         pid_t pid;
 353         int msg;
 354
 355         TDM_UT_GOTO_IF_FAIL(pipe(pipe_parent) == 0, failed);
 356         TDM_UT_GOTO_IF_FAIL(pipe(pipe_child) == 0, failed);
 357
 358         signal(SIGCHLD, SIG_IGN);
 359         signal(SIGSEGV, _ut_tdm_client_sig_handler);
 360
 361         prctl(PR_SET_PDEATHSIG, SIGHUP);
 362
 363         pid = fork();
 364         TDM_UT_GOTO_IF_FAIL(pid >= 0, failed);
 365
 366         if (pid == 0) {
 367                 _ut_tdm_server_run(pipe_parent, pipe_child);
 368                 close(pipe_child[0]);
 369                 close(pipe_child[1]);
 370                 close(pipe_parent[0]);
 371                 close(pipe_parent[1]);
 372
 373 #ifdef TIZEN_TEST_GCOV
 374                 __gcov_flush();
 375 #endif
 376
 377                 exit(0);
 378         }
 379
 380         msg = _ut_tdm_pipe_read_msg(pipe_parent[0]);
 381         TDM_UT_GOTO_IF_FAIL(msg == TDM_UT_PIPE_MSG_SERVER_READY, failed);
 382
 383         TDM_INFO("*** server fork done ***");
 384
 385         return pid;
 386
 387 failed:
 388         return -1;
 389 }
 390
 391 TEST_P(TDMClient, ClientCreate)
 392 {
 393         tdm_error ret;
 394
 395         client = tdm_client_create(&ret);
 396         ASSERT_EQ(ret, TDM_ERROR_NONE);
 397         ASSERT_NE(client, NULL);
 398 }
 399
 400 TEST_P(TDMClient, ClientCreateNullOther)
 401 {
 402         client = tdm_client_create(NULL);
 403         ASSERT_NE(client, NULL);
 404 }
 405
 406 TEST_P(TDMClient, ClientDestroy)
 407 {
 408         tdm_error ret;
 409
 410         client = tdm_client_create(&ret);
 411         ASSERT_EQ(ret, TDM_ERROR_NONE);
 412         ASSERT_NE(client, NULL);
 413
 414         tdm_client_destroy(client);
 415         client = NULL;
 416 }
 417
 418 TEST_P(TDMClient, ClientNullObject)
 419 {
 420         tdm_client_destroy(NULL);
 421 }
 422
 423 /* tdm_client_get_fd */
 424 TEST_P(TDMClient, ClientGetFd)
 425 {
 426         int fd = TDM_UT_INVALID_VALUE;
 427
 428         ASSERT_EQ(PrepareClient(), true);
 429
 430         ASSERT_EQ(tdm_client_get_fd(client, &fd), TDM_ERROR_NONE);
 431         ASSERT_GE(fd, 0);
 432 }
 433
 434 TEST_P(TDMClient, ClientGetFdNullObject)
 435 {
 436         int fd = TDM_UT_INVALID_VALUE;
 437         ASSERT_EQ(tdm_client_get_fd(NULL, &fd), TDM_ERROR_INVALID_PARAMETER);
 438         ASSERT_EQ(fd, TDM_UT_INVALID_VALUE);
 439 }
 440
 441 TEST_P(TDMClient, ClientGetFdNullOther)
 442 {
 443         ASSERT_EQ(PrepareClient(), true);
 444
 445         ASSERT_EQ(tdm_client_get_fd(client, NULL), TDM_ERROR_INVALID_PARAMETER);
 446 }
 447
 448 /* tdm_client_handle_events_timeout */
 449 TEST_P(TDMClient, DISABLED_ClientHandleEvent)
 450 {
 451         ASSERT_EQ(PrepareClient(), true);
 452
 453 //      ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 454 }
 455
 456 TEST_P(TDMClient, ClientHandleEventNullObject)
 457 {
 458         ASSERT_EQ(tdm_client_handle_events_timeout(NULL, 3000), TDM_ERROR_INVALID_PARAMETER);
 459 }
 460
 461 static void
 462 _ut_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 463 {
 464         bool *done = (bool *)user_data;
 465         if (done)
 466                 *done = true;
 467 }
 468
 469 /* tdm_client_wait_vblank, deprecated */
 470 TEST_P(TDMClient, ClientWaitVblank)
 471 {
 472         bool done = false;
 473
 474         ASSERT_EQ(PrepareClient(), true);
 475
 476         ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE);
 477         ASSERT_EQ(done, false);
 478
 479         while (!done)
 480                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 481 }
 482
 483 /* tdm_client_get_output */
 484 TEST_P(TDMClient, ClientGetOutput)
 485 {
 486         tdm_error ret;
 487
 488         ASSERT_EQ(PrepareClient(), true);
 489
 490         output = tdm_client_get_output(client, NULL, &ret);
 491         ASSERT_EQ(ret, TDM_ERROR_NONE);
 492         ASSERT_NE(output, NULL);
 493 }
 494
 495 TEST_P(TDMClient, ClientGetOutputPrimary)
 496 {
 497         tdm_error ret;
 498
 499         ASSERT_EQ(PrepareClient(), true);
 500
 501         output = tdm_client_get_output(client, (char*)"primary", &ret);
 502         ASSERT_EQ(ret, TDM_ERROR_NONE);
 503         ASSERT_NE(output, NULL);
 504 }
 505
 506 TEST_P(TDMClient, ClientGetOutputDefault)
 507 {
 508         tdm_error ret;
 509
 510         ASSERT_EQ(PrepareClient(), true);
 511
 512         output = tdm_client_get_output(client, (char*)"default", &ret);
 513         ASSERT_EQ(ret, TDM_ERROR_NONE);
 514         ASSERT_NE(output, NULL);
 515 }
 516
 517 TEST_P(TDMClient, ClientGetOutputInvalidName)
 518 {
 519         tdm_error ret;
 520
 521         ASSERT_EQ(PrepareClient(), true);
 522
 523         output = tdm_client_get_output(client, (char*)"invalid", &ret);
 524         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 525         ASSERT_EQ(output, NULL);
 526 }
 527
 528 TEST_P(TDMClient, ClientGetOutputNullObject)
 529 {
 530         tdm_error ret;
 531
 532         output = tdm_client_get_output(NULL, NULL, &ret);
 533         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 534         ASSERT_EQ(output, NULL);
 535 }
 536
 537 TEST_P(TDMClient, ClientGetOutputNullOther)
 538 {
 539         ASSERT_EQ(PrepareClient(), true);
 540
 541         output = tdm_client_get_output(client, NULL, NULL);
 542         ASSERT_NE(output, NULL);
 543 }
 544
 545 static void
 546 _ut_tdm_client_output_change_dpms_cb(tdm_client_output *output,
 547                                                                          tdm_output_change_type type,
 548                                                                          tdm_value value,
 549                                                                          void *user_data)
 550 {
 551         bool *done = (bool *)user_data;
 552
 553         switch (type) {
 554         case TDM_OUTPUT_CHANGE_DPMS:
 555                 if (done)
 556                         *done = true;
 557                 break;
 558         default:
 559                 break;
 560         }
 561 }
 562
 563 /* tdm_client_output_add_change_handler */
 564 TEST_P(TDMClient, ClientOutputAddChangeHandler)
 565 {
 566         bool done = false;
 567         tdm_output_dpms dpms;
 568
 569         ASSERT_EQ(PrepareClient(), true);
 570         ASSERT_EQ(PrepareOutput(), true);
 571
 572         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
 573         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
 574
 575         while (!done)
 576                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 577
 578         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 579         ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
 580
 581         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
 582         while (dpms != TDM_OUTPUT_DPMS_ON)
 583                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 584 }
 585
 586 TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice)
 587 {
 588         ASSERT_EQ(PrepareClient(), true);
 589         ASSERT_EQ(PrepareOutput(), true);
 590
 591         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
 592         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST);
 593 }
 594
 595 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject)
 596 {
 597         ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 598 }
 599
 600 TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther)
 601 {
 602         ASSERT_EQ(PrepareClient(), true);
 603         ASSERT_EQ(PrepareOutput(), true);
 604
 605         ASSERT_EQ(tdm_client_output_add_change_handler(output, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 606 }
 607
 608 /* tdm_client_output_remove_change_handler */
 609 TEST_P(TDMClient, ClientOutputRemoveChangeHandler)
 610 {
 611         ASSERT_EQ(PrepareClient(), true);
 612         ASSERT_EQ(PrepareOutput(), true);
 613
 614         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE);
 615         tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL);
 616 }
 617
 618 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData)
 619 {
 620         bool done = (bool)TDM_UT_INVALID_VALUE;
 621
 622         ASSERT_EQ(PrepareClient(), true);
 623         ASSERT_EQ(PrepareOutput(), true);
 624
 625         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE);
 626         tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL);
 627 }
 628
 629 static void
 630 _ut_tdm_client_output_change_dpms_cb2(tdm_client_output *output,
 631                                                                           tdm_output_change_type type,
 632                                                                           tdm_value value,
 633                                                                           void *user_data)
 634 {
 635         switch (type) {
 636         case TDM_OUTPUT_CHANGE_DPMS:
 637                 tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, user_data);
 638                 break;
 639         default:
 640                 break;
 641         }
 642 }
 643
 644 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler)
 645 {
 646         tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
 647
 648         ASSERT_EQ(PrepareClient(), true);
 649         ASSERT_EQ(PrepareOutput(), true);
 650
 651         ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE);
 652         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
 653         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 654         while (dpms != TDM_OUTPUT_DPMS_OFF) {
 655                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 656                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 657         }
 658
 659         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
 660         while (dpms != TDM_OUTPUT_DPMS_ON)
 661                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 662 }
 663
 664 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject)
 665 {
 666         tdm_client_output_remove_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL);
 667 }
 668
 669 TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther)
 670 {
 671         ASSERT_EQ(PrepareClient(), true);
 672         ASSERT_EQ(PrepareOutput(), true);
 673
 674         tdm_client_output_remove_change_handler(output, NULL, NULL);
 675 }
 676
 677 /* tdm_client_output_get_refresh_rate */
 678 TEST_P(TDMClient, ClientOutputGetRefreshRate)
 679 {
 680         unsigned int refresh = 0;
 681
 682         ASSERT_EQ(PrepareClient(), true);
 683         ASSERT_EQ(PrepareOutput(), true);
 684
 685         ASSERT_EQ(tdm_client_output_get_refresh_rate(output, &refresh), TDM_ERROR_NONE);
 686         ASSERT_GT(refresh, 0);
 687 }
 688
 689 TEST_P(TDMClient, ClientOutputGetRefreshRateNullObject)
 690 {
 691         unsigned int refresh = (unsigned int)TDM_UT_INVALID_VALUE;
 692
 693         ASSERT_EQ(tdm_client_output_get_refresh_rate(NULL, &refresh), TDM_ERROR_INVALID_PARAMETER);
 694         ASSERT_EQ(refresh, (unsigned int)TDM_UT_INVALID_VALUE);
 695 }
 696
 697 TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther)
 698 {
 699         ASSERT_EQ(PrepareClient(), true);
 700         ASSERT_EQ(PrepareOutput(), true);
 701
 702         ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 703 }
 704
 705 /* tdm_client_output_get_refresh_rate */
 706 TEST_P(TDMClient, ClientOutputGetConnStatus)
 707 {
 708         tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 709
 710         ASSERT_EQ(PrepareClient(), true);
 711         ASSERT_EQ(PrepareOutput(), true);
 712
 713         ASSERT_EQ(tdm_client_output_get_conn_status(output, &status), TDM_ERROR_NONE);
 714         ASSERT_NE(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 715 }
 716
 717 TEST_P(TDMClient, ClientOutputGetConnStatusNullObject)
 718 {
 719         tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
 720
 721         ASSERT_EQ(tdm_client_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
 722         ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
 723 }
 724
 725 TEST_P(TDMClient, ClientOutputGetConnStatusNullOther)
 726 {
 727         ASSERT_EQ(PrepareClient(), true);
 728         ASSERT_EQ(PrepareOutput(), true);
 729
 730         ASSERT_EQ(tdm_client_output_get_conn_status(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 731 }
 732
 733 /* tdm_client_output_get_dpms */
 734 TEST_P(TDMClient, ClientOutputGetDpms)
 735 {
 736         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 737
 738         ASSERT_EQ(PrepareClient(), true);
 739         ASSERT_EQ(PrepareOutput(), true);
 740
 741         ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
 742         ASSERT_NE(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 743 }
 744
 745 TEST_P(TDMClient, ClientOutputGetDpmsNullObject)
 746 {
 747         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
 748
 749         ASSERT_EQ(tdm_client_output_get_dpms(NULL, &dpms), TDM_ERROR_INVALID_PARAMETER);
 750         ASSERT_EQ(dpms, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
 751 }
 752
 753 TEST_P(TDMClient, ClientOutputGetDpmsNullOther)
 754 {
 755         ASSERT_EQ(PrepareClient(), true);
 756         ASSERT_EQ(PrepareOutput(), true);
 757
 758         ASSERT_EQ(tdm_client_output_get_dpms(output, NULL), TDM_ERROR_INVALID_PARAMETER);
 759 }
 760
 761 /* tdm_client_output_create_vblank */
 762 TEST_P(TDMClient, ClientOutputCreateVblank)
 763 {
 764         tdm_error ret;
 765
 766         ASSERT_EQ(PrepareClient(), true);
 767         ASSERT_EQ(PrepareOutput(), true);
 768
 769         vblank = tdm_client_output_create_vblank(output, &ret);
 770         ASSERT_EQ(ret, TDM_ERROR_NONE);
 771         ASSERT_NE(vblank, NULL);
 772 }
 773
 774 TEST_P(TDMClient, ClientOutputCreateVblankNullObject)
 775 {
 776         tdm_error ret;
 777
 778         vblank = tdm_client_output_create_vblank(NULL, &ret);
 779         ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 780         ASSERT_EQ(vblank, NULL);
 781 }
 782
 783 TEST_P(TDMClient, ClientOutputCreateVblankNullOther)
 784 {
 785         ASSERT_EQ(PrepareClient(), true);
 786         ASSERT_EQ(PrepareOutput(), true);
 787
 788         vblank = tdm_client_output_create_vblank(output, NULL);
 789         ASSERT_NE(vblank, NULL);
 790 }
 791
 792 /* tdm_client_vblank_destroy */
 793 TEST_P(TDMClient, ClientVblankDestroy)
 794 {
 795         tdm_error ret;
 796
 797         ASSERT_EQ(PrepareClient(), true);
 798         ASSERT_EQ(PrepareOutput(), true);
 799
 800         vblank = tdm_client_output_create_vblank(output, &ret);
 801         ASSERT_EQ(ret, TDM_ERROR_NONE);
 802         ASSERT_NE(vblank, NULL);
 803
 804         tdm_client_vblank_destroy(vblank);
 805         vblank = NULL;
 806 }
 807
 808 TEST_P(TDMClient, ClientVblankDestroyNullObject)
 809 {
 810         tdm_client_vblank_destroy(NULL);
 811 }
 812
 813 /* tdm_client_vblank_set_name */
 814 TEST_P(TDMClient, ClientVblankSetName)
 815 {
 816         ASSERT_EQ(PrepareClient(), true);
 817         ASSERT_EQ(PrepareOutput(), true);
 818         ASSERT_EQ(PrepareVblank(), true);
 819
 820         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 821 }
 822
 823 TEST_P(TDMClient, ClientVblankSetNameTwice)
 824 {
 825         ASSERT_EQ(PrepareClient(), true);
 826         ASSERT_EQ(PrepareOutput(), true);
 827         ASSERT_EQ(PrepareVblank(), true);
 828
 829         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 830         ASSERT_EQ(tdm_client_vblank_set_name(vblank, TDM_UT_VBLANK_NAME), TDM_ERROR_NONE);
 831 }
 832
 833 TEST_P(TDMClient, ClientVblankSetNameNullObject)
 834 {
 835         ASSERT_EQ(tdm_client_vblank_set_name(NULL, TDM_UT_VBLANK_NAME), TDM_ERROR_INVALID_PARAMETER);
 836 }
 837
 838 /* tdm_client_vblank_set_sync */
 839 TEST_P(TDMClient, ClientVblankSetSync)
 840 {
 841         ASSERT_EQ(PrepareClient(), true);
 842         ASSERT_EQ(PrepareOutput(), true);
 843         ASSERT_EQ(PrepareVblank(), true);
 844
 845         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 846 }
 847
 848 TEST_P(TDMClient, ClientVblankSetSyncTwice)
 849 {
 850         ASSERT_EQ(PrepareClient(), true);
 851         ASSERT_EQ(PrepareOutput(), true);
 852         ASSERT_EQ(PrepareVblank(), true);
 853
 854         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 855         ASSERT_EQ(tdm_client_vblank_set_sync(vblank, 1), TDM_ERROR_NONE);
 856 }
 857
 858 TEST_P(TDMClient, ClientVblankSetSyncNullObject)
 859 {
 860         ASSERT_EQ(tdm_client_vblank_set_sync(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 861 }
 862
 863 /* tdm_client_vblank_set_fps */
 864 TEST_P(TDMClient, ClientVblankSetFps)
 865 {
 866         ASSERT_EQ(PrepareClient(), true);
 867         ASSERT_EQ(PrepareOutput(), true);
 868         ASSERT_EQ(PrepareVblank(), true);
 869
 870         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 871 }
 872
 873 TEST_P(TDMClient, ClientVblankSetFpsTwice)
 874 {
 875         ASSERT_EQ(PrepareClient(), true);
 876         ASSERT_EQ(PrepareOutput(), true);
 877         ASSERT_EQ(PrepareVblank(), true);
 878
 879         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 880         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, 30), TDM_ERROR_NONE);
 881 }
 882
 883 TEST_P(TDMClient, ClientVblankSetFpsNullObject)
 884 {
 885         ASSERT_EQ(tdm_client_vblank_set_fps(NULL, 30), TDM_ERROR_INVALID_PARAMETER);
 886 }
 887
 888 /* tdm_client_vblank_set_offset */
 889 TEST_P(TDMClient, ClientVblankSetOffset)
 890 {
 891         ASSERT_EQ(PrepareClient(), true);
 892         ASSERT_EQ(PrepareOutput(), true);
 893         ASSERT_EQ(PrepareVblank(), true);
 894
 895         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 896 }
 897
 898 TEST_P(TDMClient, ClientVblankSetOffsetTwice)
 899 {
 900         ASSERT_EQ(PrepareClient(), true);
 901         ASSERT_EQ(PrepareOutput(), true);
 902         ASSERT_EQ(PrepareVblank(), true);
 903
 904         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 905         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 10), TDM_ERROR_NONE);
 906 }
 907
 908 TEST_P(TDMClient, ClientVblankSetOffsetNullObject)
 909 {
 910         ASSERT_EQ(tdm_client_vblank_set_offset(NULL, 10), TDM_ERROR_INVALID_PARAMETER);
 911 }
 912
 913 /* tdm_client_vblank_set_enable_fake */
 914 TEST_P(TDMClient, ClientVblankSetEnableFake)
 915 {
 916         ASSERT_EQ(PrepareClient(), true);
 917         ASSERT_EQ(PrepareOutput(), true);
 918         ASSERT_EQ(PrepareVblank(), true);
 919
 920         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 921 }
 922
 923 TEST_P(TDMClient, ClientVblankSetEnableFakeTwice)
 924 {
 925         ASSERT_EQ(PrepareClient(), true);
 926         ASSERT_EQ(PrepareOutput(), true);
 927         ASSERT_EQ(PrepareVblank(), true);
 928
 929         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 930         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
 931 }
 932
 933 TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject)
 934 {
 935         ASSERT_EQ(tdm_client_vblank_set_enable_fake(NULL, 1), TDM_ERROR_INVALID_PARAMETER);
 936 }
 937
 938 static void
 939 _ut_tdm_client_vblank_cb2(tdm_client_vblank *vblank,
 940                                                   tdm_error error,
 941                                                   unsigned int sequence,
 942                                                   unsigned int tv_sec,
 943                                                   unsigned int tv_usec,
 944                                                   void *user_data)
 945 {
 946         bool *done = (bool *)user_data;
 947         if (done)
 948                 *done = true;
 949 }
 950
 951 /* tdm_client_vblank_wait */
 952 TEST_P(TDMClient, ClientVblankWait)
 953 {
 954         bool done;
 955
 956         ASSERT_EQ(PrepareClient(), true);
 957         ASSERT_EQ(PrepareOutput(), true);
 958         ASSERT_EQ(PrepareVblank(), true);
 959
 960         done = false;
 961         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
 962
 963         start = tdm_helper_get_time();
 964         while (!done)
 965                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 966         end = tdm_helper_get_time();
 967
 968         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
 969         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
 970 }
 971
 972 TEST_P(TDMClient, ClientVblankWaitFewTime)
 973 {
 974         bool done1, done2, done3;
 975
 976         ASSERT_EQ(PrepareClient(), true);
 977         ASSERT_EQ(PrepareOutput(), true);
 978         ASSERT_EQ(PrepareVblank(), true);
 979
 980         done1 = done2 = done3 = false;
 981         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE);
 982         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE);
 983         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE);
 984
 985         start = tdm_helper_get_time();
 986         while (!done1 || !done2 || !done3)
 987                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
 988         end = tdm_helper_get_time();
 989
 990         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
 991         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
 992
 993 }
 994
 995 TEST_P(TDMClient, ClientVblankWaitInterval0)
 996 {
 997         ASSERT_EQ(PrepareClient(), true);
 998         ASSERT_EQ(PrepareOutput(), true);
 999         ASSERT_EQ(PrepareVblank(), true);
1000
1001         ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER);
1002 }
1003
1004 TEST_P(TDMClient, ClientVblankWaitInterval)
1005 {
1006         bool done;
1007
1008         ASSERT_EQ(PrepareClient(), true);
1009         ASSERT_EQ(PrepareOutput(), true);
1010         ASSERT_EQ(PrepareVblank(), true);
1011
1012         /* start from 1 */
1013         for (int t = 1; t < 10; t++) {
1014                 done = false;
1015                 ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1016
1017                 start = tdm_helper_get_time();
1018                 while (!done)
1019                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1020                 end = tdm_helper_get_time();
1021
1022                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1023                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1024                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1025         }
1026 }
1027
1028 static void
1029 _ut_tdm_client_vblank_cb3(tdm_client_vblank *vblank,
1030                                                   tdm_error error,
1031                                                   unsigned int sequence,
1032                                                   unsigned int tv_sec,
1033                                                   unsigned int tv_usec,
1034                                                   void *user_data)
1035 {
1036         unsigned int *cur_seq = (unsigned int *)user_data;
1037         if (cur_seq)
1038                 *cur_seq = sequence;
1039 }
1040
1041 TEST_P(TDMClient, ClientVblankWaitSeq)
1042 {
1043         ASSERT_EQ(PrepareClient(), true);
1044         ASSERT_EQ(PrepareOutput(), true);
1045         ASSERT_EQ(PrepareVblank(), true);
1046
1047         for (int t = 0; t < 10; t++) {
1048                 unsigned int cur_seq = 0, temp = 0;
1049
1050                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1051                 while (cur_seq == 0)
1052                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1053
1054                 start = tdm_helper_get_time();
1055                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1056                 while (temp == 0)
1057                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1058                 end = tdm_helper_get_time();
1059
1060                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1061                 ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval));
1062         }
1063 }
1064
1065 TEST_P(TDMClient, ClientVblankWaitSeqInterval)
1066 {
1067         ASSERT_EQ(PrepareClient(), true);
1068         ASSERT_EQ(PrepareOutput(), true);
1069         ASSERT_EQ(PrepareVblank(), true);
1070
1071         /* start from 1 */
1072         for (int t = 1; t < 10; t++) {
1073                 unsigned int cur_seq = 0, temp = 0;
1074
1075                 ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE);
1076                 while (cur_seq == 0)
1077                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1078
1079                 start = tdm_helper_get_time();
1080                 ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE);
1081                 while (temp == 0)
1082                         ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1083                 end = tdm_helper_get_time();
1084
1085                 /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1086                 ASSERT_GT((end - start), (vrefresh_interval * (t - 1)));
1087                 ASSERT_LT((end - start), (vrefresh_interval * t + vrefresh_interval));
1088         }
1089 }
1090
1091 TEST_P(TDMClient, ClientVblankWaitSetOffset)
1092 {
1093         bool done;
1094
1095         ASSERT_EQ(PrepareClient(), true);
1096         ASSERT_EQ(PrepareOutput(), true);
1097         ASSERT_EQ(PrepareVblank(), true);
1098
1099         ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE);
1100
1101         done = false;
1102         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1103
1104         start = tdm_helper_get_time();
1105         while (!done)
1106                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1107         end = tdm_helper_get_time();
1108
1109         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1110         ASSERT_GT((end - start), (0.1));
1111         ASSERT_LT((end - start), (vrefresh_interval + vrefresh_interval + 0.1));
1112 }
1113
1114 TEST_P(TDMClient, ClientVblankWaitSetFps)
1115 {
1116         bool done;
1117         double interval;
1118         unsigned int fps = 10;
1119
1120         ASSERT_EQ(PrepareClient(), true);
1121         ASSERT_EQ(PrepareOutput(), true);
1122         ASSERT_EQ(PrepareVblank(), true);
1123
1124         ASSERT_EQ(tdm_client_vblank_set_fps(vblank, fps), TDM_ERROR_NONE);
1125         interval = 1.0 / (double)fps;
1126
1127         done = false;
1128         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1129
1130         start = tdm_helper_get_time();
1131         while (!done)
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_GT((end - start), (interval - vrefresh_interval));
1137         ASSERT_LT((end - start), (interval + vrefresh_interval));
1138 }
1139
1140 #if 0
1141
1142 TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps)
1143 {
1144         TDM_UT_SKIP_FLAG(has_outputs);
1145
1146         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1147         double vrefresh_interval;
1148         unsigned int cur_seq[3];
1149         unsigned int global_fps = 5;
1150         double start, end, interval;
1151
1152         ASSERT_EQ(TestPrepareOutput(), true);
1153         ASSERT_EQ(TestCreateVblanks3(), true);
1154         ASSERT_EQ(vblank_count, 3);
1155
1156         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1157         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1158         vrefresh_interval = 1.0 / (double)fps;
1159
1160         for (int v = 0; v < 3; v++)
1161                 ASSERT_EQ(tdm_vblank_set_fixed_fps(vblanks[v], 10 * (v + 1)), TDM_ERROR_NONE);
1162
1163         /* enable test */
1164         tdm_vblank_enable_global_fps(1, global_fps);
1165         interval = 1.0 / (double)global_fps;
1166
1167         for (int v = 0; v < 3; v++) {
1168                 cur_seq[v] = 0;
1169                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1170         }
1171
1172         start = tdm_helper_get_time();
1173         while (cur_seq[0] == 0)
1174                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1175         end = tdm_helper_get_time();
1176
1177         ASSERT_NE(cur_seq[1], 0);
1178         ASSERT_NE(cur_seq[2], 0);
1179
1180         /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */
1181         ASSERT_GT((end - start), (interval - vrefresh_interval));
1182         ASSERT_LT((end - start), (interval + vrefresh_interval));
1183
1184         /* disable test */
1185         tdm_vblank_enable_global_fps(0, 0);
1186
1187         for (int v = 0; v < 3; v++) {
1188                 cur_seq[v] = 0;
1189                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1190         }
1191
1192         while (cur_seq[0] == 0)
1193                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1194         ASSERT_EQ(cur_seq[1], 0);
1195         ASSERT_EQ(cur_seq[2], 0);
1196
1197         while (cur_seq[1] == 0)
1198                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1199         ASSERT_EQ(cur_seq[2], 0);
1200 }
1201
1202 TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps)
1203 {
1204         TDM_UT_SKIP_FLAG(has_outputs);
1205
1206         unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE;
1207         unsigned int cur_seq[3];
1208         unsigned int global_fps = 5;
1209         double start, end, interval;
1210
1211         ASSERT_EQ(TestPrepareOutput(), true);
1212         ASSERT_EQ(TestCreateVblanks3(), true);
1213         ASSERT_EQ(vblank_count, 3);
1214
1215         ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE);
1216         ASSERT_TRUE(fps >= 30 && fps != (unsigned int)TDM_UT_INVALID_VALUE);
1217         interval = 1.0 / (double)fps;
1218
1219         /* 2nd vblank will ignore the global fps. */
1220         ASSERT_EQ(tdm_vblank_ignore_global_fps(vblanks[1], 1), TDM_ERROR_NONE);
1221
1222         tdm_vblank_enable_global_fps(1, global_fps);
1223
1224         for (int v = 0; v < 3; v++) {
1225                 cur_seq[v] = 0;
1226                 ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE);
1227         }
1228
1229         start = tdm_helper_get_time();
1230         while (cur_seq[1] == 0)
1231                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1232         end = tdm_helper_get_time();
1233
1234         ASSERT_EQ(cur_seq[0], 0);
1235         ASSERT_EQ(cur_seq[2], 0);
1236
1237         /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */
1238         ASSERT_LT((end - start), (interval + interval));
1239
1240         while (cur_seq[0] == 0)
1241                 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1242         ASSERT_NE(cur_seq[2], 0);
1243 }
1244
1245 #endif
1246
1247 TEST_P(TDMClient, ClientVblankWaitNullObject)
1248 {
1249         unsigned int cur_seq = 0;
1250
1251         ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER);
1252 }
1253
1254 TEST_P(TDMClient, ClientVblankWaitNullOther)
1255 {
1256         ASSERT_EQ(PrepareClient(), true);
1257         ASSERT_EQ(PrepareOutput(), true);
1258         ASSERT_EQ(PrepareVblank(), true);
1259
1260         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
1261 }
1262
1263 TEST_P(TDMClient, ClientVblankWaitDpmsOff)
1264 {
1265         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1266
1267         ASSERT_EQ(PrepareClient(), true);
1268         ASSERT_EQ(PrepareOutput(), true);
1269         ASSERT_EQ(PrepareVblank(), true);
1270
1271         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1272         while (dpms != TDM_OUTPUT_DPMS_OFF)
1273                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1274         ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF);
1275
1276         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF);
1277
1278         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1279         while (dpms != TDM_OUTPUT_DPMS_ON)
1280                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1281 }
1282
1283 TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff)
1284 {
1285         tdm_output_dpms dpms = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1286         bool done;
1287
1288         ASSERT_EQ(PrepareClient(), true);
1289         ASSERT_EQ(PrepareOutput(), true);
1290         ASSERT_EQ(PrepareVblank(), true);
1291
1292         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true);
1293         while (dpms != TDM_OUTPUT_DPMS_OFF)
1294                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1295
1296         ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE);
1297
1298         done = false;
1299         ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE);
1300
1301         while (!done)
1302                 ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE);
1303
1304         ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true);
1305         while (dpms != TDM_OUTPUT_DPMS_ON)
1306                 ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE);
1307 }
1308
1309 #ifdef TDM_UT_TEST_WITH_PARAMS
1310 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1311                                                 TDMClient,
1312                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1313 #else
1314 INSTANTIATE_TEST_CASE_P(TDMClientParams,
1315                                                 TDMClient,
1316                                                 Values(TDM_DEFAULT_MODULE));
1317 #endif