tests/tc_renderer.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4 #include <libds-tizen/renderer.h>
   5 #include <tizen-extension-client-protocol.h>
   6
   7 #define TIZEN_RENDERER_VERSION 1
   8
   9 class MockRendererCompositor : public MockCompositor
  10 {
  11 public:
  12     MockRendererCompositor()
  13         : MockCompositor(&MockRendererCompositor::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         bGetRendererSurface = false;
  22         bDestroyRendererInfo = false;
  23     }
  24
  25     ~MockRendererCompositor()
  26     {
  27         ds_inf("%s : this(%p)", __func__, this);
  28     }
  29
  30     static void TestSetup(void *data)
  31     {
  32         MockRendererCompositor *mockComp =
  33             static_cast<MockRendererCompositor *>(data);
  34         Compositor *comp = mockComp->compositor;
  35
  36         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  37
  38         // new surface listener
  39         mockComp->mNewSurfaceListener.notify =
  40             MockRendererCompositor::NewSurfaceCallback;
  41         mockComp->mNewSurfaceListener.parent = mockComp;
  42         ds_compositor_add_new_surface_listener(comp->compositor,
  43                 &mockComp->mNewSurfaceListener);
  44
  45         mockComp->mRenderer =
  46             ds_tizen_renderer_create(comp->display);
  47
  48         // destroy listener
  49         mockComp->mDestroyListener.notify =
  50             MockRendererCompositor::DestroyCallback;
  51         mockComp->mDestroyListener.parent = mockComp;
  52         ds_tizen_renderer_add_destroy_listener(mockComp->mRenderer,
  53             &mockComp->mDestroyListener);
  54
  55         // get_flusher_info listener
  56         mockComp->mGetFlusherInfoListener.notify =
  57             MockRendererCompositor::GetRendererSurfaceCallback;
  58         mockComp->mGetFlusherInfoListener.parent = mockComp;
  59         ds_tizen_renderer_add_get_renderer_surface_info_listener(
  60             mockComp->mRenderer,
  61             &mockComp->mGetFlusherInfoListener);
  62     }
  63
  64     static void NewSurfaceCallback(struct wl_listener *listener, void *data)
  65     {
  66         MockRendererCompositor *mockComp =
  67             reinterpret_cast<NewSurfaceListener *>(listener)->parent;
  68         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  69
  70         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  71
  72         mockComp->mSurface = surface;
  73
  74         // del surface listener
  75         mockComp->mDelSurfaceListener.notify =
  76             MockRendererCompositor::DelSurfaceCallback;
  77         mockComp->mDelSurfaceListener.parent = mockComp;
  78         ds_surface_add_destroy_listener(surface,
  79             &mockComp->mDelSurfaceListener);
  80     }
  81
  82     static void DelSurfaceCallback(struct wl_listener *listener, void *data)
  83     {
  84         MockRendererCompositor *mockComp =
  85             reinterpret_cast<DelSurfaceListener *>(listener)->parent;
  86         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  87
  88         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  89
  90         if (ds_surface_get_wl_resource(mockComp->mSurface) ==
  91             ds_surface_get_wl_resource(surface)) {
  92             ds_inf("%s: surface is deleted.", __func__);
  93             mockComp->bSurfaceDestroyed = true;
  94         }
  95     }
  96
  97     static void DestroyCallback(struct wl_listener *listener, void *data)
  98     {
  99         ds_inf("%s", __func__);
 100
 101         MockRendererCompositor *mockComp =
 102             reinterpret_cast<DestroyListener *>(listener)->parent;
 103
 104         mockComp->bDestroyed = true;
 105     }
 106
 107     static void GetRendererSurfaceCallback(struct wl_listener *listener,
 108         void *data)
 109     {
 110         ds_inf("%s", __func__);
 111
 112         MockRendererCompositor *mockComp =
 113             reinterpret_cast<GetFlusherInfoListener *>(listener)->parent;
 114         struct ds_tizen_renderer_info *info =
 115             static_cast<struct ds_tizen_renderer_info *>(data);
 116
 117         ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, info);
 118
 119         mockComp->bGetRendererSurface = true;
 120
 121         mockComp->mInfo = info;
 122         mockComp->mSurface =
 123             ds_tizen_renderer_info_get_surface(mockComp->mInfo);
 124
 125         // info destroy listener
 126         mockComp->mRendererInfoDestroyListener.notify =
 127             MockRendererCompositor::RendererInfoDestroyCallback;
 128         mockComp->mRendererInfoDestroyListener.parent = mockComp;
 129         ds_tizen_renderer_info_add_destroy_listener(mockComp->mInfo,
 130             &mockComp->mRendererInfoDestroyListener);
 131     }
 132
 133     static void RendererInfoDestroyCallback(struct wl_listener *listener,
 134         void *data)
 135     {
 136         ds_inf("%s", __func__);
 137
 138         MockRendererCompositor *mockComp =
 139             reinterpret_cast<FlusherInfoDestroyListener *>(listener)->parent;
 140         struct ds_tizen_renderer_info *info =
 141             static_cast<struct ds_tizen_renderer_info *>(data);
 142
 143         ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, info);
 144
 145         if (mockComp->mInfo == info) {
 146             ds_inf("%s: info is deleted.", __func__);
 147             mockComp->bDestroyRendererInfo = true;
 148         }
 149     }
 150
 151     void SendRendererInfoRedraw()
 152     {
 153         ds_inf("%s", __func__);
 154
 155         ds_tizen_renderer_info_send_redraw(mInfo);
 156     }
 157
 158 public:
 159     bool bSurfaceDestroyed;
 160     bool bDestroyed;
 161     bool bGetRendererSurface;
 162     bool bDestroyRendererInfo;
 163
 164 private:
 165     struct ds_tizen_renderer_info *mInfo;
 166     struct ds_surface *mSurface;
 167
 168     struct NewSurfaceListener : ::wl_listener {
 169         MockRendererCompositor *parent;
 170     };
 171     NewSurfaceListener mNewSurfaceListener;
 172
 173     struct DelSurfaceListener : ::wl_listener {
 174         MockRendererCompositor *parent;
 175     };
 176     DelSurfaceListener mDelSurfaceListener;
 177
 178     struct ds_tizen_renderer *mRenderer;
 179
 180     struct DestroyListener : ::wl_listener {
 181         MockRendererCompositor *parent;
 182     };
 183     DestroyListener mDestroyListener;
 184
 185     struct GetFlusherInfoListener : ::wl_listener {
 186         MockRendererCompositor *parent;
 187     };
 188     GetFlusherInfoListener mGetFlusherInfoListener;
 189
 190     struct FlusherInfoDestroyListener : ::wl_listener {
 191         MockRendererCompositor *parent;
 192     };
 193     FlusherInfoDestroyListener mRendererInfoDestroyListener;
 194 };
 195
 196 class MockRendererClient : public MockClient
 197 {
 198 public:
 199     MockRendererClient()
 200         : bRedrawEvent(false),
 201           compositor_res(nullptr),
 202           renderer_res(nullptr)
 203     {}
 204     MockRendererClient(const struct wl_registry_listener *listener)
 205         : MockClient(listener, this)
 206     {
 207         ds_inf("%s", __func__);
 208
 209         bRedrawEvent = false;
 210     }
 211     ~MockRendererClient()
 212     {
 213         ds_inf("%s", __func__);
 214     }
 215
 216     void SetWlCompositor(struct wl_compositor *global_res)
 217     {
 218         ds_inf("%s", __func__);
 219
 220         compositor_res = global_res;
 221     }
 222
 223     struct wl_compositor *GetWlCompositor()
 224     {
 225         ds_inf("%s", __func__);
 226
 227         return compositor_res;
 228     }
 229
 230     void SetTizenRenderer(struct tizen_renderer *resource)
 231     {
 232         ds_inf("%s", __func__);
 233
 234         renderer_res = resource;
 235     }
 236
 237     struct tizen_renderer *GetTizenRenderer()
 238     {
 239         ds_inf("%s", __func__);
 240
 241         return renderer_res;
 242     }
 243
 244 public:
 245     bool bRedrawEvent;
 246
 247 private:
 248     struct wl_compositor *compositor_res;
 249     struct tizen_renderer *renderer_res;
 250 };
 251
 252 static void
 253 client_registry_cb_global(void *data, struct wl_registry *registry,
 254     uint32_t name, const char *interface, uint32_t version)
 255 {
 256     ds_inf("%s", __func__);
 257
 258     MockRendererClient *client = static_cast<MockRendererClient *>(data);
 259     struct wl_compositor *compositor_res;
 260     struct tizen_renderer *renderer_res;
 261
 262     if (!strcmp(interface, "wl_compositor")) {
 263         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
 264             name, &wl_compositor_interface, 1);
 265         if (compositor_res == nullptr) {
 266             ds_err("wl_registry_bind() failed. wl_compositor resource.");
 267             return;
 268         }
 269         client->SetWlCompositor(compositor_res);
 270     } else if (!strcmp(interface, "tizen_renderer")) {
 271         renderer_res = (struct tizen_renderer *)wl_registry_bind(registry,
 272             name, &tizen_renderer_interface, TIZEN_RENDERER_VERSION);
 273         if (renderer_res == nullptr) {
 274             ds_err("wl_registry_bind() failed. tizen_renderer resource.");
 275             return;
 276         }
 277         client->SetTizenRenderer(renderer_res);
 278     }
 279 }
 280
 281 static void
 282 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 283     uint32_t name)
 284 {
 285     ds_inf("%s", __func__);
 286
 287     MockRendererClient *client = static_cast<MockRendererClient *>(data);
 288     struct wl_compositor *compositor_res = client->GetWlCompositor();
 289     struct tizen_renderer *renderer_res = client->GetTizenRenderer();
 290
 291     tizen_renderer_destroy(renderer_res);
 292     wl_compositor_destroy(compositor_res);
 293 }
 294
 295 static const struct wl_registry_listener registry_listener = {
 296     .global = client_registry_cb_global,
 297     .global_remove = client_registry_cb_global_remove
 298 };
 299
 300 static void
 301 client_tizen_renderer_surface_cb_redraw_request(void *data,
 302     struct tizen_renderer_surface *renderer_surface_res)
 303 {
 304     ds_inf("%s", __func__);
 305
 306     MockRendererClient *client = static_cast<MockRendererClient *>(data);
 307
 308     client->bRedrawEvent = true;
 309 }
 310
 311 static const struct
 312 tizen_renderer_surface_listener renderer_surface_cb_listener = {
 313     .redraw_request = client_tizen_renderer_surface_cb_redraw_request,
 314 };
 315
 316 class RendererTest : public ::testing::Test
 317 {
 318 public:
 319     void SetUp(void) override;
 320     void TearDown(void) override;
 321
 322     MockRendererCompositor *comp;
 323     MockRendererClient *client;
 324     struct wl_compositor *compositor_res;
 325     struct tizen_renderer *renderer_res;
 326     struct wl_surface *surface_res;
 327     struct tizen_renderer_surface *renderer_surface_res;
 328 };
 329
 330 void
 331 RendererTest::SetUp(void)
 332 {
 333     //ds_log_init(DS_DBG, NULL);
 334
 335     ds_inf("%s", __func__);
 336
 337     comp = new MockRendererCompositor();
 338     client = new MockRendererClient(&registry_listener);
 339     compositor_res = client->GetWlCompositor();
 340     renderer_res = client->GetTizenRenderer();
 341     surface_res = wl_compositor_create_surface(compositor_res);
 342
 343     renderer_surface_res =
 344         tizen_renderer_get_renderer_surface(renderer_res, surface_res);
 345
 346     tizen_renderer_surface_add_listener(renderer_surface_res,
 347         &renderer_surface_cb_listener, client);
 348
 349     client->RoundTrip();
 350 }
 351
 352 void
 353 RendererTest::TearDown(void)
 354 {
 355     ds_inf("%s", __func__);
 356
 357     tizen_renderer_surface_destroy(renderer_surface_res);
 358     client->RoundTrip();
 359     EXPECT_TRUE(comp->bDestroyRendererInfo);
 360
 361     wl_surface_destroy(surface_res);
 362     client->RoundTrip();
 363     EXPECT_TRUE(comp->bSurfaceDestroyed);
 364
 365     delete client;
 366     delete comp;
 367 }
 368
 369 TEST_F(RendererTest, Create_P)
 370 {
 371     EXPECT_TRUE(true);
 372     EXPECT_TRUE(comp->bGetRendererSurface);
 373 }
 374
 375 TEST_F(RendererTest, Ev_TizenRendererSurfaceRedraw)
 376 {
 377     comp->SendRendererInfoRedraw();
 378     comp->Process();
 379
 380     client->RoundTrip();
 381     EXPECT_TRUE(client->bRedrawEvent);
 382 }