tests/tc_remote_surface.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4
   5 #include <cstring>
   6 #include <libds/log.h>
   7 #include <libds-tizen/remote_surface.h>
   8 #include <tizen-remote-surface-client-protocol.h>
   9 #include <wayland-tbm-client.h>
  10 #include <wayland-tbm-server.h>
  11
  12 TEST(RemoteSurfaceSimpleTest, CreateRemoteSurfaceManager)
  13 {
  14     struct wl_display *display = wl_display_create();
  15
  16     struct ds_tizen_remote_surface_manager *remote_surface_manager =
  17         ds_tizen_remote_surface_manager_create(display);
  18     ASSERT_NE(remote_surface_manager, nullptr);
  19
  20     wl_display_destroy(display);
  21 }
  22
  23 class RemoteSurfaceCompositor : public MockCompositor, public ::testing::Test
  24 {
  25 public:
  26     RemoteSurfaceCompositor() :
  27         MockCompositor(&RemoteSurfaceCompositor::SetUpComp, this)
  28     {
  29     }
  30
  31     static void SetUpComp(void *data)
  32     {
  33         RemoteSurfaceCompositor *comp = static_cast<RemoteSurfaceCompositor*>(data);
  34
  35         struct ds_tizen_remote_surface_manager *remote_surface_manager =
  36             ds_tizen_remote_surface_manager_create(comp->GetWlDisplay());
  37         ASSERT_NE(remote_surface_manager, nullptr);
  38
  39         struct wayland_tbm_server *tbm_server =
  40             wayland_tbm_server_init(comp->GetWlDisplay(), NULL, -1, 0);;
  41         ASSERT_NE(tbm_server, nullptr);
  42     }
  43 };
  44
  45 static void handle_global(void *data, struct wl_registry *registry,
  46     uint32_t name, const char *interface, uint32_t version);
  47 static void handle_global_remove(void *data, struct wl_registry *registry,
  48         uint32_t name);
  49
  50 static const struct wl_registry_listener registry_listener = {
  51     .global = handle_global,
  52     .global_remove = handle_global_remove,
  53 };
  54
  55 class MockRemoteSurfaceClient : public MockClient
  56 {
  57 public:
  58     MockRemoteSurfaceClient() : MockClient(&registry_listener, this),
  59                                 resource_id(0),
  60                                 provider_visibility(0),
  61                                 input_event_filter(0)
  62     {
  63         EXPECT_NE(this->compositor, nullptr);
  64         EXPECT_NE(this->remote_surface_manager, nullptr);
  65
  66         surface = wl_compositor_create_surface(this->compositor);
  67         EXPECT_NE(this->surface, nullptr);
  68
  69         surface2 = wl_compositor_create_surface(this->compositor);
  70         EXPECT_NE(this->surface, nullptr);
  71
  72         wl_tbm_client = wayland_tbm_client_init(GetWlDisplay());
  73         EXPECT_NE(wl_tbm_client, nullptr);
  74
  75         wl_tbm = wayland_tbm_client_get_wl_tbm(wl_tbm_client);
  76     }
  77
  78     ~MockRemoteSurfaceClient()
  79     {
  80         wl_surface_destroy(this->surface);
  81         tizen_remote_surface_manager_destroy(this->remote_surface_manager);
  82         wl_compositor_destroy(this->compositor);
  83     }
  84
  85     struct wl_compositor *compositor;
  86     struct tizen_remote_surface_manager *remote_surface_manager;
  87     struct wl_surface *surface, *surface2;
  88     uint32_t resource_id;
  89     uint32_t provider_visibility;
  90     uint32_t input_event_filter;
  91     struct wayland_tbm_client *wl_tbm_client;
  92     struct wl_tbm *wl_tbm;
  93 };
  94
  95 static void
  96 handle_global(void *data, struct wl_registry *registry,
  97     uint32_t name, const char *interface, uint32_t version)
  98 {
  99     MockRemoteSurfaceClient *client = static_cast<MockRemoteSurfaceClient*>(data);
 100
 101     if (strcmp(interface, "wl_compositor") == 0) {
 102         client->compositor = static_cast<struct wl_compositor *>(
 103                 wl_registry_bind(registry, name, &wl_compositor_interface, 4));
 104     } else if (strcmp(interface, "tizen_remote_surface_manager") == 0) {
 105         client->remote_surface_manager = static_cast<struct tizen_remote_surface_manager *>(
 106                 wl_registry_bind(registry, name, &tizen_remote_surface_manager_interface, 6));
 107     }
 108 }
 109
 110 static void
 111 handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
 112 {
 113 }
 114
 115 static void
 116 handle_provider_resource_id(void *data,
 117                             struct tizen_remote_surface_provider *provider,
 118                             uint32_t resource_id)
 119 {
 120     MockRemoteSurfaceClient *client = static_cast<MockRemoteSurfaceClient*>(data);
 121
 122     client->resource_id = resource_id;
 123 }
 124
 125 static void
 126 handle_provider_visibility(void *data,
 127                            struct tizen_remote_surface_provider *provider,
 128                            uint32_t visibility)
 129 {
 130     MockRemoteSurfaceClient *client = static_cast<MockRemoteSurfaceClient*>(data);
 131
 132     client->provider_visibility = visibility;
 133 }
 134
 135 static const struct tizen_remote_surface_provider_listener provider_listener =
 136 {
 137     handle_provider_resource_id,
 138     handle_provider_visibility,
 139 };
 140
 141 static void
 142 handle_remote_surface_update_buffer(void *data,
 143                                     struct tizen_remote_surface *remote_surface,
 144                                     struct wl_buffer *buffer,
 145                                     uint32_t time)
 146 {
 147     wl_buffer_destroy(buffer);
 148 }
 149
 150 static void
 151 handle_remote_surface_missing(void *data,
 152                               struct tizen_remote_surface *remote_surface)
 153 {
 154 }
 155
 156 static void
 157 handle_remote_surface_changed_buffer(void *data,
 158                                      struct tizen_remote_surface *remote_surface,
 159                                      uint32_t type,
 160                                      struct wl_buffer *tbm,
 161                                      int32_t fd,
 162                                      uint32_t size,
 163                                      uint32_t time,
 164                                      struct wl_array *keys)
 165 {
 166     tbm_surface_h tbm_surface;
 167
 168     if (type == TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM) {
 169         tbm_surface = static_cast<tbm_surface_h>(wl_buffer_get_user_data(tbm));
 170         ASSERT_EQ(tbm_surface, nullptr);
 171
 172         wl_buffer_destroy(tbm);
 173     }
 174
 175     close(fd);
 176 }
 177
 178 static void
 179 handle_remote_surface_input_ev_filter(void *data,
 180                                       struct tizen_remote_surface *tizen_remote_surface,
 181                                       uint32_t input_event_filter)
 182 {
 183     MockRemoteSurfaceClient *client = static_cast<MockRemoteSurfaceClient*>(data);
 184
 185     client->input_event_filter = input_event_filter;
 186 }
 187
 188 static const struct tizen_remote_surface_listener remote_surface_listener =
 189 {
 190     handle_remote_surface_update_buffer, /* deprecated */
 191     handle_remote_surface_missing,
 192     handle_remote_surface_changed_buffer,
 193     handle_remote_surface_input_ev_filter,
 194 };
 195
 196 TEST_F(RemoteSurfaceCompositor, CreateProvider)
 197 {
 198     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 199
 200     struct tizen_remote_surface_provider *remote_surface_provider;
 201
 202     remote_surface_provider =
 203         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 204                                                      client->surface);
 205     EXPECT_TRUE(remote_surface_provider);
 206
 207     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 208                                                &provider_listener,
 209                                                client);
 210
 211     client->ExpectNoError();
 212
 213     tizen_remote_surface_provider_destroy(remote_surface_provider);
 214     delete client;
 215 }
 216
 217 TEST_F(RemoteSurfaceCompositor, ProviderOffscreenSet)
 218 {
 219     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 220
 221     struct tizen_remote_surface_provider *remote_surface_provider;
 222
 223     remote_surface_provider =
 224         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 225                                                      client->surface);
 226     EXPECT_TRUE(remote_surface_provider);
 227
 228     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 229                                                &provider_listener,
 230                                                client);
 231     client->ExpectNoError();
 232
 233     tizen_remote_surface_provider_offscreen_set(remote_surface_provider, 1);
 234     client->ExpectNoError();
 235
 236     tizen_remote_surface_provider_destroy(remote_surface_provider);
 237     delete client;
 238 }
 239
 240 TEST_F(RemoteSurfaceCompositor, ProviderSetInputEventFilter)
 241 {
 242     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 243
 244     struct tizen_remote_surface_provider *remote_surface_provider;
 245
 246     remote_surface_provider =
 247         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 248                                                      client->surface);
 249     EXPECT_TRUE(remote_surface_provider);
 250
 251     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 252                                                &provider_listener,
 253                                                client);
 254     client->ExpectNoError();
 255
 256     tizen_remote_surface_provider_set_input_event_filter(remote_surface_provider,
 257         TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_ALL|
 258         TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_MOUSE_WHEEL_ALL |
 259         TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_ALL |
 260         TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_TOUCH_CANCEL_ALL |
 261         TIZEN_REMOTE_SURFACE_INPUT_EVENT_FILTER_KEY_ALL);
 262     client->ExpectNoError();
 263
 264     tizen_remote_surface_provider_destroy(remote_surface_provider);
 265     delete client;
 266 }
 267
 268 TEST_F(RemoteSurfaceCompositor, CreateSurface)
 269 {
 270     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 271
 272     struct tizen_remote_surface_provider *remote_surface_provider;
 273     struct tizen_remote_surface *remote_surface;
 274
 275     remote_surface_provider =
 276         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 277                                                      client->surface);
 278     EXPECT_TRUE(remote_surface_provider);
 279
 280     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 281                                                &provider_listener,
 282                                                client);
 283     client->ExpectNoError();
 284
 285     remote_surface = tizen_remote_surface_manager_create_surface(
 286         client->remote_surface_manager, client->resource_id, client->wl_tbm);
 287     EXPECT_TRUE(remote_surface);
 288
 289     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 290     client->ExpectNoError();
 291
 292     tizen_remote_surface_provider_destroy(remote_surface_provider);
 293     tizen_remote_surface_destroy(remote_surface);
 294     delete client;
 295 }
 296
 297 TEST_F(RemoteSurfaceCompositor, CreateSurfaceWithWlSurface)
 298 {
 299     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 300
 301     struct tizen_remote_surface_provider *remote_surface_provider;
 302     struct tizen_remote_surface *remote_surface;
 303
 304     remote_surface_provider =
 305         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 306                                                      client->surface);
 307     EXPECT_TRUE(remote_surface_provider);
 308
 309     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 310                                                &provider_listener,
 311                                                client);
 312     client->ExpectNoError();
 313
 314     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 315         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 316     EXPECT_TRUE(remote_surface);
 317
 318     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 319     client->ExpectNoError();
 320
 321     tizen_remote_surface_provider_destroy(remote_surface_provider);
 322     tizen_remote_surface_destroy(remote_surface);
 323     delete client;
 324 }
 325
 326 TEST_F(RemoteSurfaceCompositor, SurfaceRedirect)
 327 {
 328     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 329
 330     struct tizen_remote_surface_provider *remote_surface_provider;
 331     struct tizen_remote_surface *remote_surface;
 332
 333     remote_surface_provider =
 334         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 335                                                      client->surface);
 336     EXPECT_TRUE(remote_surface_provider);
 337
 338     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 339                                                &provider_listener,
 340                                                client);
 341     client->ExpectNoError();
 342
 343     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 344         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 345     EXPECT_TRUE(remote_surface);
 346
 347     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 348     client->ExpectNoError();
 349
 350     tizen_remote_surface_redirect(remote_surface);
 351     client->ExpectNoError();
 352
 353     tizen_remote_surface_provider_destroy(remote_surface_provider);
 354     tizen_remote_surface_destroy(remote_surface);
 355     delete client;
 356 }
 357
 358 TEST_F(RemoteSurfaceCompositor, SurfaceUnredirect)
 359 {
 360     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 361
 362     struct tizen_remote_surface_provider *remote_surface_provider;
 363     struct tizen_remote_surface *remote_surface;
 364
 365     remote_surface_provider =
 366         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 367                                                      client->surface);
 368     EXPECT_TRUE(remote_surface_provider);
 369
 370     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 371                                                &provider_listener,
 372                                                client);
 373     client->ExpectNoError();
 374
 375     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 376         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 377     EXPECT_TRUE(remote_surface);
 378
 379     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 380     client->ExpectNoError();
 381
 382     tizen_remote_surface_unredirect(remote_surface);
 383     client->ExpectNoError();
 384
 385     tizen_remote_surface_provider_destroy(remote_surface_provider);
 386     tizen_remote_surface_destroy(remote_surface);
 387     delete client;
 388 }
 389
 390 TEST_F(RemoteSurfaceCompositor, SurfaceTransferMouseEvent)
 391 {
 392     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 393
 394     struct tizen_remote_surface_provider *remote_surface_provider;
 395     struct tizen_remote_surface *remote_surface;
 396     uint32_t event_type = 0;
 397     int32_t device = 0;
 398     int32_t button = 0;
 399     int32_t x = 0, y = 0;
 400     wl_fixed_t radius_x = 0, radius_y = 0;
 401     wl_fixed_t pressure = 0;
 402     wl_fixed_t angle = 0;
 403     uint32_t clas = 0, subclas = 0;
 404     const char *identifier = "test_identifier";
 405     uint32_t time = 0;
 406
 407     remote_surface_provider =
 408         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 409                                                      client->surface);
 410     EXPECT_TRUE(remote_surface_provider);
 411
 412     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 413                                                &provider_listener,
 414                                                client);
 415     client->ExpectNoError();
 416
 417     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 418         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 419     EXPECT_TRUE(remote_surface);
 420
 421     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 422     client->ExpectNoError();
 423
 424     tizen_remote_surface_transfer_mouse_event(remote_surface,
 425                                               event_type,
 426                                               device,
 427                                               button,
 428                                               x,
 429                                               y,
 430                                               radius_x,
 431                                               radius_y,
 432                                               pressure,
 433                                               angle,
 434                                               clas,
 435                                               subclas,
 436                                               identifier,
 437                                               time);
 438     client->ExpectNoError();
 439
 440     tizen_remote_surface_provider_destroy(remote_surface_provider);
 441     tizen_remote_surface_destroy(remote_surface);
 442     delete client;
 443 }
 444
 445 TEST_F(RemoteSurfaceCompositor, SurfaceTransferMouseWheel)
 446 {
 447     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 448
 449     struct tizen_remote_surface_provider *remote_surface_provider;
 450     struct tizen_remote_surface *remote_surface;
 451     uint32_t direction = 0;
 452     int32_t z = 0;
 453     uint32_t clas = 0, subclas = 0;
 454     const char *identifier = "test_identifier";
 455     uint32_t time = 0;
 456
 457     remote_surface_provider =
 458         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 459                                                      client->surface);
 460     EXPECT_TRUE(remote_surface_provider);
 461
 462     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 463                                                &provider_listener,
 464                                                client);
 465     client->ExpectNoError();
 466
 467     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 468         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 469     EXPECT_TRUE(remote_surface);
 470
 471     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 472     client->ExpectNoError();
 473
 474     tizen_remote_surface_transfer_mouse_wheel(remote_surface,
 475                                               direction,
 476                                               z,
 477                                               clas,
 478                                               subclas,
 479                                               identifier,
 480                                               time);
 481     client->ExpectNoError();
 482
 483     tizen_remote_surface_provider_destroy(remote_surface_provider);
 484     tizen_remote_surface_destroy(remote_surface);
 485     delete client;
 486 }
 487
 488 TEST_F(RemoteSurfaceCompositor, SurfaceTransferTouchEvent)
 489 {
 490     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 491
 492     struct tizen_remote_surface_provider *remote_surface_provider;
 493     struct tizen_remote_surface *remote_surface;
 494     uint32_t event_type = 0;
 495     int32_t device = 0;
 496     int32_t button = 0;
 497     int32_t x = 0, y = 0;
 498     wl_fixed_t radius_x = 0, radius_y = 0;
 499     wl_fixed_t pressure = 0;
 500     wl_fixed_t angle = 0;
 501     uint32_t clas = 0, subclas = 0;
 502     const char *identifier = "test_identifier";
 503     uint32_t time = 0;
 504
 505     remote_surface_provider =
 506         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 507                                                      client->surface);
 508     EXPECT_TRUE(remote_surface_provider);
 509
 510     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 511                                                &provider_listener,
 512                                                client);
 513     client->ExpectNoError();
 514
 515     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 516         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 517     EXPECT_TRUE(remote_surface);
 518
 519     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 520     client->ExpectNoError();
 521
 522     tizen_remote_surface_transfer_touch_event(remote_surface,
 523                                               event_type,
 524                                               device,
 525                                               button,
 526                                               x,
 527                                               y,
 528                                               radius_x,
 529                                               radius_y,
 530                                               pressure,
 531                                               angle,
 532                                               clas,
 533                                               subclas,
 534                                               identifier,
 535                                               time);
 536     client->ExpectNoError();
 537
 538     tizen_remote_surface_provider_destroy(remote_surface_provider);
 539     tizen_remote_surface_destroy(remote_surface);
 540     delete client;
 541 }
 542
 543 TEST_F(RemoteSurfaceCompositor, SurfaceTransferTouchCancel)
 544 {
 545     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 546
 547     struct tizen_remote_surface_provider *remote_surface_provider;
 548     struct tizen_remote_surface *remote_surface;
 549
 550     remote_surface_provider =
 551         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 552                                                      client->surface);
 553     EXPECT_TRUE(remote_surface_provider);
 554
 555     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 556                                                &provider_listener,
 557                                                client);
 558     client->ExpectNoError();
 559
 560     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 561         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 562     EXPECT_TRUE(remote_surface);
 563
 564     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 565     client->ExpectNoError();
 566
 567     tizen_remote_surface_transfer_touch_cancel(remote_surface);
 568     client->ExpectNoError();
 569
 570     tizen_remote_surface_provider_destroy(remote_surface_provider);
 571     tizen_remote_surface_destroy(remote_surface);
 572     delete client;
 573 }
 574
 575 TEST_F(RemoteSurfaceCompositor, SurfaceTransferKeyEvent)
 576 {
 577     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 578
 579     struct tizen_remote_surface_provider *remote_surface_provider;
 580     struct tizen_remote_surface *remote_surface;
 581     uint32_t event_type = 0;
 582     int32_t keycode = 0;
 583     uint32_t clas = 0, subclas = 0;
 584     const char *identifier = "test_identifier";
 585     uint32_t time = 0;
 586
 587     remote_surface_provider =
 588         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 589                                                      client->surface);
 590     EXPECT_TRUE(remote_surface_provider);
 591
 592     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 593                                                &provider_listener,
 594                                                client);
 595     client->ExpectNoError();
 596
 597     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 598         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 599     EXPECT_TRUE(remote_surface);
 600
 601     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 602     client->ExpectNoError();
 603
 604     tizen_remote_surface_transfer_key_event(remote_surface,
 605                                             event_type,
 606                                             keycode,
 607                                             clas,
 608                                             subclas,
 609                                             identifier,
 610                                             time);
 611     client->ExpectNoError();
 612
 613     tizen_remote_surface_provider_destroy(remote_surface_provider);
 614     tizen_remote_surface_destroy(remote_surface);
 615     delete client;
 616 }
 617
 618 TEST_F(RemoteSurfaceCompositor, SurfaceTransferVisibility)
 619 {
 620     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 621
 622     struct tizen_remote_surface_provider *remote_surface_provider;
 623     struct tizen_remote_surface *remote_surface;
 624
 625     remote_surface_provider =
 626         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 627                                                      client->surface);
 628     EXPECT_TRUE(remote_surface_provider);
 629
 630     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 631                                                &provider_listener,
 632                                                client);
 633     client->ExpectNoError();
 634
 635     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 636         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 637     EXPECT_TRUE(remote_surface);
 638
 639     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 640     client->ExpectNoError();
 641
 642     tizen_remote_surface_transfer_visibility(remote_surface,
 643                                              TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE);
 644     client->ExpectNoError();
 645
 646     tizen_remote_surface_provider_destroy(remote_surface_provider);
 647     tizen_remote_surface_destroy(remote_surface);
 648     delete client;
 649 }
 650
 651 TEST_F(RemoteSurfaceCompositor, SurfaceSetOwner)
 652 {
 653     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 654
 655     struct tizen_remote_surface_provider *remote_surface_provider;
 656     struct tizen_remote_surface *remote_surface;
 657
 658     remote_surface_provider =
 659         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 660                                                      client->surface);
 661     EXPECT_TRUE(remote_surface_provider);
 662
 663     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 664                                                &provider_listener,
 665                                                client);
 666     client->ExpectNoError();
 667
 668     remote_surface = tizen_remote_surface_manager_create_surface(
 669         client->remote_surface_manager, client->resource_id, client->wl_tbm);
 670     EXPECT_TRUE(remote_surface);
 671
 672     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 673     client->ExpectNoError();
 674
 675     tizen_remote_surface_set_owner(remote_surface, client->surface2);
 676     client->ExpectNoError();
 677
 678     tizen_remote_surface_provider_destroy(remote_surface_provider);
 679     tizen_remote_surface_destroy(remote_surface);
 680     delete client;
 681 }
 682
 683 TEST_F(RemoteSurfaceCompositor, SurfaceSetRemoteRender)
 684 {
 685     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 686
 687     struct tizen_remote_surface_provider *remote_surface_provider;
 688     struct tizen_remote_surface *remote_surface;
 689
 690     remote_surface_provider =
 691         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 692                                                      client->surface);
 693     EXPECT_TRUE(remote_surface_provider);
 694
 695     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 696                                                &provider_listener,
 697                                                client);
 698     client->ExpectNoError();
 699
 700     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 701         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 702     EXPECT_TRUE(remote_surface);
 703
 704     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 705     client->ExpectNoError();
 706
 707     tizen_remote_surface_set_remote_render(remote_surface, 1);
 708     client->ExpectNoError();
 709
 710     tizen_remote_surface_provider_destroy(remote_surface_provider);
 711     tizen_remote_surface_destroy(remote_surface);
 712     delete client;
 713 }
 714
 715 TEST_F(RemoteSurfaceCompositor, SurfaceSetChangedBufferEventFilter)
 716 {
 717     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 718
 719     struct tizen_remote_surface_provider *remote_surface_provider;
 720     struct tizen_remote_surface *remote_surface;
 721
 722     remote_surface_provider =
 723         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 724                                                      client->surface);
 725     EXPECT_TRUE(remote_surface_provider);
 726
 727     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 728                                                &provider_listener,
 729                                                client);
 730     client->ExpectNoError();
 731
 732     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 733         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 734     EXPECT_TRUE(remote_surface);
 735
 736     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 737     client->ExpectNoError();
 738
 739     tizen_remote_surface_set_changed_buffer_event_filter(remote_surface,
 740         TIZEN_REMOTE_SURFACE_CHANGED_BUFFER_EVENT_FILTER_TBM |
 741         TIZEN_REMOTE_SURFACE_CHANGED_BUFFER_EVENT_FILTER_IMAGE_FILE);
 742     client->ExpectNoError();
 743
 744     tizen_remote_surface_provider_destroy(remote_surface_provider);
 745     tizen_remote_surface_destroy(remote_surface);
 746     delete client;
 747 }
 748
 749 TEST_F(RemoteSurfaceCompositor, SurfaceGetCurrentBuffer)
 750 {
 751     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 752
 753     struct tizen_remote_surface_provider *remote_surface_provider;
 754     struct tizen_remote_surface *remote_surface;
 755
 756     remote_surface_provider =
 757         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 758                                                      client->surface);
 759     EXPECT_TRUE(remote_surface_provider);
 760
 761     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 762                                                &provider_listener,
 763                                                client);
 764     client->ExpectNoError();
 765
 766     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 767         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 768     EXPECT_TRUE(remote_surface);
 769
 770     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 771     client->ExpectNoError();
 772
 773     tizen_remote_surface_get_current_buffer(remote_surface, TIZEN_REMOTE_SURFACE_BUFFER_TYPE_TBM, 1);
 774     client->ExpectNoError();
 775
 776     tizen_remote_surface_provider_destroy(remote_surface_provider);
 777     tizen_remote_surface_destroy(remote_surface);
 778     delete client;
 779 }
 780
 781 TEST_F(RemoteSurfaceCompositor, RegionSetGeometry)
 782 {
 783     MockRemoteSurfaceClient *client = new MockRemoteSurfaceClient();
 784
 785     struct tizen_remote_surface_provider *remote_surface_provider;
 786     struct tizen_remote_surface *remote_surface;
 787     struct tizen_remote_surface_region *region;
 788
 789     remote_surface_provider =
 790         tizen_remote_surface_manager_create_provider(client->remote_surface_manager,
 791                                                      client->surface);
 792     EXPECT_TRUE(remote_surface_provider);
 793
 794     tizen_remote_surface_provider_add_listener(remote_surface_provider,
 795                                                &provider_listener,
 796                                                client);
 797     client->ExpectNoError();
 798
 799     remote_surface = tizen_remote_surface_manager_create_surface_with_wl_surface(
 800         client->remote_surface_manager, client->resource_id, client->wl_tbm, client->surface2);
 801     EXPECT_TRUE(remote_surface);
 802
 803     tizen_remote_surface_add_listener(remote_surface, &remote_surface_listener, NULL);
 804     client->ExpectNoError();
 805
 806     region = tizen_remote_surface_create_region(remote_surface);
 807     EXPECT_TRUE(region);
 808
 809     tizen_remote_surface_region_set_geometry(region, 0, 0, 100, 100);
 810     client->ExpectNoError();
 811
 812     tizen_remote_surface_provider_destroy(remote_surface_provider);
 813     tizen_remote_surface_destroy(remote_surface);
 814     delete client;
 815 }