tests/tc_clipboard.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4 #include <libds-tizen/clipboard.h>
   5 #include <tizen-extension-client-protocol.h>
   6
   7 #define TIZEN_CLIPBOARD_VERSION 2
   8
   9 class MockClipboardCompositor : public MockCompositor
  10 {
  11 public:
  12     MockClipboardCompositor()
  13         : MockCompositor(&MockClipboardCompositor::TestSetup, this)
  14     {
  15         ds_inf("%s : this(%p)", __func__, this);
  16
  17         // initialize the flags to check
  18         bSurfaceDestroyed = false;
  19
  20         bDestroyed = false;
  21         bShow = false;
  22         bHide = false;
  23         mSetDataOnly = 0;
  24
  25         mAllowed = 0;
  26     }
  27
  28     ~MockClipboardCompositor()
  29     {
  30         ds_inf("%s : this(%p)", __func__, this);
  31     }
  32
  33     static void TestSetup(void *data)
  34     {
  35         MockClipboardCompositor *mockComp =
  36             static_cast<MockClipboardCompositor *>(data);
  37         Compositor *comp = mockComp->compositor;
  38
  39         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  40
  41         // new surface listener
  42         mockComp->mNewSurfaceListener.notify =
  43             MockClipboardCompositor::NewSurfaceCallback;
  44         mockComp->mNewSurfaceListener.parent = mockComp;
  45         ds_compositor_add_new_surface_listener(comp->compositor,
  46                 &mockComp->mNewSurfaceListener);
  47
  48         mockComp->mClipboard = ds_tizen_clipboard_create(comp->display);
  49
  50         // destroy listener
  51         mockComp->mDestroyListener.notify =
  52             MockClipboardCompositor::DestroyCallback;
  53         mockComp->mDestroyListener.parent = mockComp;
  54         ds_tizen_clipboard_add_destroy_listener(mockComp->mClipboard,
  55             &mockComp->mDestroyListener);
  56
  57         // show listener
  58         mockComp->mShowListener.notify =
  59             MockClipboardCompositor::ShowCallback;
  60         mockComp->mShowListener.parent = mockComp;
  61         ds_tizen_clipboard_add_show_listener(mockComp->mClipboard,
  62             &mockComp->mShowListener);
  63
  64         // hide listener
  65         mockComp->mHideListener.notify =
  66             MockClipboardCompositor::HideCallback;
  67         mockComp->mHideListener.parent = mockComp;
  68         ds_tizen_clipboard_add_hide_listener(
  69             mockComp->mClipboard,
  70             &mockComp->mHideListener);
  71
  72         // set_data_only listener
  73         mockComp->mSetDataOnlyListener.notify =
  74             MockClipboardCompositor::SetDataOnlyCallback;
  75         mockComp->mSetDataOnlyListener.parent = mockComp;
  76         ds_tizen_clipboard_add_set_data_only_listener(
  77             mockComp->mClipboard,
  78             &mockComp->mSetDataOnlyListener);
  79     }
  80
  81     static void NewSurfaceCallback(struct wl_listener *listener, void *data)
  82     {
  83         MockClipboardCompositor *mockComp =
  84             reinterpret_cast<NewSurfaceListener *>(listener)->parent;
  85         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  86
  87         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  88
  89         mockComp->mSurface = surface;
  90
  91         // del surface listener
  92         mockComp->mDelSurfaceListener.notify =
  93             MockClipboardCompositor::DelSurfaceCallback;
  94         mockComp->mDelSurfaceListener.parent = mockComp;
  95         ds_surface_add_destroy_listener(surface,
  96             &mockComp->mDelSurfaceListener);
  97     }
  98
  99     static void DelSurfaceCallback(struct wl_listener *listener, void *data)
 100     {
 101         MockClipboardCompositor *mockComp =
 102             reinterpret_cast<DelSurfaceListener *>(listener)->parent;
 103         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
 104
 105         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
 106
 107         if (ds_surface_get_wl_resource(mockComp->mSurface) ==
 108             ds_surface_get_wl_resource(surface)) {
 109             ds_inf("%s: surface is deleted.", __func__);
 110             mockComp->bSurfaceDestroyed = true;
 111         }
 112     }
 113
 114     static void DestroyCallback(struct wl_listener *listener, void *data)
 115     {
 116         ds_inf("%s", __func__);
 117
 118         MockClipboardCompositor *mockComp =
 119             reinterpret_cast<DestroyListener *>(listener)->parent;
 120
 121         mockComp->bDestroyed = true;
 122     }
 123
 124     static void ShowCallback(struct wl_listener *listener, void *data)
 125     {
 126         ds_inf("%s", __func__);
 127
 128         MockClipboardCompositor *mockComp =
 129             reinterpret_cast<ShowListener *>(listener)->parent;
 130         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
 131
 132         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
 133
 134         mockComp->bShow = true;
 135     }
 136
 137     static void HideCallback(struct wl_listener *listener,
 138         void *data)
 139     {
 140         ds_inf("%s", __func__);
 141
 142         MockClipboardCompositor *mockComp =
 143             reinterpret_cast<SetDataOnlyListener *>(listener)->parent;
 144         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
 145
 146         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
 147
 148         mockComp->bHide = true;
 149     }
 150
 151     static void SetDataOnlyCallback(struct wl_listener *listener,
 152         void *data)
 153     {
 154         ds_inf("%s", __func__);
 155
 156         MockClipboardCompositor *mockComp =
 157             reinterpret_cast<HideListener *>(listener)->parent;
 158         struct ds_tizen_clipboard_client *client =
 159             static_cast<struct ds_tizen_clipboard_client *>(data);
 160
 161         ds_inf("%s: mockComp(%p), client(%p)", __func__, mockComp, client);
 162
 163         mockComp->mSetDataOnly =
 164             ds_tizen_clipboard_client_get_data_only(client);
 165
 166         ds_tizen_clipboard_client_send_allowed_data_only(client,
 167             mockComp->mAllowed);
 168     }
 169
 170     void SendDataSelected()
 171     {
 172         ds_inf("%s", __func__);
 173
 174         ds_tizen_clipboard_send_data_selected(mClipboard, mSurface);
 175     }
 176
 177     void SetAllowedDataOnly(uint32_t allowed)
 178     {
 179         ds_inf("%s", __func__);
 180
 181         mAllowed = allowed;
 182     }
 183
 184 public:
 185     bool bSurfaceDestroyed;
 186     bool bDestroyed;
 187     bool bShow;
 188     bool bHide;
 189     uint32_t mSetDataOnly;
 190
 191     uint32_t mAllowed;
 192
 193 private:
 194     struct ds_surface *mSurface;
 195     struct NewSurfaceListener : ::wl_listener {
 196         MockClipboardCompositor *parent;
 197     };
 198     NewSurfaceListener mNewSurfaceListener;
 199     struct DelSurfaceListener : ::wl_listener {
 200         MockClipboardCompositor *parent;
 201     };
 202     DelSurfaceListener mDelSurfaceListener;
 203
 204     struct ds_tizen_clipboard *mClipboard;
 205     struct DestroyListener : ::wl_listener {
 206         MockClipboardCompositor *parent;
 207     };
 208     DestroyListener mDestroyListener;
 209     struct ShowListener : ::wl_listener {
 210         MockClipboardCompositor *parent;
 211     };
 212     ShowListener mShowListener;
 213     struct HideListener : ::wl_listener {
 214         MockClipboardCompositor *parent;
 215     };
 216     HideListener mHideListener;
 217     struct SetDataOnlyListener : ::wl_listener {
 218         MockClipboardCompositor *parent;
 219     };
 220     SetDataOnlyListener mSetDataOnlyListener;
 221 };
 222
 223 class MockClipboardClient : public MockClient
 224 {
 225 public:
 226     MockClipboardClient()
 227         : bDataSelectedEvent(false),
 228           mAllowedDataOnly(0),
 229           compositor_res(nullptr),
 230           tizen_clipboard(nullptr)
 231     {}
 232     MockClipboardClient(const struct wl_registry_listener *listener)
 233         : MockClient(listener, this)
 234     {
 235         ds_inf("%s", __func__);
 236
 237         bDataSelectedEvent = false;
 238         mAllowedDataOnly = 0;
 239     }
 240     ~MockClipboardClient()
 241     {
 242         ds_inf("%s", __func__);
 243     }
 244
 245     void SetWlCompositor(struct wl_compositor *global_res)
 246     {
 247         ds_inf("%s", __func__);
 248
 249         compositor_res = global_res;
 250     }
 251
 252     struct wl_compositor *GetWlCompositor()
 253     {
 254         ds_inf("%s", __func__);
 255
 256         return compositor_res;
 257     }
 258
 259     void SetTizenClipboard(struct tizen_clipboard *global_res)
 260     {
 261         ds_inf("%s", __func__);
 262
 263         tizen_clipboard = global_res;
 264     }
 265
 266     struct tizen_clipboard *GetTizenClipboard()
 267     {
 268         ds_inf("%s", __func__);
 269
 270         return tizen_clipboard;
 271     }
 272
 273 public:
 274     bool bDataSelectedEvent;
 275     uint32_t mAllowedDataOnly;
 276
 277 private:
 278     struct wl_compositor *compositor_res;
 279     struct tizen_clipboard *tizen_clipboard;
 280 };
 281
 282 static void
 283 client_tizen_clipboard_cb_data_selected(void *data,
 284     struct tizen_clipboard *clipboard, struct wl_surface *surface)
 285 {
 286     ds_inf("%s", __func__);
 287
 288     MockClipboardClient *client = static_cast<MockClipboardClient *>(data);
 289
 290     client->bDataSelectedEvent = true;
 291 }
 292
 293 static void
 294 client_tizen_clipboard_cb_allowed_data_only(void *data,
 295     struct tizen_clipboard *clipboard, uint32_t allowed)
 296 {
 297     ds_inf("%s", __func__);
 298
 299     MockClipboardClient *client = static_cast<MockClipboardClient *>(data);
 300
 301     client->mAllowedDataOnly = allowed;
 302 }
 303
 304 static const struct tizen_clipboard_listener clipboard_cb_listener = {
 305     .data_selected = client_tizen_clipboard_cb_data_selected,
 306     .allowed_data_only = client_tizen_clipboard_cb_allowed_data_only
 307 };
 308
 309 static void
 310 client_registry_cb_global(void *data, struct wl_registry *registry,
 311     uint32_t name, const char *interface, uint32_t version)
 312 {
 313     ds_inf("%s", __func__);
 314
 315     MockClipboardClient *client = static_cast<MockClipboardClient *>(data);
 316     struct wl_compositor *compositor_res;
 317     struct tizen_clipboard *tizen_clipboard;
 318
 319     if (!strcmp(interface, "wl_compositor")) {
 320         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
 321             name, &wl_compositor_interface, 1);
 322         if (compositor_res == nullptr) {
 323             ds_err("wl_registry_bind() failed. wl_compositor resource.");
 324             return;
 325         }
 326         client->SetWlCompositor(compositor_res);
 327     } else if (!strcmp(interface, "tizen_clipboard")) {
 328         tizen_clipboard = (struct tizen_clipboard *)wl_registry_bind(registry,
 329             name, &tizen_clipboard_interface, TIZEN_CLIPBOARD_VERSION);
 330         if (tizen_clipboard == nullptr) {
 331             ds_err("wl_registry_bind() failed. tizen_clipboard resource.");
 332             return;
 333         }
 334         client->SetTizenClipboard(tizen_clipboard);
 335
 336         tizen_clipboard_add_listener(tizen_clipboard, &clipboard_cb_listener,
 337             client);
 338     }
 339 }
 340
 341 static void
 342 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 343     uint32_t name)
 344 {
 345     ds_inf("%s", __func__);
 346
 347     MockClipboardClient *client = static_cast<MockClipboardClient *>(data);
 348     struct wl_compositor *compositor_res = client->GetWlCompositor();
 349     struct tizen_clipboard *clipboard_res = client->GetTizenClipboard();
 350
 351     tizen_clipboard_destroy(clipboard_res);
 352     wl_compositor_destroy(compositor_res);
 353 }
 354
 355 static const struct wl_registry_listener registry_listener = {
 356     .global = client_registry_cb_global,
 357     .global_remove = client_registry_cb_global_remove
 358 };
 359
 360 class ClipboardTest : public ::testing::Test
 361 {
 362 public:
 363     void SetUp(void) override;
 364     void TearDown(void) override;
 365
 366     MockClipboardCompositor *comp;
 367     MockClipboardClient *client;
 368     struct wl_compositor *compositor_res;
 369     struct tizen_clipboard *clipboard_res;
 370         struct wl_surface *surface_res;
 371 };
 372
 373 void
 374 ClipboardTest::SetUp(void)
 375 {
 376     //ds_log_init(DS_DBG, NULL);
 377
 378     ds_inf("%s", __func__);
 379
 380     comp = new MockClipboardCompositor();
 381     client = new MockClipboardClient(&registry_listener);
 382     compositor_res = client->GetWlCompositor();
 383     clipboard_res = client->GetTizenClipboard();
 384         surface_res = wl_compositor_create_surface(compositor_res);
 385
 386     client->RoundTrip();
 387 }
 388
 389 void
 390 ClipboardTest::TearDown(void)
 391 {
 392     ds_inf("%s", __func__);
 393
 394     wl_surface_destroy(surface_res);
 395     client->RoundTrip();
 396     EXPECT_TRUE(comp->bSurfaceDestroyed);
 397
 398     delete client;
 399     delete comp;
 400 }
 401
 402 TEST_F(ClipboardTest, Create_P)
 403 {
 404     EXPECT_TRUE(true);
 405 }
 406
 407 TEST_F(ClipboardTest, Req_TizenClipboardShow)
 408 {
 409     tizen_clipboard_show(clipboard_res, surface_res);
 410     client->RoundTrip();
 411     EXPECT_TRUE(comp->bShow);
 412     EXPECT_FALSE(comp->bHide);
 413 }
 414
 415 TEST_F(ClipboardTest, Req_TizenClipboardHide)
 416 {
 417     tizen_clipboard_hide(clipboard_res, surface_res);
 418     client->RoundTrip();
 419     EXPECT_FALSE(comp->bShow);
 420     EXPECT_TRUE(comp->bHide);
 421 }
 422
 423 TEST_F(ClipboardTest, Req_TizenClipboardSetDataOnly)
 424 {
 425     tizen_clipboard_set_data_only(clipboard_res, 1);
 426     client->RoundTrip();
 427     EXPECT_TRUE(comp->mSetDataOnly == 1);
 428 }
 429
 430 TEST_F(ClipboardTest, Ev_TizenClipboardDataSelected)
 431 {
 432     tizen_clipboard_show(clipboard_res, surface_res);
 433     client->RoundTrip();
 434     EXPECT_TRUE(comp->bShow);
 435
 436     comp->SendDataSelected();
 437     comp->Process();
 438
 439     client->RoundTrip();
 440     EXPECT_TRUE(client->bDataSelectedEvent);
 441 }
 442
 443 TEST_F(ClipboardTest, Ev_TizenClipboardAllowedDataOnly)
 444 {
 445     // set the value of allowed to be 1 at compositor
 446     comp->SetAllowedDataOnly(1);
 447
 448     // send a client's request
 449     tizen_clipboard_set_data_only(clipboard_res, 1);
 450     client->RoundTrip();
 451     EXPECT_TRUE(comp->mSetDataOnly);
 452
 453     comp->Process();
 454
 455     client->RoundTrip();
 456     EXPECT_TRUE(client->mAllowedDataOnly == 1);
 457 }