tests/tc_screenshooter.cpp

   1 #include <libds/output.h>
   2 #include <libds/backend/wayland.h>
   3 #include <libds-tizen/screenshooter.h>
   4 #ifdef TIZEN_SCREENMIRROR_STOP
   5 #undef TIZEN_SCREENMIRROR_STOP
   6 #endif
   7 #include <tizen-extension-client-protocol.h>
   8 #include <wayland-tbm-client.h>
   9 #include <tbm_surface.h>
  10 #include <sys/mman.h>
  11 #include "tc_main.h"
  12 #include "mockclient.h"
  13 #include "mockcompositor.h"
  14
  15 #define TIZEN_SCREENSHOOTER_VERSION 3
  16 #define SHM_BUF_WIDTH 1920
  17 #define SHM_BUF_HEIGHT 1080
  18 #define SHM_BUF_STRIDE 7680 //width * 4
  19 #define SHM_BUF_FORMAT WL_SHM_FORMAT_XRGB8888
  20
  21 class MockScreenShooterCompositor : public MockCompositor
  22 {
  23 public:
  24     MockScreenShooterCompositor()
  25         : MockCompositor(&MockScreenShooterCompositor::TestSetup, this)
  26     {
  27         ds_inf("%s : this(%p)", __func__, this);
  28
  29         bDestroyed = false;
  30         bMirror = false;
  31         bDestroyMirror = false;
  32         bShoot = false;
  33         bStart = false;
  34         bAutoRotation = false;
  35         mBackend = nullptr;
  36         mBuffer = nullptr;
  37         mOutput = nullptr;;
  38         mScreenShooter = nullptr;
  39         mScreenMirror = nullptr;
  40         new_output = {};
  41
  42         mDestroyListener = {};
  43         mNewScreenMirrorListener = {};
  44         mScreenShootListener = {};
  45         mScreenMirrorDestroyListener = {};
  46         mScreenMirrorSetStretchListener = {};
  47         mScreenMirrorQueueListener = {};
  48         mScreenMirrorDequeueListener = {};
  49         mScreenMirrorStartListener = {};
  50         mScreenMirrorStopListener = {};
  51         mScreenMirrorAutoRotationListener = {};
  52     }
  53
  54     ~MockScreenShooterCompositor()
  55     {
  56         ds_inf("%s : this(%p)", __func__, this);
  57     }
  58
  59     static void TestSetup(void *data)
  60     {
  61         MockScreenShooterCompositor *mockComp =
  62             static_cast<MockScreenShooterCompositor *>(data);
  63         Compositor *comp = mockComp->compositor;
  64
  65         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  66
  67         mockComp->mBackend = ds_wl_backend_create(comp->display, NULL);
  68         mockComp->new_output.notify = screenshooter_backend_handle_new_output;
  69         ds_backend_add_new_output_listener(mockComp->mBackend, &mockComp->new_output);
  70         ds_backend_start(mockComp->mBackend);
  71
  72         mockComp->mScreenShooter =
  73             ds_tizen_screenshooter_create(comp->display);
  74
  75         // add destroy listener
  76         mockComp->mDestroyListener.notify =
  77             MockScreenShooterCompositor::DestroyCallback;
  78         mockComp->mDestroyListener.parent = mockComp;
  79         ds_tizen_screenshooter_add_destroy_listener(mockComp->mScreenShooter,
  80             &mockComp->mDestroyListener);
  81
  82         // add newscreenmirror listener
  83         mockComp->mNewScreenMirrorListener.notify =
  84             MockScreenShooterCompositor::NewScreenMirrorCallback;
  85         mockComp->mNewScreenMirrorListener.parent = mockComp;
  86         ds_tizen_screenshooter_add_get_screenmirror_listener(mockComp->mScreenShooter,
  87             &mockComp->mNewScreenMirrorListener);
  88
  89         // add shoot listener
  90         mockComp->mScreenShootListener.notify =
  91             MockScreenShooterCompositor::ScreenShootCallback;
  92         mockComp->mScreenShootListener.parent = mockComp;
  93         ds_tizen_screenshooter_add_shoot_listener(mockComp->mScreenShooter,
  94             &mockComp->mScreenShootListener);
  95     }
  96
  97     static void screenshooter_backend_handle_new_output(struct wl_listener *listener,
  98         void *data)
  99     {
 100         MockScreenShooterCompositor *mockComp;
 101
 102         mockComp = wl_container_of(listener, mockComp, new_output);
 103         mockComp->mOutput = static_cast<struct ds_output *>(data);
 104
 105         ds_inf("New ds_output(%p)", mockComp->mOutput);
 106
 107         ds_output_create_global(mockComp->mOutput);
 108         ds_inf("create output global");
 109     }
 110
 111     static void DestroyCallback(struct wl_listener *listener, void *data)
 112     {
 113         ds_inf("%s", __func__);
 114
 115         MockScreenShooterCompositor *mockComp =
 116             reinterpret_cast<DestroyListener *>(listener)->parent;
 117
 118         mockComp->bDestroyed = true;
 119     }
 120
 121     static void NewScreenMirrorCallback(struct wl_listener *listener,
 122         void *data)
 123     {
 124         ds_inf("%s", __func__);
 125
 126         MockScreenShooterCompositor *mockComp =
 127             reinterpret_cast<NewScreenMirrorListener *>(listener)->parent;
 128         struct ds_tizen_screenmirror *mirror =
 129             static_cast<struct ds_tizen_screenmirror *>(data);
 130
 131         ds_inf("%s: mockComp(%p), mirror(%p)", __func__, mockComp, mirror);
 132
 133         mockComp->bMirror = true;
 134         mockComp->mScreenMirror = mirror;
 135
 136         // add destroy listener
 137         mockComp->mScreenMirrorDestroyListener.notify =
 138             MockScreenShooterCompositor::ScreenMirrorDestroyCallback;
 139         mockComp->mScreenMirrorDestroyListener.parent = mockComp;
 140         ds_tizen_screenmirror_add_destroy_listener(mockComp->mScreenMirror,
 141             &mockComp->mScreenMirrorDestroyListener);
 142
 143         // add set_stretch listener
 144         mockComp->mScreenMirrorSetStretchListener.notify =
 145             MockScreenShooterCompositor::ScreenMirrorSetStretchCallback;
 146         mockComp->mScreenMirrorSetStretchListener.parent = mockComp;
 147         ds_tizen_screenmirror_add_set_stretch_listener(mockComp->mScreenMirror,
 148             &mockComp->mScreenMirrorSetStretchListener);
 149
 150         // add queue listener
 151         mockComp->mScreenMirrorQueueListener.notify =
 152             MockScreenShooterCompositor::ScreenMirrorQueueCallback;
 153         mockComp->mScreenMirrorQueueListener.parent = mockComp;
 154         ds_tizen_screenmirror_add_queue_listener(mockComp->mScreenMirror,
 155             &mockComp->mScreenMirrorQueueListener);
 156
 157         // add dequeue listener
 158         mockComp->mScreenMirrorDequeueListener.notify =
 159             MockScreenShooterCompositor::ScreenMirrorDequeueCallback;
 160         mockComp->mScreenMirrorDequeueListener.parent = mockComp;
 161         ds_tizen_screenmirror_add_dequeue_listener(mockComp->mScreenMirror,
 162             &mockComp->mScreenMirrorDequeueListener);
 163
 164         // add start listener
 165         mockComp->mScreenMirrorStartListener.notify =
 166             MockScreenShooterCompositor::ScreenMirrorStartCallback;
 167         mockComp->mScreenMirrorStartListener.parent = mockComp;
 168         ds_tizen_screenmirror_add_start_listener(mockComp->mScreenMirror,
 169             &mockComp->mScreenMirrorStartListener);
 170
 171         // add stop listener
 172         mockComp->mScreenMirrorStopListener.notify =
 173             MockScreenShooterCompositor::ScreenMirrorStopCallback;
 174         mockComp->mScreenMirrorStopListener.parent = mockComp;
 175         ds_tizen_screenmirror_add_stop_listener(mockComp->mScreenMirror,
 176             &mockComp->mScreenMirrorStopListener);
 177
 178         // add auto rotation listener
 179         mockComp->mScreenMirrorAutoRotationListener.notify =
 180             MockScreenShooterCompositor::ScreenMirrorAutoRotationCallback;
 181         mockComp->mScreenMirrorAutoRotationListener.parent = mockComp;
 182         ds_tizen_screenmirror_add_auto_rotation_listener(mockComp->mScreenMirror,
 183             &mockComp->mScreenMirrorAutoRotationListener);
 184     }
 185
 186     static void ScreenShootCallback(struct wl_listener *listener,
 187         void *data)
 188     {
 189         ds_inf("%s", __func__);
 190
 191         MockScreenShooterCompositor *mockComp =
 192             reinterpret_cast<ScreenShootListener *>(listener)->parent;
 193         struct ds_tizen_screenshooter_event_shoot *event =
 194             static_cast<struct ds_tizen_screenshooter_event_shoot *>(data);
 195
 196
 197         ds_inf("%s: mockComp(%p), output(%p), buffer(%p), client(%p), auto_rotate:%d",
 198             __func__, mockComp, event->output, event->buffer, event->client,
 199             event->auto_rotation ? 1 : 0);
 200
 201         mockComp->bShoot = true;
 202         ds_tizen_screenshooter_send_shoot_done(mockComp->mScreenShooter, event->client);
 203     }
 204
 205     static void ScreenMirrorDestroyCallback(struct wl_listener *listener,
 206         void *data)
 207     {
 208         ds_inf("%s", __func__);
 209
 210         MockScreenShooterCompositor *mockComp =
 211             reinterpret_cast<ScreenMirrorDestroyListener *>(listener)->parent;
 212         struct ds_tizen_screenmirror *mirror =
 213             static_cast<struct ds_tizen_screenmirror *>(data);
 214
 215         ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, mirror);
 216
 217         if (mockComp->mScreenMirror == mirror) {
 218             ds_inf("%s: info is deleted.", __func__);
 219             mockComp->bDestroyMirror = true;
 220         }
 221     }
 222
 223     static void ScreenMirrorSetStretchCallback(struct wl_listener *listener,
 224         void *data)
 225     {
 226         ds_inf("%s", __func__);
 227
 228         MockScreenShooterCompositor *mockComp =
 229             reinterpret_cast<ScreenMirrorSetStretchListener *>(listener)->parent;
 230         enum ds_tizen_screenmirror_stretch *stretch = (enum ds_tizen_screenmirror_stretch *)data;
 231
 232         ds_inf("%s: mockComp(%p), stretch(%d)", __func__, mockComp, *stretch);
 233     }
 234
 235     static void ScreenMirrorQueueCallback(struct wl_listener *listener,
 236         void *data)
 237     {
 238         ds_inf("%s", __func__);
 239
 240         MockScreenShooterCompositor *mockComp =
 241             reinterpret_cast<ScreenMirrorQueueListener *>(listener)->parent;
 242         struct ds_buffer *buffer =
 243             static_cast<struct ds_buffer *>(data);
 244
 245         ds_inf("%s: mockComp(%p), queue(%p)", __func__, mockComp, buffer);
 246     }
 247
 248     static void ScreenMirrorDequeueCallback(struct wl_listener *listener,
 249         void *data)
 250     {
 251         ds_inf("%s", __func__);
 252
 253         MockScreenShooterCompositor *mockComp =
 254             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 255         struct ds_buffer *buffer =
 256             static_cast<struct ds_buffer *>(data);
 257
 258         ds_inf("%s: mockComp(%p), dequeue(%p)", __func__, mockComp, buffer);
 259
 260         ds_tizen_screenmirror_send_dequeued(mockComp->mScreenMirror, buffer);
 261     }
 262
 263     static void ScreenMirrorStartCallback(struct wl_listener *listener,
 264         void *data)
 265     {
 266         ds_inf("%s", __func__);
 267
 268         MockScreenShooterCompositor *mockComp =
 269             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 270
 271         ds_inf("%s: mockComp(%p), start", __func__, mockComp);
 272
 273         mockComp->bStart = true;
 274     }
 275
 276     static void ScreenMirrorStopCallback(struct wl_listener *listener,
 277         void *data)
 278     {
 279         ds_inf("%s", __func__);
 280
 281         MockScreenShooterCompositor *mockComp =
 282             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 283
 284         ds_inf("%s: mockComp(%p), stop", __func__, mockComp);
 285
 286         mockComp->bStart = false;
 287     }
 288
 289     static void ScreenMirrorAutoRotationCallback(struct wl_listener *listener,
 290         void *data)
 291     {
 292         ds_inf("%s", __func__);
 293
 294         MockScreenShooterCompositor *mockComp =
 295             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 296         uint32_t *set = (uint32_t *)data;
 297
 298         ds_inf("%s: mockComp(%p), autorotation(%d)", __func__, mockComp, *set);
 299
 300         if (*set)
 301             mockComp->bAutoRotation = true;
 302         else
 303             mockComp->bAutoRotation = false;
 304     }
 305
 306 public:
 307     bool bDestroyed;
 308
 309     bool bMirror;
 310     bool bDestroyMirror;
 311     bool bShoot;
 312     bool bStart;
 313     bool bAutoRotation;
 314
 315 private:
 316     struct ds_backend *mBackend;
 317     struct ds_buffer *mBuffer;
 318     struct ds_output *mOutput;
 319     struct ds_tizen_screenshooter *mScreenShooter;
 320         struct ds_tizen_screenmirror *mScreenMirror;
 321     struct wl_listener new_output;
 322
 323     struct DestroyListener : ::wl_listener {
 324         MockScreenShooterCompositor *parent;
 325     };
 326     DestroyListener mDestroyListener;
 327
 328     struct NewScreenMirrorListener : ::wl_listener {
 329         MockScreenShooterCompositor *parent;
 330     };
 331     NewScreenMirrorListener mNewScreenMirrorListener;
 332
 333     struct ScreenShootListener : ::wl_listener {
 334         MockScreenShooterCompositor *parent;
 335     };
 336     ScreenShootListener mScreenShootListener;
 337
 338     struct ScreenMirrorDestroyListener : ::wl_listener {
 339         MockScreenShooterCompositor *parent;
 340     };
 341     ScreenMirrorDestroyListener mScreenMirrorDestroyListener;
 342
 343     struct ScreenMirrorSetStretchListener : ::wl_listener {
 344         MockScreenShooterCompositor *parent;
 345     };
 346     ScreenMirrorSetStretchListener mScreenMirrorSetStretchListener;
 347
 348     struct ScreenMirrorQueueListener : ::wl_listener {
 349         MockScreenShooterCompositor *parent;
 350     };
 351     ScreenMirrorQueueListener mScreenMirrorQueueListener;
 352
 353     struct ScreenMirrorDequeueListener : ::wl_listener {
 354         MockScreenShooterCompositor *parent;
 355     };
 356     ScreenMirrorDequeueListener mScreenMirrorDequeueListener;
 357
 358     struct ScreenMirrorStartListener : ::wl_listener {
 359         MockScreenShooterCompositor *parent;
 360     };
 361     ScreenMirrorStartListener mScreenMirrorStartListener;
 362
 363     struct ScreenMirrorStopListener : ::wl_listener {
 364         MockScreenShooterCompositor *parent;
 365     };
 366     ScreenMirrorStopListener mScreenMirrorStopListener;
 367
 368     struct ScreenMirrorAutoRotationListener : ::wl_listener {
 369         MockScreenShooterCompositor *parent;
 370     };
 371     ScreenMirrorAutoRotationListener mScreenMirrorAutoRotationListener;
 372 };
 373
 374 class MockScreenShooterClient : public MockClient
 375 {
 376 public:
 377     MockScreenShooterClient()
 378         : bShootEvent(false),
 379           bMirrorStartEvent(false),
 380           bMirrorStopEvent(false),
 381           output_res(nullptr),
 382           shm_res(nullptr),
 383           shm_pool(nullptr),
 384           screenshooter_res(nullptr),
 385           screenmirror_res(nullptr)
 386     {}
 387     MockScreenShooterClient(const struct wl_registry_listener *listener)
 388         : MockClient(listener, this)
 389     {
 390         ds_inf("%s", __func__);
 391
 392         bShootEvent = false;
 393         bMirrorStartEvent = false;
 394         bMirrorStopEvent = false;
 395         output_res = nullptr;
 396         shm_res = nullptr;
 397         shm_pool = nullptr;
 398         screenshooter_res = nullptr;
 399         screenmirror_res = nullptr;
 400     }
 401     ~MockScreenShooterClient()
 402     {
 403         ds_inf("%s", __func__);
 404     }
 405
 406     void SetWlOutput(struct wl_output *global_res)
 407     {
 408         ds_inf("%s", __func__);
 409
 410         output_res = global_res;
 411     }
 412
 413     struct wl_output *GetWlOutput()
 414     {
 415         ds_inf("%s", __func__);
 416
 417         return output_res;
 418     }
 419
 420     void SetWlShm(struct wl_shm *global_res)
 421     {
 422         ds_inf("%s", __func__);
 423
 424         shm_res = global_res;
 425     }
 426
 427     struct wl_shm *GetWlShm()
 428     {
 429         ds_inf("%s", __func__);
 430
 431         return shm_res;
 432     }
 433
 434     void SetWlShmPool(struct wl_shm_pool *_shm_pool)
 435     {
 436         ds_inf("%s", __func__);
 437
 438         shm_pool = _shm_pool;
 439     }
 440
 441     struct wl_shm_pool *GetWlShmPool()
 442     {
 443         ds_inf("%s", __func__);
 444
 445         return shm_pool;
 446     }
 447
 448     void SetTizenScreenShooter(struct tizen_screenshooter *resource)
 449     {
 450         ds_inf("%s", __func__);
 451
 452         screenshooter_res = resource;
 453     }
 454
 455     struct tizen_screenshooter *GetTizenScreenShooter()
 456     {
 457         ds_inf("%s", __func__);
 458
 459         return screenshooter_res;
 460     }
 461
 462
 463     void SetTizenScreenMirror(struct tizen_screenmirror *resource)
 464     {
 465         ds_inf("%s", __func__);
 466
 467         screenmirror_res = resource;
 468     }
 469
 470     struct tizen_screenmirror *GetTizenScreenMirror()
 471     {
 472         ds_inf("%s", __func__);
 473
 474         return screenmirror_res;
 475     }
 476
 477 public:
 478     bool bShootEvent;
 479     bool bMirrorStartEvent;
 480     bool bMirrorStopEvent;
 481
 482 private:
 483     struct wl_output *output_res;
 484     struct wl_shm *shm_res;
 485     struct wl_shm_pool *shm_pool;
 486     struct tizen_screenshooter *screenshooter_res;
 487     struct tizen_screenmirror *screenmirror_res;
 488 };
 489
 490 static void
 491 client_tizen_screenshooter_cb_format(void *data,
 492     struct tizen_screenshooter *screenshooter_res, uint32_t format)
 493 {
 494 }
 495
 496 static void
 497 client_tizen_screenshooter_cb_noti(void *data,
 498     struct tizen_screenshooter *screenshooter_res, uint32_t noti)
 499 {
 500     ds_inf("noti : %d");
 501 }
 502
 503 static void
 504 client_tizen_screenshooter_cb_done(void *data,
 505     struct tizen_screenshooter *screenshooter_res)
 506 {
 507     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 508
 509     client->bShootEvent = true;
 510 }
 511
 512 static const struct
 513 tizen_screenshooter_listener screenshooter_cb_listener = {
 514     client_tizen_screenshooter_cb_format,
 515     client_tizen_screenshooter_cb_noti,
 516     client_tizen_screenshooter_cb_done,
 517 };
 518
 519 static void
 520 _client_tizen_screenshooter_destroy_anonymous_file(int fd)
 521 {
 522     if (fd < 0)
 523         return;
 524
 525     close(fd);
 526 }
 527
 528 static int
 529 _client_tizen_screenshooter_create_anonymous_file(off_t size)
 530 {
 531     static const char tempname[] = "/shooter-XXXXXX";
 532     const char *path;
 533     char *name = NULL;
 534     size_t name_size;
 535     int fd = -1;
 536     int ret = -1;
 537
 538     path = getenv("XDG_RUNTIME_DIR");
 539     if (!path) {
 540         errno = ENOENT;
 541         return -1;
 542     }
 543
 544     name_size = strlen(path) + sizeof(tempname);
 545     name = (char *)malloc(name_size);
 546     if (name == NULL)
 547         return -1;
 548
 549     snprintf(name, name_size, "%s%s", path, tempname);
 550
 551     fd = mkstemp(name);
 552     if (fd >= 0)
 553         unlink(name);
 554
 555     free(name);
 556
 557     if (fd < 0)
 558         return -1;
 559
 560     ret = ftruncate(fd, size);
 561     if (ret < 0) {
 562         close(fd);
 563         return -1;
 564     }
 565
 566     return fd;
 567 }
 568
 569 static struct wl_shm_pool *
 570 _client_tizen_screenshooter_create_shm_pool(struct wl_shm *shm, int size)
 571 {
 572     struct wl_shm_pool *shm_pool = NULL;
 573     void *data = NULL;
 574     int fd = -1;
 575
 576     fd = _client_tizen_screenshooter_create_anonymous_file(size);
 577     if (fd < 0)
 578         goto fail;
 579
 580     data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 581     if (data == NULL)
 582         goto fail;
 583
 584     memset(data, 0xff, size);
 585     munmap(data, size);
 586
 587     shm_pool = wl_shm_create_pool(shm, fd, size);
 588     if (shm_pool == NULL)
 589         goto fail;
 590
 591     _client_tizen_screenshooter_destroy_anonymous_file(fd);
 592
 593     return shm_pool;
 594
 595 fail:
 596     if (fd > 0)
 597         _client_tizen_screenshooter_destroy_anonymous_file(fd);
 598
 599     return NULL;
 600 }
 601
 602 void
 603 _client_tizen_screenshooter_destroy_shm_pool(struct wl_shm_pool *shm_pool)
 604 {
 605     if (!shm_pool)
 606         return;
 607
 608     wl_shm_pool_destroy(shm_pool);
 609 }
 610
 611 static void
 612 client_registry_cb_global(void *data, struct wl_registry *registry,
 613     uint32_t name, const char *interface, uint32_t version)
 614 {
 615     ds_inf("%s", __func__);
 616
 617     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 618     struct tizen_screenshooter *screenshooter_res;
 619     struct wl_shm *shm_res;
 620     struct wl_shm_pool *shm_pool;
 621     struct wl_output *output_res;
 622
 623     if (!strcmp(interface, "wl_shm")) {
 624         shm_res = (struct wl_shm *)wl_registry_bind(registry,
 625             name, &wl_shm_interface, 1);
 626         if (shm_res == nullptr) {
 627             ds_err("wl_registry_bind() failed. wl_shm resource.");
 628             return;
 629         }
 630         shm_pool = _client_tizen_screenshooter_create_shm_pool(shm_res, SHM_BUF_WIDTH * 4 * SHM_BUF_HEIGHT);
 631         if (shm_pool == NULL) {
 632             ds_err("wl_registry_bind() failed. wl_shm_pool create fail.");
 633             wl_shm_destroy(shm_res);
 634             return;
 635         }
 636         client->SetWlShm(shm_res);
 637         client->SetWlShmPool(shm_pool);
 638     }  else if (!strcmp(interface, "wl_output")) {
 639         output_res = (struct wl_output *)wl_registry_bind(registry,
 640             name, &wl_output_interface, 1);
 641         if (output_res == nullptr) {
 642             ds_err("wl_registry_bind() failed. wl_output resource.");
 643             return;
 644         }
 645         client->SetWlOutput(output_res);
 646     } else if (!strcmp(interface, "tizen_screenshooter")) {
 647         screenshooter_res = (struct tizen_screenshooter *)wl_registry_bind(registry,
 648             name, &tizen_screenshooter_interface, TIZEN_SCREENSHOOTER_VERSION);
 649         if (screenshooter_res == nullptr) {
 650             ds_err("wl_registry_bind() failed. tizen_screenshooter resource.");
 651             return;
 652         }
 653         client->SetTizenScreenShooter(screenshooter_res);
 654
 655         tizen_screenshooter_add_listener(screenshooter_res,
 656             &screenshooter_cb_listener, client);
 657     }
 658 }
 659
 660 static void
 661 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 662     uint32_t name)
 663 {
 664     ds_inf("%s", __func__);
 665
 666     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 667     struct wl_shm *shm_res = client->GetWlShm();
 668     struct wl_shm_pool *shm_pool = client->GetWlShmPool();
 669     struct tizen_screenshooter *screenshooter_res = client->GetTizenScreenShooter();
 670     struct tizen_screenmirror *screenmirror_res = client->GetTizenScreenMirror();
 671
 672     if (screenmirror_res)
 673         tizen_screenmirror_destroy(screenmirror_res);
 674     tizen_screenshooter_destroy(screenshooter_res);
 675     _client_tizen_screenshooter_destroy_shm_pool(shm_pool);
 676     wl_shm_destroy(shm_res);
 677 }
 678
 679 static const struct wl_registry_listener registry_listener = {
 680     .global = client_registry_cb_global,
 681     .global_remove = client_registry_cb_global_remove
 682 };
 683
 684 class ScreenShooterTest : public ::testing::Test
 685 {
 686 public:
 687     void SetUp(void) override;
 688     void TearDown(void) override;
 689
 690     MockScreenShooterCompositor *comp;
 691     MockScreenShooterClient *client;
 692     struct wl_output *output_res;
 693     struct wl_shm *shm_res;
 694     struct wl_shm_pool *shm_pool;
 695     struct wl_buffer *buffer_res1;
 696     struct wl_buffer *buffer_res2;
 697     struct wl_buffer *buffer_res3;
 698     struct tizen_screenshooter *screenshooter_res;
 699     struct tizen_screenmirror *screenmirror_res;
 700 };
 701
 702 void
 703 ScreenShooterTest::SetUp(void)
 704 {
 705     //ds_log_init(DS_DBG, NULL);
 706
 707     ds_inf("%s", __func__);
 708
 709     comp = new MockScreenShooterCompositor();
 710     client = new MockScreenShooterClient(&registry_listener);
 711     output_res = client->GetWlOutput();
 712     shm_res = client->GetWlShm();
 713     shm_pool = client->GetWlShmPool();
 714     screenshooter_res = client->GetTizenScreenShooter();
 715
 716     client->RoundTrip();
 717 }
 718
 719 void
 720 ScreenShooterTest::TearDown(void)
 721 {
 722     ds_inf("%s", __func__);
 723
 724     client->RoundTrip();
 725
 726     delete client;
 727     delete comp;
 728 }
 729
 730 TEST_F(ScreenShooterTest, Create_P)
 731 {
 732     EXPECT_TRUE(true);
 733 }
 734
 735 TEST_F(ScreenShooterTest, Req_TizenScreenShooterShot)
 736 {
 737     buffer_res1 = wl_shm_pool_create_buffer(shm_pool, 0,
 738         SHM_BUF_WIDTH, SHM_BUF_HEIGHT, SHM_BUF_STRIDE, SHM_BUF_FORMAT);
 739     tizen_screenshooter_shoot(screenshooter_res, output_res, buffer_res1);
 740     client->RoundTrip();
 741     EXPECT_TRUE(comp->bShoot);
 742     comp->Process();
 743     EXPECT_TRUE(client->bShootEvent);
 744 }