tests/tc_embedded_compositor.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4 #include <libds-tizen/embedded_compositor.h>
   5 #include <libds/surface.h>
   6 #include <tizen-extension-client-protocol.h>
   7
   8 #define TIZEN_EMBEDDED_COMPOSITOR_VERSION 1
   9
  10 class MockEmbeddedCompositorCompositor : public MockCompositor
  11 {
  12 public:
  13     MockEmbeddedCompositorCompositor()
  14         : MockCompositor(&MockEmbeddedCompositorCompositor::TestSetup, this)
  15     {
  16         ds_inf("%s : this(%p)", __func__, this);
  17
  18         // initialize the flags to check
  19         bSurfaceDestroyed = false;
  20
  21         bDestroyed = false;
  22     }
  23
  24     ~MockEmbeddedCompositorCompositor()
  25     {
  26         ds_inf("%s : this(%p)", __func__, this);
  27     }
  28
  29     static void TestSetup(void *data)
  30     {
  31         MockEmbeddedCompositorCompositor *mockComp =
  32             static_cast<MockEmbeddedCompositorCompositor *>(data);
  33         Compositor *comp = mockComp->compositor;
  34
  35         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  36
  37         // new surface listener
  38         mockComp->mNewSurfaceListener.notify =
  39             MockEmbeddedCompositorCompositor::NewSurfaceCallback;
  40         mockComp->mNewSurfaceListener.parent = mockComp;
  41         ds_compositor_add_new_surface_listener(comp->compositor,
  42                 &mockComp->mNewSurfaceListener);
  43
  44         mockComp->mEmbeddedCompositor =
  45             ds_tizen_embedded_compositor_create(comp->display);
  46
  47         // destroy listener
  48         mockComp->mDestroyListener.notify =
  49             MockEmbeddedCompositorCompositor::DestroyCallback;
  50         mockComp->mDestroyListener.parent = mockComp;
  51         ds_tizen_embedded_compositor_add_destroy_listener(mockComp->mEmbeddedCompositor,
  52             &mockComp->mDestroyListener);
  53     }
  54
  55     static void NewSurfaceCallback(struct wl_listener *listener, void *data)
  56     {
  57         MockEmbeddedCompositorCompositor *mockComp =
  58             reinterpret_cast<NewSurfaceListener *>(listener)->parent;
  59         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  60
  61         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  62
  63         mockComp->mSurface = surface;
  64
  65         // del surface listener
  66         mockComp->mDelSurfaceListener.notify =
  67             MockEmbeddedCompositorCompositor::DelSurfaceCallback;
  68         mockComp->mDelSurfaceListener.parent = mockComp;
  69         ds_surface_add_destroy_listener(surface,
  70             &mockComp->mDelSurfaceListener);
  71     }
  72
  73     static void DelSurfaceCallback(struct wl_listener *listener, void *data)
  74     {
  75         MockEmbeddedCompositorCompositor *mockComp =
  76             reinterpret_cast<DelSurfaceListener *>(listener)->parent;
  77         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  78
  79         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  80
  81         if (ds_surface_get_wl_resource(mockComp->mSurface) ==
  82             ds_surface_get_wl_resource(surface)) {
  83             ds_inf("%s: surface is deleted.", __func__);
  84             mockComp->bSurfaceDestroyed = true;
  85         }
  86     }
  87
  88     static void DestroyCallback(struct wl_listener *listener, void *data)
  89     {
  90         ds_inf("%s", __func__);
  91
  92         MockEmbeddedCompositorCompositor *mockComp =
  93             reinterpret_cast<DestroyListener *>(listener)->parent;
  94
  95         mockComp->bDestroyed = true;
  96     }
  97
  98 public:
  99     bool bSurfaceDestroyed;
 100     bool bDestroyed;
 101
 102 private:
 103     struct ds_surface *mSurface;
 104
 105     struct NewSurfaceListener : ::wl_listener {
 106         MockEmbeddedCompositorCompositor *parent;
 107     };
 108     NewSurfaceListener mNewSurfaceListener;
 109
 110     struct DelSurfaceListener : ::wl_listener {
 111         MockEmbeddedCompositorCompositor *parent;
 112     };
 113     DelSurfaceListener mDelSurfaceListener;
 114
 115     struct ds_tizen_embedded_compositor *mEmbeddedCompositor;
 116
 117     struct DestroyListener : ::wl_listener {
 118         MockEmbeddedCompositorCompositor *parent;
 119     };
 120     DestroyListener mDestroyListener;
 121 };
 122
 123 class MockEmbeddedCompositorClient : public MockClient
 124 {
 125 public:
 126     MockEmbeddedCompositorClient()
 127         : bSocketEvent(false),
 128           socket_fd(-1),
 129           compositor_res(nullptr),
 130           tizen_embedded_compositor(nullptr)
 131     {}
 132     MockEmbeddedCompositorClient(const struct wl_registry_listener *listener)
 133         : MockClient(listener, this)
 134     {
 135         ds_inf("%s", __func__);
 136
 137         bSocketEvent = false;
 138         socket_fd = -1;
 139     }
 140     ~MockEmbeddedCompositorClient()
 141     {
 142         ds_inf("%s", __func__);
 143     }
 144
 145     void SetWlCompositor(struct wl_compositor *global_res)
 146     {
 147         ds_inf("%s", __func__);
 148
 149         compositor_res = global_res;
 150     }
 151
 152     struct wl_compositor *GetWlCompositor()
 153     {
 154         ds_inf("%s", __func__);
 155
 156         return compositor_res;
 157     }
 158
 159     void SetTizenEmbeddedCompositor(struct tizen_embedded_compositor *global_res)
 160     {
 161         ds_inf("%s", __func__);
 162
 163         tizen_embedded_compositor = global_res;
 164     }
 165
 166     struct tizen_embedded_compositor *GetTizenEmbeddedCompositor()
 167     {
 168         ds_inf("%s", __func__);
 169
 170         return tizen_embedded_compositor;
 171     }
 172
 173 public:
 174     bool bSocketEvent;
 175     int32_t socket_fd;
 176
 177 private:
 178     struct wl_compositor *compositor_res;
 179     struct tizen_embedded_compositor *tizen_embedded_compositor;
 180 };
 181
 182 static void
 183 client_tizen_embedded_compositor_cb_socket(void *data,
 184     struct tizen_embedded_compositor *embedded_compositor, int32_t socket_fd)
 185 {
 186     ds_inf("%s", __func__);
 187
 188     MockEmbeddedCompositorClient *client = static_cast<MockEmbeddedCompositorClient *>(data);
 189
 190     client->bSocketEvent = true;
 191     client->socket_fd = socket_fd;
 192 }
 193
 194 static const struct tizen_embedded_compositor_listener embedded_compositor_cb_listener = {
 195     .socket = client_tizen_embedded_compositor_cb_socket,
 196 };
 197
 198 static void
 199 client_registry_cb_global(void *data, struct wl_registry *registry,
 200     uint32_t name, const char *interface, uint32_t version)
 201 {
 202     ds_inf("%s", __func__);
 203
 204     MockEmbeddedCompositorClient *client = static_cast<MockEmbeddedCompositorClient *>(data);
 205     struct wl_compositor *compositor_res;
 206     struct tizen_embedded_compositor *embedded_compositor_res;
 207
 208     if (!strcmp(interface, "wl_compositor")) {
 209         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
 210             name, &wl_compositor_interface, 1);
 211         if (compositor_res == nullptr) {
 212             ds_err("wl_registry_bind() failed. wl_compositor resource.");
 213             return;
 214         }
 215         client->SetWlCompositor(compositor_res);
 216     } else if (!strcmp(interface, "tizen_embedded_compositor")) {
 217         embedded_compositor_res = (struct tizen_embedded_compositor *)wl_registry_bind(registry,
 218             name, &tizen_embedded_compositor_interface, TIZEN_EMBEDDED_COMPOSITOR_VERSION);
 219         if (embedded_compositor_res == nullptr) {
 220             ds_err("wl_registry_bind() failed. tizen_embedded_compositor resource.");
 221             return;
 222         }
 223         client->SetTizenEmbeddedCompositor(embedded_compositor_res);
 224
 225         tizen_embedded_compositor_add_listener(embedded_compositor_res,
 226             &embedded_compositor_cb_listener, client);
 227     }
 228 }
 229
 230 static void
 231 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 232     uint32_t name)
 233 {
 234     ds_inf("%s", __func__);
 235
 236     MockEmbeddedCompositorClient *client = static_cast<MockEmbeddedCompositorClient *>(data);
 237     struct wl_compositor *compositor_res = client->GetWlCompositor();
 238     struct tizen_embedded_compositor *embedded_compositor_res = client->GetTizenEmbeddedCompositor();
 239
 240     tizen_embedded_compositor_destroy(embedded_compositor_res);
 241     wl_compositor_destroy(compositor_res);
 242 }
 243
 244 static const struct wl_registry_listener registry_listener = {
 245     .global = client_registry_cb_global,
 246     .global_remove = client_registry_cb_global_remove
 247 };
 248
 249 class EmbeddedCompositorTest : public ::testing::Test
 250 {
 251 public:
 252     void SetUp(void) override;
 253     void TearDown(void) override;
 254
 255     MockEmbeddedCompositorCompositor *comp;
 256     MockEmbeddedCompositorClient *client;
 257     struct wl_compositor *compositor_res;
 258     struct tizen_embedded_compositor *embedded_compositor_res;
 259     struct wl_surface *surface_res;
 260 };
 261
 262 void
 263 EmbeddedCompositorTest::SetUp(void)
 264 {
 265     //ds_log_init(DS_DBG, NULL);
 266
 267     ds_inf("%s", __func__);
 268
 269     comp = new MockEmbeddedCompositorCompositor();
 270     client = new MockEmbeddedCompositorClient(&registry_listener);
 271     compositor_res = client->GetWlCompositor();
 272     embedded_compositor_res = client->GetTizenEmbeddedCompositor();
 273     surface_res = wl_compositor_create_surface(compositor_res);
 274
 275     client->RoundTrip();
 276 }
 277
 278 void
 279 EmbeddedCompositorTest::TearDown(void)
 280 {
 281     ds_inf("%s", __func__);
 282
 283     wl_surface_destroy(surface_res);
 284     client->RoundTrip();
 285     EXPECT_TRUE(comp->bSurfaceDestroyed);
 286
 287     delete client;
 288     delete comp;
 289 }
 290
 291 TEST_F(EmbeddedCompositorTest, Create_P)
 292 {
 293     EXPECT_TRUE(true);
 294 }
 295
 296 TEST_F(EmbeddedCompositorTest, Ev_GetSocket)
 297 {
 298     tizen_embedded_compositor_get_socket(embedded_compositor_res);
 299     client->RoundTrip();
 300
 301     comp->Process();
 302     EXPECT_TRUE(client->bSocketEvent);
 303     EXPECT_TRUE(client->socket_fd >= 0)
 304         << "get socket_fd : " << client->socket_fd << std::endl;
 305 }