tests/tc_display_policy.cpp

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