tests/tc_hwc.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4 #include <libds-tizen/hwc.h>
   5 #include <tizen-hwc-client-protocol.h>
   6
   7 #define TIZEN_HWC_VERSION 1
   8
   9 class MockHwcCompositor : public MockCompositor
  10 {
  11 public:
  12     MockHwcCompositor()
  13         : MockCompositor(&MockHwcCompositor::TestSetup, this)
  14     {
  15         ds_inf("%s : this(%p)", __func__, this);
  16
  17         bHwcDestroyed = false;
  18         bSurfaceDestroyed = false;
  19     }
  20
  21     ~MockHwcCompositor()
  22     {
  23         ds_inf("%s : this(%p)", __func__, this);
  24     }
  25
  26     static void TestSetup(void *data)
  27     {
  28         MockHwcCompositor *mockComp =
  29             static_cast<MockHwcCompositor *>(data);
  30         Compositor *comp = mockComp->compositor;
  31
  32         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  33
  34         // new surface listener
  35         mockComp->mNewSurfaceListener.notify =
  36             MockHwcCompositor::NewSurfaceCallback;
  37         mockComp->mNewSurfaceListener.parent = mockComp;
  38         ds_compositor_add_new_surface_listener(comp->compositor,
  39                 &mockComp->mNewSurfaceListener);
  40
  41         mockComp->mHwc =
  42             ds_tizen_hwc_create(comp->display);
  43
  44         // destroy listener
  45         mockComp->mHwcDestroyListener.notify =
  46             MockHwcCompositor::HwcDestroyCallback;
  47         mockComp->mHwcDestroyListener.parent = mockComp;
  48         ds_tizen_hwc_add_destroy_listener(mockComp->mHwc,
  49             &mockComp->mHwcDestroyListener);
  50
  51         // add_ignore_output_transform listener
  52         mockComp->mHwcNewCommitFeedbackListener.notify =
  53             MockHwcCompositor::HwcNewCommitFeedbackCallback;
  54         mockComp->mHwcNewCommitFeedbackListener.parent = mockComp;
  55         ds_tizen_hwc_add_new_commit_feedback_listener(
  56             mockComp->mHwc,
  57             &mockComp->mHwcNewCommitFeedbackListener);
  58     }
  59
  60     static void NewSurfaceCallback(struct wl_listener *listener, void *data)
  61     {
  62         MockHwcCompositor *mockComp =
  63             reinterpret_cast<NewSurfaceListener *>(listener)->parent;
  64         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  65
  66         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  67
  68         mockComp->mSurface = surface;
  69
  70         // del surface listener
  71         mockComp->mDelSurfaceListener.notify =
  72             MockHwcCompositor::DelSurfaceCallback;
  73         mockComp->mDelSurfaceListener.parent = mockComp;
  74         ds_surface_add_destroy_listener(surface,
  75             &mockComp->mDelSurfaceListener);
  76     }
  77
  78     static void DelSurfaceCallback(struct wl_listener *listener, void *data)
  79     {
  80         MockHwcCompositor *mockComp =
  81             reinterpret_cast<DelSurfaceListener *>(listener)->parent;
  82         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
  83
  84         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
  85
  86         if (ds_surface_get_wl_resource(mockComp->mSurface) ==
  87             ds_surface_get_wl_resource(surface)) {
  88             ds_inf("%s: surface is deleted.", __func__);
  89             mockComp->bSurfaceDestroyed = true;
  90         }
  91     }
  92
  93     static void HwcDestroyCallback(struct wl_listener *listener, void *data)
  94     {
  95         ds_inf("%s", __func__);
  96
  97         MockHwcCompositor *mockComp =
  98             reinterpret_cast<HwcDestroyListener *>(listener)->parent;
  99
 100         mockComp->bHwcDestroyed = true;
 101     }
 102
 103     static void HwcNewCommitFeedbackCallback(struct wl_listener *listener,
 104         void *data)
 105     {
 106         ds_inf("%s", __func__);
 107
 108         MockHwcCompositor *mockComp =
 109             reinterpret_cast<HwcNewCommitFeedbackListener *>(listener)->parent;
 110         struct ds_tizen_hwc_commit_feedback *commitFeedback =
 111             static_cast<struct ds_tizen_hwc_commit_feedback *>(data);
 112
 113         ds_inf("%s: mockComp(%p), commitFeedback(%p)", __func__, mockComp, commitFeedback);
 114
 115         mockComp->mCommitFeedback = commitFeedback;
 116         mockComp->mSurface =
 117             ds_tizen_hwc_commit_feedback_get_surface(mockComp->mCommitFeedback);
 118
 119         mockComp->mHwcCommitFeedbackDestroyListener.notify =
 120             MockHwcCompositor::HwcCommitFeedbackDestroyCallback;
 121         mockComp->mHwcCommitFeedbackDestroyListener.parent = mockComp;
 122         ds_tizen_hwc_commit_feedback_add_destroy_listener(mockComp->mCommitFeedback,
 123             &mockComp->mHwcCommitFeedbackDestroyListener);
 124     }
 125
 126     static void HwcCommitFeedbackDestroyCallback(struct wl_listener *listener,
 127         void *data)
 128     {
 129         ds_inf("%s", __func__);
 130
 131         MockHwcCompositor *mockComp =
 132             reinterpret_cast<HwcCommitFeedbackDestroyListener *>(listener)->parent;
 133         struct ds_tizen_hwc_commit_feedback *commitFeedback =
 134             static_cast<struct ds_tizen_hwc_commit_feedback *>(data);
 135
 136         ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, commitFeedback);
 137
 138         if (mockComp->mCommitFeedback == commitFeedback) {
 139             ds_inf("%s: commitFeedback is deleted.", __func__);
 140         }
 141     }
 142
 143     void SendHwcCommitFeedbackCommitted(void)
 144     {
 145         ds_inf("%s", __func__);
 146
 147         ds_tizen_hwc_commit_feedback_send_committed(mCommitFeedback);
 148     }
 149
 150     void SendHwcCommitFeedbackDiscarded(void)
 151     {
 152         ds_inf("%s", __func__);
 153
 154         ds_tizen_hwc_commit_feedback_send_discarded(mCommitFeedback);
 155     }
 156
 157 public:
 158     bool bHwcDestroyed;
 159     bool bSurfaceDestroyed;
 160
 161 private:
 162     struct ds_tizen_hwc *mHwc;
 163
 164     struct HwcDestroyListener : ::wl_listener {
 165         MockHwcCompositor *parent;
 166     };
 167     HwcDestroyListener mHwcDestroyListener;
 168
 169     struct ds_surface *mSurface;
 170
 171     struct NewSurfaceListener : ::wl_listener {
 172         MockHwcCompositor *parent;
 173     };
 174     NewSurfaceListener mNewSurfaceListener;
 175
 176     struct DelSurfaceListener : ::wl_listener {
 177         MockHwcCompositor *parent;
 178     };
 179     DelSurfaceListener mDelSurfaceListener;
 180
 181     struct ds_tizen_hwc_commit_feedback *mCommitFeedback;
 182
 183     struct HwcNewCommitFeedbackListener : ::wl_listener {
 184         MockHwcCompositor *parent;
 185     };
 186     HwcNewCommitFeedbackListener mHwcNewCommitFeedbackListener;
 187
 188     struct HwcCommitFeedbackDestroyListener : ::wl_listener {
 189         MockHwcCompositor *parent;
 190     };
 191     HwcCommitFeedbackDestroyListener mHwcCommitFeedbackDestroyListener;
 192 };
 193
 194 class MockHwcClient : public MockClient
 195 {
 196 public:
 197     MockHwcClient()
 198         : bCommittedEvent(false),
 199           bDiscardedEvent(false),
 200           compositorRes(nullptr),
 201           tizenHwcRes(nullptr)
 202     {}
 203     MockHwcClient(const struct wl_registry_listener *listener)
 204         : MockClient(listener, this)
 205     {
 206         ds_inf("%s", __func__);
 207     }
 208     ~MockHwcClient()
 209     {
 210         ds_inf("%s", __func__);
 211     }
 212
 213     void SetWlCompositor(struct wl_compositor *globalRes)
 214     {
 215         ds_inf("%s", __func__);
 216
 217         compositorRes = globalRes;
 218     }
 219
 220     struct wl_compositor *GetWlCompositor()
 221     {
 222         ds_inf("%s", __func__);
 223
 224         return compositorRes;
 225     }
 226
 227     void SetTizenHwc(struct tizen_hwc *resource)
 228     {
 229         ds_inf("%s", __func__);
 230
 231         tizenHwcRes = resource;
 232     }
 233
 234     struct tizen_hwc *GetTizenHwc()
 235     {
 236         ds_inf("%s", __func__);
 237
 238         return tizenHwcRes;
 239     }
 240
 241 public:
 242     bool bCommittedEvent;
 243     bool bDiscardedEvent;
 244 private:
 245     struct wl_compositor *compositorRes;
 246     struct tizen_hwc *tizenHwcRes;
 247 };
 248
 249 static void
 250 client_registry_cb_global(void *data, struct wl_registry *registry,
 251     uint32_t name, const char *interface, uint32_t version)
 252 {
 253     ds_inf("%s", __func__);
 254
 255     MockHwcClient *client = static_cast<MockHwcClient *>(data);
 256     struct wl_compositor *compositor_res;
 257     struct tizen_hwc *tizen_hwc_res;
 258
 259     if (!strcmp(interface, "wl_compositor")) {
 260         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
 261             name, &wl_compositor_interface, 1);
 262         if (compositor_res == nullptr) {
 263             ds_err("wl_registry_bind() failed. wl_compositor resource.");
 264             return;
 265         }
 266         client->SetWlCompositor(compositor_res);
 267     } else if (!strcmp(interface, "tizen_hwc")) {
 268         tizen_hwc_res = (struct tizen_hwc *)wl_registry_bind(registry,
 269             name, &tizen_hwc_interface, TIZEN_HWC_VERSION);
 270         if (tizen_hwc_res == nullptr) {
 271             ds_err("wl_registry_bind() failed. tizen_hwc resource.");
 272             return;
 273         }
 274         client->SetTizenHwc(tizen_hwc_res);
 275     }
 276 }
 277
 278 static void
 279 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 280     uint32_t name)
 281 {
 282     ds_inf("%s", __func__);
 283
 284     MockHwcClient *client = static_cast<MockHwcClient *>(data);
 285     struct wl_compositor *compositor_res = client->GetWlCompositor();
 286     struct tizen_hwc *tizen_hwc_res = client->GetTizenHwc();
 287
 288     tizen_hwc_destroy(tizen_hwc_res);
 289     wl_compositor_destroy(compositor_res);
 290 }
 291
 292 static const struct wl_registry_listener registry_listener = {
 293     .global = client_registry_cb_global,
 294     .global_remove = client_registry_cb_global_remove
 295 };
 296
 297 class HwcTest : public ::testing::Test
 298 {
 299 public:
 300     void SetUp(void) override;
 301     void TearDown(void) override;
 302
 303     MockHwcCompositor *comp;
 304     MockHwcClient *client;
 305     struct wl_compositor *compositorRes;
 306     struct tizen_hwc *tizenHwcRes;
 307     struct wl_surface *surfaceRes;
 308     struct tizen_hwc_commit_feedback *tizenHwcCommitFeedbackRes;
 309 };
 310
 311 static void
 312 tizen_hwc_commit_feedback_cb_committed(void *data,
 313     struct tizen_hwc_commit_feedback *hwc_commit_feedback,
 314     uint32_t serial)
 315 {
 316     ds_inf("%s", __func__);
 317
 318     MockHwcClient *client = static_cast<MockHwcClient *>(data);
 319
 320     client->bCommittedEvent = true;
 321
 322     tizen_hwc_commit_feedback_destroy(hwc_commit_feedback);
 323 }
 324
 325 static void
 326 tizen_hwc_commit_feedback_cb_discarded(void *data,
 327     struct tizen_hwc_commit_feedback *hwc_commit_feedback,
 328     uint32_t serial)
 329 {
 330     ds_inf("%s", __func__);
 331
 332     MockHwcClient *client = static_cast<MockHwcClient *>(data);
 333
 334     client->bDiscardedEvent = true;
 335
 336     tizen_hwc_commit_feedback_destroy(hwc_commit_feedback);
 337 }
 338
 339 static const struct tizen_hwc_commit_feedback_listener tizen_hwc_commit_feedback_cb_listener = {
 340     .committed = tizen_hwc_commit_feedback_cb_committed,
 341     .discarded = tizen_hwc_commit_feedback_cb_discarded,
 342 };
 343
 344 void
 345 HwcTest::SetUp(void)
 346 {
 347     ds_inf("%s", __func__);
 348
 349     comp = new MockHwcCompositor();
 350     client = new MockHwcClient(&registry_listener);
 351     compositorRes = client->GetWlCompositor();
 352     tizenHwcRes = client->GetTizenHwc();
 353     surfaceRes = wl_compositor_create_surface(compositorRes);
 354
 355     tizenHwcCommitFeedbackRes =
 356         tizen_hwc_create_commit_feedback(tizenHwcRes, surfaceRes, 1);
 357
 358     tizen_hwc_commit_feedback_add_listener(tizenHwcCommitFeedbackRes,
 359         &tizen_hwc_commit_feedback_cb_listener, client);
 360
 361     client->RoundTrip();
 362 }
 363
 364 void
 365 HwcTest::TearDown(void)
 366 {
 367     ds_inf("%s", __func__);
 368
 369     wl_surface_destroy(surfaceRes);
 370     client->RoundTrip();
 371     EXPECT_TRUE(comp->bSurfaceDestroyed);
 372
 373     delete client;
 374     delete comp;
 375 }
 376
 377 TEST_F(HwcTest, Create_P)
 378 {
 379     EXPECT_TRUE(true);
 380 }
 381
 382 TEST_F(HwcTest, Ev_TizenHwcCommitFeedbackCommitted)
 383 {
 384     comp->SendHwcCommitFeedbackCommitted();
 385     comp->Process();
 386
 387     client->RoundTrip();
 388     EXPECT_TRUE(client->bCommittedEvent);
 389 }
 390
 391 TEST_F(HwcTest, Ev_TizenHwcCommitFeedbackDiscared)
 392 {
 393     comp->SendHwcCommitFeedbackDiscarded();
 394     comp->Process();
 395
 396     client->RoundTrip();
 397     EXPECT_TRUE(client->bDiscardedEvent);
 398 }