tests/tc_policy.cpp

   1 #include "tc_main.h"
   2 #include "mockclient.h"
   3 #include "mockcompositor.h"
   4 #include <libds-tizen/policy.h>
   5 #include <tizen-extension-client-protocol.h>
   6
   7 #define TIZEN_POLICY_VERSION 11
   8
   9 class MockPolicyVisibility
  10 {
  11 public:
  12     MockPolicyVisibility()
  13       : mVisibility(nullptr)
  14     {}
  15     MockPolicyVisibility(struct ds_tizen_policy_visibility *visibility)
  16       : mVisibility(visibility)
  17     {
  18         ds_inf("%s", __func__);
  19
  20         // policy_surface destroy listener
  21         mDestroyListener.notify = MockPolicyVisibility::DestroyCallback;
  22         mDestroyListener.parent = this;
  23         ds_tizen_policy_visibility_add_destroy_listener(visibility, &mDestroyListener);
  24     }
  25     ~MockPolicyVisibility()
  26     {
  27         ds_inf("%s", __func__);
  28
  29         if (mDestroyListener.notify) {
  30             wl_list_remove(&mDestroyListener.link);
  31             mDestroyListener.notify = nullptr;
  32         }
  33     }
  34
  35     static void DestroyCallback(struct wl_listener *listener, void *data)
  36     {
  37         MockPolicyVisibility *policyVisibility =
  38             reinterpret_cast<DestroyListener *>(listener)->parent;
  39         struct ds_tizen_policy_visibility *visibility =
  40             static_cast<struct ds_tizen_policy_visibility *>(data);
  41
  42         ds_inf("%s: policyVisibility(%p), visibility(%p)", __func__,
  43             policyVisibility, visibility);
  44
  45         wl_list_remove(&policyVisibility->mDestroyListener.link);
  46         policyVisibility->mDestroyListener.notify = nullptr;
  47
  48         policyVisibility->bDestroyed = true;
  49     }
  50
  51     void SendNotify(enum ds_tizen_policy_visibility_type type)
  52     {
  53         ds_tizen_policy_visibility_send_notify(mVisibility, type);
  54     }
  55
  56     void SendChanged(enum ds_tizen_policy_visibility_type type, uint32_t option)
  57     {
  58         ds_tizen_policy_visibility_send_changed(mVisibility, type, option);
  59     }
  60
  61 public:
  62     bool bDestroyed;
  63
  64 private:
  65     struct ds_tizen_policy_visibility *mVisibility;
  66
  67     struct DestroyListener : ::wl_listener {
  68         MockPolicyVisibility *parent;
  69     };
  70     DestroyListener mDestroyListener;
  71 };
  72
  73 class MockPolicyPosition
  74 {
  75 public:
  76     MockPolicyPosition()
  77       : mX(-1),
  78         mY(-1),
  79         mPosition(nullptr)
  80     {}
  81     MockPolicyPosition(struct ds_tizen_policy_position *position)
  82       : mX(-1),
  83         mY(-1),
  84         mPosition(position)
  85     {
  86         ds_inf("%s", __func__);
  87
  88         // policy_surface destroy listener
  89         mDestroyListener.notify = MockPolicyPosition::DestroyCallback;
  90         mDestroyListener.parent = this;
  91         ds_tizen_policy_position_add_destroy_listener(position, &mDestroyListener);
  92
  93         // position listener
  94         mSetListener.notify = MockPolicyPosition::SetCallback;
  95         mSetListener.parent = this;
  96         ds_tizen_policy_position_add_set_listener(position, &mSetListener);
  97     }
  98     ~MockPolicyPosition()
  99     {
 100         ds_inf("%s", __func__);
 101
 102         if (mSetListener.notify) {
 103             wl_list_remove(&mSetListener.link);
 104             mSetListener.notify = nullptr;
 105         }
 106
 107         if (mDestroyListener.notify) {
 108             wl_list_remove(&mDestroyListener.link);
 109             mDestroyListener.notify = nullptr;
 110         }
 111     }
 112
 113     static void DestroyCallback(struct wl_listener *listener, void *data)
 114     {
 115         MockPolicyPosition *policyPosition =
 116             reinterpret_cast<DestroyListener *>(listener)->parent;
 117         struct ds_tizen_policy_position *position =
 118             static_cast<struct ds_tizen_policy_position *>(data);
 119
 120         ds_inf("%s: policyPosition(%p), position(%p)", __func__,
 121             policyPosition, position);
 122
 123         wl_list_remove(&policyPosition->mSetListener.link);
 124         policyPosition->mSetListener.notify = nullptr;
 125
 126         wl_list_remove(&policyPosition->mDestroyListener.link);
 127         policyPosition->mDestroyListener.notify = nullptr;
 128
 129         policyPosition->bDestroyed = true;
 130     }
 131
 132     static void SetCallback(struct wl_listener *listener, void *data)
 133     {
 134         MockPolicyPosition *mockPosition =
 135             reinterpret_cast<SetListener *>(listener)->parent;
 136         struct ds_tizen_event_policy_position_set *event =
 137             static_cast<struct ds_tizen_event_policy_position_set *>(data);
 138
 139         EXPECT_TRUE(mockPosition->mPosition == event->position);
 140         mockPosition->mX = event->x;
 141         mockPosition->mY = event->y;
 142     }
 143
 144     void SendChanged(int32_t x, int32_t y)
 145     {
 146         ds_tizen_policy_position_send_changed(mPosition, x, y);
 147         mX = x;
 148         mY = y;
 149     }
 150
 151 public:
 152     bool bDestroyed;
 153
 154     int32_t mX;
 155     int32_t mY;
 156
 157 private:
 158     struct ds_tizen_policy_position *mPosition;
 159
 160     struct DestroyListener : ::wl_listener {
 161         MockPolicyPosition *parent;
 162     };
 163     DestroyListener mDestroyListener;
 164
 165     struct SetListener : ::wl_listener {
 166         MockPolicyPosition *parent;
 167     };
 168     SetListener mSetListener;
 169 };
 170
 171 class MockPolicySubsurfaceWatcher
 172 {
 173 public:
 174     MockPolicySubsurfaceWatcher()
 175       : mSubsurfaceWatcher(nullptr)
 176     {}
 177     MockPolicySubsurfaceWatcher(struct ds_tizen_policy_subsurface_watcher *subsurface_watcher)
 178       : mSubsurfaceWatcher(subsurface_watcher)
 179     {
 180         ds_inf("%s", __func__);
 181
 182         // policy_surface destroy listener
 183         mDestroyListener.notify = MockPolicySubsurfaceWatcher::DestroyCallback;
 184         mDestroyListener.parent = this;
 185         ds_tizen_policy_subsurface_watcher_add_destroy_listener(subsurface_watcher, &mDestroyListener);
 186     }
 187     ~MockPolicySubsurfaceWatcher()
 188     {
 189         ds_inf("%s", __func__);
 190
 191         if (mDestroyListener.notify) {
 192             wl_list_remove(&mDestroyListener.link);
 193             mDestroyListener.notify = nullptr;
 194         }
 195     }
 196
 197     static void DestroyCallback(struct wl_listener *listener, void *data)
 198     {
 199         MockPolicySubsurfaceWatcher *policySubsurfaceWatcher =
 200             reinterpret_cast<DestroyListener *>(listener)->parent;
 201         struct ds_tizen_policy_subsurface_watcher *subsurface_watcher =
 202             static_cast<struct ds_tizen_policy_subsurface_watcher *>(data);
 203
 204         ds_inf("%s: policySubsurfaceWatcher(%p), subsurface_watcher(%p)", __func__,
 205             policySubsurfaceWatcher, subsurface_watcher);
 206
 207         wl_list_remove(&policySubsurfaceWatcher->mDestroyListener.link);
 208         policySubsurfaceWatcher->mDestroyListener.notify = nullptr;
 209
 210         policySubsurfaceWatcher->bDestroyed = true;
 211     }
 212
 213 #if 0 // TODO:
 214     void SendMessage(enum ds_tizen_policy_subsurface_watcher_message message)
 215     {
 216         ds_tizen_policy_subsurface_watcher_send_message(mSubsurfaceWatcher, message);
 217     }
 218 #endif
 219
 220 public:
 221     bool bDestroyed;
 222
 223 private:
 224     struct ds_tizen_policy_subsurface_watcher *mSubsurfaceWatcher;
 225
 226     struct DestroyListener : ::wl_listener {
 227         MockPolicySubsurfaceWatcher *parent;
 228     };
 229     DestroyListener mDestroyListener;
 230 };
 231
 232 class MockPolicySurface
 233 {
 234 public:
 235     MockPolicySurface(struct ds_tizen_policy_surface *policy_surface)
 236       : mPolicySurface(policy_surface),
 237         mPolicyVisibility(nullptr),
 238         mPolicyPosition(nullptr),
 239         mPolicySubsurfaceWatcher(nullptr)
 240     {
 241         ds_inf("%s", __func__);
 242
 243         // policy_surface destroy listener
 244         mDestroyListener.notify = MockPolicySurface::DestroyCallback;
 245         mDestroyListener.parent = this;
 246         ds_tizen_policy_surface_add_destroy_listener(policy_surface, &mDestroyListener);
 247
 248         // policy_surface listeners
 249         mNewVisibilityListener.notify = MockPolicySurface::NewVisibilityCallback;
 250         mNewVisibilityListener.parent = this;
 251         ds_tizen_policy_surface_add_new_visibility_listener(policy_surface,
 252             &mNewVisibilityListener);
 253
 254         mGetPositionListener.notify = MockPolicySurface::GetPositionCallback;
 255         mGetPositionListener.parent = this;
 256         ds_tizen_policy_surface_add_get_position_listener(policy_surface,
 257             &mGetPositionListener);
 258
 259         mActivateListener.notify = MockPolicySurface::ActivateCallback;
 260         mActivateListener.parent = this;
 261         ds_tizen_policy_surface_add_activate_listener(policy_surface,
 262             &mActivateListener);
 263
 264         mRaiseListener.notify = MockPolicySurface::RaiseCallback;
 265         mRaiseListener.parent = this;
 266         ds_tizen_policy_surface_add_raise_listener(policy_surface,
 267             &mRaiseListener);
 268
 269         mLowerListener.notify = MockPolicySurface::LowerCallback;
 270         mLowerListener.parent = this;
 271         ds_tizen_policy_surface_add_lower_listener(policy_surface,
 272             &mLowerListener);
 273
 274         mSetFocusSkipListener.notify = MockPolicySurface::SetFocusSkipCallback;
 275         mSetFocusSkipListener.parent = this;
 276         ds_tizen_policy_surface_add_set_focus_skip_listener(policy_surface,
 277             &mSetFocusSkipListener);
 278
 279         mUnsetFocusSkipListener.notify = MockPolicySurface::UnsetFocusSkipCallback;
 280         mUnsetFocusSkipListener.parent = this;
 281         ds_tizen_policy_surface_add_unset_focus_skip_listener(policy_surface,
 282             &mUnsetFocusSkipListener);
 283
 284         mSetRoleListener.notify = MockPolicySurface::SetRoleCallback;
 285         mSetRoleListener.parent = this;
 286         ds_tizen_policy_surface_add_set_role_listener(policy_surface,
 287             &mSetRoleListener);
 288
 289         mWindowTypeListener.notify = MockPolicySurface::WindowTypeCallback;
 290         mWindowTypeListener.parent = this;
 291         ds_tizen_policy_surface_add_set_window_type_listener(policy_surface,
 292             &mWindowTypeListener);
 293
 294         mSetConformantListener.notify = MockPolicySurface::SetConformantCallback;
 295         mSetConformantListener.parent = this;
 296         ds_tizen_policy_surface_add_set_conformant_listener(policy_surface,
 297             &mSetConformantListener);
 298
 299         mUnsetConformantListener.notify = MockPolicySurface::UnsetConformantCallback;
 300         mUnsetConformantListener.parent = this;
 301         ds_tizen_policy_surface_add_unset_conformant_listener(policy_surface,
 302             &mUnsetConformantListener);
 303
 304         mGetConformantListener.notify = MockPolicySurface::GetConformantCallback;
 305         mGetConformantListener.parent = this;
 306         ds_tizen_policy_surface_add_get_conformant_listener(policy_surface,
 307             &mGetConformantListener);
 308
 309         mSetNotificationLevelListener.notify = MockPolicySurface::SetNotificationLevelCallback;
 310         mSetNotificationLevelListener.parent = this;
 311         ds_tizen_policy_surface_add_set_notification_level_listener(policy_surface,
 312             &mSetNotificationLevelListener);
 313
 314         mSetWindowScreenModeListener.notify = MockPolicySurface::SetWindowScreenModeCallback;
 315         mSetWindowScreenModeListener.parent = this;
 316         ds_tizen_policy_surface_add_set_window_screen_mode_listener(policy_surface,
 317             &mSetWindowScreenModeListener);
 318
 319         mGetSubsurfaceListener.notify = MockPolicySurface::GetSubsurfaceCallback;
 320         mGetSubsurfaceListener.parent = this;
 321         ds_tizen_policy_surface_add_get_subsurface_listener(policy_surface,
 322             &mGetSubsurfaceListener);
 323
 324         mIconifyListener.notify = MockPolicySurface::IconifyCallback;
 325         mIconifyListener.parent = this;
 326         ds_tizen_policy_surface_add_iconify_listener(policy_surface,
 327             &mIconifyListener);
 328
 329         mUniconifyListener.notify = MockPolicySurface::UniconifyCallback;
 330         mUniconifyListener.parent = this;
 331         ds_tizen_policy_surface_add_uniconify_listener(policy_surface,
 332             &mUniconifyListener);
 333
 334         mAddAuxHintListener.notify = MockPolicySurface::AddAuxHintCallback;
 335         mAddAuxHintListener.parent = this;
 336         ds_tizen_policy_surface_add_add_aux_hint_listener(policy_surface,
 337             &mAddAuxHintListener);
 338
 339         mChangeAuxHintListener.notify = MockPolicySurface::ChangeAuxHintCallback;
 340         mChangeAuxHintListener.parent = this;
 341         ds_tizen_policy_surface_add_change_aux_hint_listener(policy_surface,
 342             &mChangeAuxHintListener);
 343
 344         mDeleteAuxHintListener.notify = MockPolicySurface::DeleteAuxHintCallback;
 345         mDeleteAuxHintListener.parent = this;
 346         ds_tizen_policy_surface_add_delete_aux_hint_listener(policy_surface,
 347             &mDeleteAuxHintListener);
 348
 349         mGetSupportAuxHintsListener.notify = MockPolicySurface::GetSupportAuxHintsCallback;
 350         mGetSupportAuxHintsListener.parent = this;
 351         ds_tizen_policy_surface_add_get_supported_aux_hints_listener(policy_surface,
 352             &mGetSupportAuxHintsListener);
 353
 354         mSetFloatingModeListener.notify = MockPolicySurface::SetFloatingModeCallback;
 355         mSetFloatingModeListener.parent = this;
 356         ds_tizen_policy_surface_add_set_floating_mode_listener(policy_surface,
 357             &mSetFloatingModeListener);
 358
 359         mUnsetFloatingModeListener.notify = MockPolicySurface::UnsetFloatingModeCallback;
 360         mUnsetFloatingModeListener.parent = this;
 361         ds_tizen_policy_surface_add_unset_floating_mode_listener(policy_surface,
 362             &mUnsetFloatingModeListener);
 363
 364         mSetStackModeListener.notify = MockPolicySurface::SetStackModeCallback;
 365         mSetStackModeListener.parent = this;
 366         ds_tizen_policy_surface_add_set_stack_mode_listener(policy_surface,
 367             &mSetStackModeListener);
 368
 369         mGetSubsurfaceWatcherListener.notify = MockPolicySurface::GetSubsurfaceWatcherCallback;
 370         mGetSubsurfaceWatcherListener.parent = this;
 371         ds_tizen_policy_surface_add_get_subsurface_watcher_listener(policy_surface,
 372             &mGetSubsurfaceWatcherListener);
 373
 374         mSetParentListener.notify = MockPolicySurface::SetParentCallback;
 375         mSetParentListener.parent = this;
 376         ds_tizen_policy_surface_add_set_parent_listener(policy_surface,
 377             &mSetParentListener);
 378
 379         mAckConformantRegionListener.notify = MockPolicySurface::AckConformantRegionCallback;
 380         mAckConformantRegionListener.parent = this;
 381         ds_tizen_policy_surface_add_ack_conformant_region_listener(policy_surface,
 382             &mAckConformantRegionListener);
 383
 384         mSetVideoListener.notify = MockPolicySurface::SetVideoCallback;
 385         mSetVideoListener.parent = this;
 386         ds_tizen_policy_surface_add_set_video_listener(policy_surface,
 387             &mSetVideoListener);
 388
 389         mShowListener.notify = MockPolicySurface::ShowCallback;
 390         mShowListener.parent = this;
 391         ds_tizen_policy_surface_add_show_listener(policy_surface,
 392             &mShowListener);
 393
 394         mHideListener.notify = MockPolicySurface::HideCallback;
 395         mHideListener.parent = this;
 396         ds_tizen_policy_surface_add_hide_listener(policy_surface,
 397             &mHideListener);
 398
 399         mSetParentWithBelowListener.notify = MockPolicySurface::SetParentWithBelowCallback;
 400         mSetParentWithBelowListener.parent = this;
 401         ds_tizen_policy_surface_add_set_parent_with_below_listener(policy_surface,
 402             &mSetParentWithBelowListener);
 403     }
 404     ~MockPolicySurface()
 405     {
 406         ds_inf("%s", __func__);
 407
 408         if (mNewVisibilityListener.notify) {
 409             wl_list_remove(&mNewVisibilityListener.link);
 410             mNewVisibilityListener.notify = nullptr;
 411         }
 412
 413         if (mDestroyListener.notify) {
 414             wl_list_remove(&mDestroyListener.link);
 415             mDestroyListener.notify = nullptr;
 416         }
 417
 418         if (mPolicySubsurfaceWatcher)
 419             delete mPolicySubsurfaceWatcher;
 420
 421         if (mPolicyPosition)
 422             delete mPolicyPosition;
 423
 424         if (mPolicyVisibility)
 425             delete mPolicyVisibility;
 426     }
 427
 428     static void DestroyCallback(struct wl_listener *listener, void *data)
 429     {
 430         MockPolicySurface *policySurface =
 431             reinterpret_cast<DestroyListener *>(listener)->parent;
 432         struct ds_tizen_policy_surface *policy_surface =
 433             static_cast<struct ds_tizen_policy_surface *>(data);
 434
 435         ds_inf("%s: policySurface(%p), policy_surface(%p)", __func__, policySurface, policy_surface);
 436
 437         wl_list_remove(&policySurface->mDestroyListener.link);
 438         policySurface->mDestroyListener.notify = nullptr;
 439
 440         policySurface->bDestroyed = true;
 441     }
 442
 443     static void NewVisibilityCallback(struct wl_listener *listener, void *data)
 444     {
 445         MockPolicySurface *policySurface =
 446             reinterpret_cast<NewVisibilityListener *>(listener)->parent;
 447         struct ds_tizen_event_policy_surface_new_visibility *event =
 448             static_cast<struct ds_tizen_event_policy_surface_new_visibility *>(data);
 449
 450         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 451         EXPECT_TRUE(event->visibility != NULL);
 452
 453         policySurface->bNewVisibility = true;
 454
 455         MockPolicyVisibility *policyVisibility =
 456             new MockPolicyVisibility(event->visibility);
 457
 458         policySurface->mPolicyVisibility = policyVisibility;
 459     }
 460
 461     static void GetPositionCallback(struct wl_listener *listener, void *data)
 462     {
 463         MockPolicySurface *policySurface =
 464             reinterpret_cast<GetPositionListener *>(listener)->parent;
 465         struct ds_tizen_event_policy_surface_get_position *event =
 466             static_cast<struct ds_tizen_event_policy_surface_get_position *>(data);
 467
 468         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 469         EXPECT_TRUE(event->position != NULL);
 470
 471         policySurface->bGetPosition = true;
 472
 473         MockPolicyPosition *policyPosition =
 474             new MockPolicyPosition(event->position);
 475
 476         policySurface->mPolicyPosition = policyPosition;
 477     }
 478
 479     static void ActivateCallback(struct wl_listener *listener, void *data)
 480     {
 481         MockPolicySurface *policySurface =
 482             reinterpret_cast<ActivateListener *>(listener)->parent;
 483         struct ds_tizen_event_policy_surface_activate *event =
 484             static_cast<struct ds_tizen_event_policy_surface_activate *>(data);
 485
 486         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 487
 488         policySurface->bActivate = true;
 489     }
 490
 491     static void RaiseCallback(struct wl_listener *listener, void *data)
 492     {
 493         MockPolicySurface *policySurface =
 494             reinterpret_cast<RaiseListener *>(listener)->parent;
 495         struct ds_tizen_event_policy_surface_raise *event =
 496             static_cast<struct ds_tizen_event_policy_surface_raise *>(data);
 497
 498         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 499
 500         policySurface->bRaise = true;
 501     }
 502
 503     static void LowerCallback(struct wl_listener *listener, void *data)
 504     {
 505         MockPolicySurface *policySurface =
 506             reinterpret_cast<LowerListener *>(listener)->parent;
 507         struct ds_tizen_event_policy_surface_lower *event =
 508             static_cast<struct ds_tizen_event_policy_surface_lower *>(data);
 509
 510         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 511
 512         policySurface->bLower = true;
 513     }
 514
 515     static void SetFocusSkipCallback(struct wl_listener *listener, void *data)
 516     {
 517         MockPolicySurface *policySurface =
 518             reinterpret_cast<SetFocusSkipListener *>(listener)->parent;
 519         struct ds_tizen_event_policy_surface_set_focus_skip *event =
 520             static_cast<struct ds_tizen_event_policy_surface_set_focus_skip *>(data);
 521
 522         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 523
 524         policySurface->bSetFocusSkip = true;
 525     }
 526
 527     static void UnsetFocusSkipCallback(struct wl_listener *listener, void *data)
 528     {
 529         MockPolicySurface *policySurface =
 530             reinterpret_cast<UnsetFocusSkipListener *>(listener)->parent;
 531         struct ds_tizen_event_policy_surface_unset_focus_skip *event =
 532             static_cast<struct ds_tizen_event_policy_surface_unset_focus_skip *>(data);
 533
 534         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 535
 536         policySurface->bSetFocusSkip = false;
 537     }
 538
 539     static void SetRoleCallback(struct wl_listener *listener, void *data)
 540     {
 541         MockPolicySurface *policySurface =
 542             reinterpret_cast<SetRoleListener *>(listener)->parent;
 543         struct ds_tizen_event_policy_surface_set_role *event =
 544             static_cast<struct ds_tizen_event_policy_surface_set_role *>(data);
 545
 546         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 547         policySurface->mRole = event->role; // char -> string
 548     }
 549
 550     static void WindowTypeCallback(struct wl_listener *listener, void *data)
 551     {
 552         MockPolicySurface *policySurface =
 553             reinterpret_cast<WindowTypeListener *>(listener)->parent;
 554         struct ds_tizen_event_policy_surface_set_window_type *event =
 555             static_cast<struct ds_tizen_event_policy_surface_set_window_type *>(data);
 556
 557         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 558
 559         policySurface->mWinType = event->win_type;
 560     }
 561
 562     static void SetConformantCallback(struct wl_listener *listener, void *data)
 563     {
 564         MockPolicySurface *policySurface =
 565             reinterpret_cast<SetConformantListener *>(listener)->parent;
 566         struct ds_tizen_event_policy_surface_set_conformant *event =
 567             static_cast<struct ds_tizen_event_policy_surface_set_conformant *>(data);
 568
 569         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 570
 571         policySurface->bSetConformant = true;
 572     }
 573
 574     static void UnsetConformantCallback(struct wl_listener *listener, void *data)
 575     {
 576         MockPolicySurface *policySurface =
 577             reinterpret_cast<UnsetConformantListener *>(listener)->parent;
 578         struct ds_tizen_event_policy_surface_unset_conformant *event =
 579             static_cast<struct ds_tizen_event_policy_surface_unset_conformant *>(data);
 580
 581         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 582
 583         policySurface->bSetConformant = false;
 584     }
 585
 586     static void GetConformantCallback(struct wl_listener *listener, void *data)
 587     {
 588         MockPolicySurface *policySurface =
 589             reinterpret_cast<GetConformantListener *>(listener)->parent;
 590         struct ds_tizen_event_policy_surface_get_conformant *event =
 591             static_cast<struct ds_tizen_event_policy_surface_get_conformant *>(data);
 592
 593         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 594
 595         policySurface->bGetConformant = true;
 596     }
 597
 598     static void SetNotificationLevelCallback(struct wl_listener *listener, void *data)
 599     {
 600         MockPolicySurface *policySurface =
 601             reinterpret_cast<SetNotificationLevelListener *>(listener)->parent;
 602         struct ds_tizen_event_policy_surface_set_notification_level *event =
 603             static_cast<struct ds_tizen_event_policy_surface_set_notification_level *>(data);
 604
 605         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 606
 607         policySurface->mNotificationLevel = event->level;
 608     }
 609
 610     static void SetWindowScreenModeCallback(struct wl_listener *listener, void *data)
 611     {
 612         MockPolicySurface *policySurface =
 613             reinterpret_cast<SetWindowScreenModeListener *>(listener)->parent;
 614         struct ds_tizen_event_policy_surface_set_window_screen_mode *event =
 615             static_cast<struct ds_tizen_event_policy_surface_set_window_screen_mode *>(data);
 616
 617         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 618
 619         policySurface->mWindowScreenMode = event->mode;
 620     }
 621
 622     static void GetSubsurfaceCallback(struct wl_listener *listener, void *data)
 623     {
 624         MockPolicySurface *policySurface =
 625             reinterpret_cast<GetSubsurfaceListener *>(listener)->parent;
 626         struct ds_tizen_event_policy_surface_get_subsurface *event =
 627             static_cast<struct ds_tizen_event_policy_surface_get_subsurface *>(data);
 628
 629         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 630
 631         policySurface->mParentUniversalId = event->parent_universal_id;
 632     }
 633
 634     static void IconifyCallback(struct wl_listener *listener, void *data)
 635     {
 636         MockPolicySurface *policySurface =
 637             reinterpret_cast<IconifyListener *>(listener)->parent;
 638         struct ds_tizen_event_policy_surface_iconify *event =
 639             static_cast<struct ds_tizen_event_policy_surface_iconify *>(data);
 640
 641         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 642
 643         policySurface->bIconify = true;
 644     }
 645
 646     static void UniconifyCallback(struct wl_listener *listener, void *data)
 647     {
 648         MockPolicySurface *policySurface =
 649             reinterpret_cast<UniconifyListener *>(listener)->parent;
 650         struct ds_tizen_event_policy_surface_uniconify *event =
 651             static_cast<struct ds_tizen_event_policy_surface_uniconify *>(data);
 652
 653         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 654
 655         policySurface->bIconify = false;
 656     }
 657
 658     static void AddAuxHintCallback(struct wl_listener *listener, void *data)
 659     {
 660         MockPolicySurface *policySurface =
 661             reinterpret_cast<AddAuxHintListener *>(listener)->parent;
 662         struct ds_tizen_event_policy_surface_add_aux_hint *event =
 663             static_cast<struct ds_tizen_event_policy_surface_add_aux_hint *>(data);
 664
 665         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 666
 667         policySurface->mAuxHintId = event->id;
 668         policySurface->mAuxHintName = event->name;
 669         policySurface->mAuxHintValue = event->value;
 670     }
 671
 672     static void ChangeAuxHintCallback(struct wl_listener *listener, void *data)
 673     {
 674         MockPolicySurface *policySurface =
 675             reinterpret_cast<ChangeAuxHintListener *>(listener)->parent;
 676         struct ds_tizen_event_policy_surface_change_aux_hint *event =
 677             static_cast<struct ds_tizen_event_policy_surface_change_aux_hint *>(data);
 678
 679         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 680
 681         policySurface->mAuxHintId = event->id;
 682         policySurface->mAuxHintValue = event->value;
 683     }
 684
 685     static void DeleteAuxHintCallback(struct wl_listener *listener, void *data)
 686     {
 687         MockPolicySurface *policySurface =
 688             reinterpret_cast<DeleteAuxHintListener *>(listener)->parent;
 689         struct ds_tizen_event_policy_surface_delete_aux_hint *event =
 690             static_cast<struct ds_tizen_event_policy_surface_delete_aux_hint *>(data);
 691
 692         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 693
 694         policySurface->mAuxHintId = event->id;
 695     }
 696
 697     static void GetSupportAuxHintsCallback(struct wl_listener *listener, void *data)
 698     {
 699         MockPolicySurface *policySurface =
 700             reinterpret_cast<GetSupportAuxHintsListener *>(listener)->parent;
 701         struct ds_tizen_event_policy_surface_get_supported_aux_hints *event =
 702             static_cast<struct ds_tizen_event_policy_surface_get_supported_aux_hints *>(data);
 703
 704         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 705
 706         policySurface->bGetSupportedAuxHints = true;
 707     }
 708
 709     static void SetFloatingModeCallback(struct wl_listener *listener, void *data)
 710     {
 711         MockPolicySurface *policySurface =
 712             reinterpret_cast<SetFloatingModeListener *>(listener)->parent;
 713         struct ds_tizen_event_policy_surface_set_floating_mode *event =
 714             static_cast<struct ds_tizen_event_policy_surface_set_floating_mode *>(data);
 715
 716         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 717
 718         policySurface->bSetFloatingMode = true;
 719     }
 720
 721     static void UnsetFloatingModeCallback(struct wl_listener *listener, void *data)
 722     {
 723         MockPolicySurface *policySurface =
 724             reinterpret_cast<UnsetFloatingModeListener *>(listener)->parent;
 725         struct ds_tizen_event_policy_surface_unset_floating_mode *event =
 726             static_cast<struct ds_tizen_event_policy_surface_unset_floating_mode *>(data);
 727
 728         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 729
 730         policySurface->bSetFloatingMode = false;
 731     }
 732
 733     static void SetStackModeCallback(struct wl_listener *listener, void *data)
 734     {
 735         MockPolicySurface *policySurface =
 736             reinterpret_cast<SetStackModeListener *>(listener)->parent;
 737         struct ds_tizen_event_policy_surface_set_stack_mode *event =
 738             static_cast<struct ds_tizen_event_policy_surface_set_stack_mode *>(data);
 739
 740         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 741
 742         policySurface->mStackMode = event->mode;
 743     }
 744
 745     static void GetSubsurfaceWatcherCallback(struct wl_listener *listener, void *data)
 746     {
 747         MockPolicySurface *policySurface =
 748             reinterpret_cast<GetSubsurfaceWatcherListener *>(listener)->parent;
 749         struct ds_tizen_event_policy_surface_get_subsurface_watcher *event =
 750             static_cast<struct ds_tizen_event_policy_surface_get_subsurface_watcher *>(data);
 751
 752         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 753         EXPECT_TRUE(event->subsurface_watcher != NULL);
 754
 755         policySurface->bGetSubsurfaceWatcher = true;
 756
 757         MockPolicySubsurfaceWatcher *policySubsurfaceWatcher =
 758             new MockPolicySubsurfaceWatcher(event->subsurface_watcher);
 759
 760         policySurface->mPolicySubsurfaceWatcher = policySubsurfaceWatcher;
 761     }
 762
 763     static void SetParentCallback(struct wl_listener *listener, void *data)
 764     {
 765         MockPolicySurface *policySurface =
 766             reinterpret_cast<SetParentListener *>(listener)->parent;
 767         struct ds_tizen_event_policy_surface_set_parent *event =
 768             static_cast<struct ds_tizen_event_policy_surface_set_parent *>(data);
 769
 770         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 771
 772         policySurface->mParentSurface = event->parent_surface;
 773     }
 774
 775     static void AckConformantRegionCallback(struct wl_listener *listener, void *data)
 776     {
 777         MockPolicySurface *policySurface =
 778             reinterpret_cast<AckConformantRegionListener *>(listener)->parent;
 779         struct ds_tizen_event_policy_surface_ack_conformant_region *event =
 780             static_cast<struct ds_tizen_event_policy_surface_ack_conformant_region *>(data);
 781
 782         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 783
 784         policySurface->mSerial = event->serial;
 785     }
 786
 787     static void SetVideoCallback(struct wl_listener *listener, void *data)
 788     {
 789         MockPolicySurface *policySurface =
 790             reinterpret_cast<SetVideoListener *>(listener)->parent;
 791         struct ds_tizen_event_policy_surface_set_video *event =
 792             static_cast<struct ds_tizen_event_policy_surface_set_video *>(data);
 793
 794         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 795
 796         policySurface->bVideo = event->video;
 797     }
 798
 799     static void ShowCallback(struct wl_listener *listener, void *data)
 800     {
 801         MockPolicySurface *policySurface =
 802             reinterpret_cast<ShowListener *>(listener)->parent;
 803         struct ds_tizen_event_policy_surface_show *event =
 804             static_cast<struct ds_tizen_event_policy_surface_show *>(data);
 805
 806         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 807
 808         policySurface->bShow = true;
 809     }
 810
 811     static void HideCallback(struct wl_listener *listener, void *data)
 812     {
 813         MockPolicySurface *policySurface =
 814             reinterpret_cast<HideListener *>(listener)->parent;
 815         struct ds_tizen_event_policy_surface_hide *event =
 816             static_cast<struct ds_tizen_event_policy_surface_hide *>(data);
 817
 818         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 819
 820         policySurface->bHide = true;
 821     }
 822
 823     static void SetParentWithBelowCallback(struct wl_listener *listener, void *data)
 824     {
 825         MockPolicySurface *policySurface =
 826             reinterpret_cast<SetParentWithBelowListener *>(listener)->parent;
 827         struct ds_tizen_event_policy_surface_set_parent_with_below *event =
 828             static_cast<struct ds_tizen_event_policy_surface_set_parent_with_below *>(data);
 829
 830         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 831
 832         policySurface->mParentSurface = event->parent_surface;
 833     }
 834
 835     uint32_t GetSurfaceResId()
 836     {
 837         struct ds_surface *surface = ds_tizen_policy_surface_get_surface(mPolicySurface);
 838         struct wl_resource *surface_res = ds_surface_get_wl_resource(surface);
 839
 840         return wl_resource_get_id(surface_res);
 841     }
 842
 843     MockPolicyVisibility *NewVisibility()
 844     {
 845         return mPolicyVisibility;
 846     }
 847
 848     MockPolicyPosition *GetPosition()
 849     {
 850         return mPolicyPosition;
 851     }
 852
 853     MockPolicySubsurfaceWatcher*GetSubsurfaceWatcher()
 854     {
 855         return mPolicySubsurfaceWatcher;
 856     }
 857
 858     void SendConformant(bool active)
 859     {
 860         ds_inf("%s", __func__);
 861
 862         ds_tizen_policy_surface_send_conformant(mPolicySurface, active);
 863     }
 864
 865     void SendConformantArea(enum ds_tizen_policy_conformant_part part,
 866         bool visible, int32_t x, int32_t y, int32_t w, int32_t h)
 867     {
 868         ds_inf("%s", __func__);
 869
 870         ds_tizen_policy_surface_send_conformant_area(mPolicySurface, part, visible,
 871             x, y, w, h);
 872     }
 873
 874     void SendNotificationDone(
 875         enum ds_tizen_policy_notification_level notification_level,
 876         enum ds_tizen_policy_error_state error_state)
 877     {
 878         ds_inf("%s", __func__);
 879
 880         ds_tizen_policy_surface_send_notification_done(mPolicySurface, notification_level,
 881             error_state);
 882     }
 883
 884     void SendWindowScreenModeDone(
 885         enum ds_tizen_policy_window_screen_mode window_screen_mode,
 886         enum ds_tizen_policy_error_state error_state)
 887     {
 888         ds_inf("%s", __func__);
 889
 890         ds_tizen_policy_surface_send_window_screen_mode_done(mPolicySurface, window_screen_mode,
 891             error_state);
 892     }
 893
 894     void SendIconifyStateChanged(bool iconified, bool force)
 895     {
 896         ds_inf("%s", __func__);
 897
 898         ds_tizen_policy_surface_send_iconify_state_changed(mPolicySurface, iconified, force);
 899     }
 900
 901 public:
 902     bool bDestroyed;
 903
 904     bool bNewVisibility;
 905     bool bGetPosition;
 906     bool bActivate;
 907     bool bRaise;
 908     bool bLower;
 909     bool bSetFocusSkip;
 910     std::string mRole;
 911     enum ds_tizen_policy_window_type mWinType;
 912     bool bSetConformant;
 913     bool bGetConformant;
 914     enum ds_tizen_policy_notification_level mNotificationLevel;
 915     enum ds_tizen_policy_window_screen_mode mWindowScreenMode;
 916     uint32_t mUniversalId;
 917     uint32_t mParentUniversalId;
 918     bool bIconify;
 919     int32_t mAuxHintId;
 920     std::string mAuxHintName;
 921     std::string mAuxHintValue;
 922     bool bGetSupportedAuxHints;
 923     bool bSetFloatingMode;
 924     enum ds_tizen_policy_stack_mode mStackMode;
 925     bool bGetSubsurfaceWatcher;
 926     struct ds_surface *mParentSurface;
 927     uint32_t mSerial;
 928     bool bVideo;
 929     bool bShow;
 930     bool bHide;
 931
 932 private:
 933     struct ds_tizen_policy_surface *mPolicySurface;
 934     MockPolicyVisibility *mPolicyVisibility;
 935     MockPolicyPosition *mPolicyPosition;
 936     MockPolicySubsurfaceWatcher *mPolicySubsurfaceWatcher;
 937
 938     struct DestroyListener : ::wl_listener {
 939         MockPolicySurface *parent;
 940     };
 941     DestroyListener mDestroyListener;
 942
 943     // policy policy_surface listener structure
 944     struct NewVisibilityListener : ::wl_listener {
 945         MockPolicySurface *parent;
 946     };
 947     NewVisibilityListener mNewVisibilityListener;
 948
 949     struct GetPositionListener : ::wl_listener {
 950         MockPolicySurface *parent;
 951     };
 952     GetPositionListener mGetPositionListener;
 953
 954     struct ActivateListener : ::wl_listener {
 955         MockPolicySurface *parent;
 956     };
 957     ActivateListener mActivateListener;
 958
 959     struct RaiseListener : ::wl_listener {
 960         MockPolicySurface *parent;
 961     };
 962     RaiseListener mRaiseListener;
 963
 964     struct LowerListener : ::wl_listener {
 965         MockPolicySurface *parent;
 966     };
 967     LowerListener mLowerListener;
 968
 969     struct SetFocusSkipListener : ::wl_listener {
 970         MockPolicySurface *parent;
 971     };
 972     SetFocusSkipListener mSetFocusSkipListener;
 973
 974     struct UnsetFocusSkipListener : ::wl_listener {
 975         MockPolicySurface *parent;
 976     };
 977     UnsetFocusSkipListener mUnsetFocusSkipListener;
 978
 979     struct SetRoleListener : ::wl_listener {
 980         MockPolicySurface *parent;
 981     };
 982     SetRoleListener mSetRoleListener;
 983
 984     struct WindowTypeListener : ::wl_listener {
 985         MockPolicySurface *parent;
 986     };
 987     WindowTypeListener mWindowTypeListener;
 988
 989     struct SetConformantListener : ::wl_listener {
 990         MockPolicySurface *parent;
 991     };
 992     SetConformantListener mSetConformantListener;
 993
 994     struct UnsetConformantListener : ::wl_listener {
 995         MockPolicySurface *parent;
 996     };
 997     UnsetConformantListener mUnsetConformantListener;
 998
 999     struct GetConformantListener : ::wl_listener {
1000         MockPolicySurface *parent;
1001     };
1002     GetConformantListener mGetConformantListener;
1003
1004     struct SetNotificationLevelListener : ::wl_listener {
1005         MockPolicySurface *parent;
1006     };
1007     SetNotificationLevelListener mSetNotificationLevelListener;
1008
1009     struct SetWindowScreenModeListener : ::wl_listener {
1010         MockPolicySurface *parent;
1011     };
1012     SetWindowScreenModeListener mSetWindowScreenModeListener;
1013
1014     struct GetSubsurfaceListener : ::wl_listener {
1015         MockPolicySurface *parent;
1016     };
1017     GetSubsurfaceListener mGetSubsurfaceListener;
1018
1019     struct IconifyListener : ::wl_listener {
1020         MockPolicySurface *parent;
1021     };
1022     IconifyListener mIconifyListener;
1023
1024     struct UniconifyListener : ::wl_listener {
1025         MockPolicySurface *parent;
1026     };
1027     UniconifyListener mUniconifyListener;
1028
1029     struct AddAuxHintListener : ::wl_listener {
1030         MockPolicySurface *parent;
1031     };
1032     AddAuxHintListener mAddAuxHintListener;
1033
1034     struct ChangeAuxHintListener : ::wl_listener {
1035         MockPolicySurface *parent;
1036     };
1037     ChangeAuxHintListener mChangeAuxHintListener;
1038
1039     struct DeleteAuxHintListener : ::wl_listener {
1040         MockPolicySurface *parent;
1041     };
1042     DeleteAuxHintListener mDeleteAuxHintListener;
1043
1044     struct GetSupportAuxHintsListener : ::wl_listener {
1045         MockPolicySurface *parent;
1046     };
1047     GetSupportAuxHintsListener mGetSupportAuxHintsListener;
1048
1049     struct SetFloatingModeListener : ::wl_listener {
1050         MockPolicySurface *parent;
1051     };
1052     SetFloatingModeListener mSetFloatingModeListener;
1053
1054     struct UnsetFloatingModeListener : ::wl_listener {
1055         MockPolicySurface *parent;
1056     };
1057     UnsetFloatingModeListener mUnsetFloatingModeListener;
1058
1059     struct SetStackModeListener : ::wl_listener {
1060         MockPolicySurface *parent;
1061     };
1062     SetStackModeListener mSetStackModeListener;
1063
1064     struct GetSubsurfaceWatcherListener : ::wl_listener {
1065         MockPolicySurface *parent;
1066     };
1067     GetSubsurfaceWatcherListener mGetSubsurfaceWatcherListener;
1068
1069     struct SetParentListener : ::wl_listener {
1070         MockPolicySurface *parent;
1071     };
1072     SetParentListener mSetParentListener;
1073
1074     struct AckConformantRegionListener : ::wl_listener {
1075         MockPolicySurface *parent;
1076     };
1077     AckConformantRegionListener mAckConformantRegionListener;
1078
1079     struct SetVideoListener : ::wl_listener {
1080         MockPolicySurface *parent;
1081     };
1082     SetVideoListener mSetVideoListener;
1083
1084     struct ShowListener : ::wl_listener {
1085         MockPolicySurface *parent;
1086     };
1087     ShowListener mShowListener;
1088
1089     struct HideListener : ::wl_listener {
1090         MockPolicySurface *parent;
1091     };
1092     HideListener mHideListener;
1093
1094     struct SetParentWithBelowListener : ::wl_listener {
1095         MockPolicySurface *parent;
1096     };
1097     SetParentWithBelowListener mSetParentWithBelowListener;
1098 };
1099
1100 class MockSurface
1101 {
1102 public:
1103     MockSurface(struct ds_surface *surface)
1104       : mSurface(surface)
1105     {
1106         ds_inf("%s", __func__);
1107
1108         // del surface listener
1109         mDestroyListener.notify = MockSurface::DestroyCallback;
1110         mDestroyListener.parent = this;
1111         ds_surface_add_destroy_listener(surface, &mDestroyListener);
1112     }
1113     ~MockSurface()
1114     {
1115         ds_inf("%s", __func__);
1116
1117         if (mDestroyListener.notify) {
1118             wl_list_remove(&mDestroyListener.link);
1119             mDestroyListener.notify = nullptr;
1120         }
1121     }
1122
1123     static void DestroyCallback(struct wl_listener *listener, void *data)
1124     {
1125         MockSurface *mockSurface =
1126             reinterpret_cast<DestroyListener *>(listener)->parent;
1127         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
1128
1129         ds_inf("%s: mockSurface(%p), surface(%p)", __func__, mockSurface, surface);
1130
1131         wl_list_remove(&mockSurface->mDestroyListener.link);
1132         mockSurface->mDestroyListener.notify = nullptr;
1133     }
1134
1135 private:
1136     struct ds_surface *mSurface;
1137
1138     struct DestroyListener : ::wl_listener {
1139         MockSurface *parent;
1140     };
1141     DestroyListener mDestroyListener;
1142 };
1143
1144 class MockPolicyCompositor : public MockCompositor
1145 {
1146 public:
1147     MockPolicyCompositor()
1148         : MockCompositor(&MockPolicyCompositor::TestSetup, this)
1149     {
1150         ds_inf("%s : this(%p)", __func__, this);
1151
1152         // initialize the flags to check
1153         bDestroyed = false;
1154         bNewPolicySurface = false;
1155     }
1156
1157     ~MockPolicyCompositor()
1158     {
1159         ds_inf("%s : this(%p)", __func__, this);
1160
1161         auto removeSurfaces = [&](MockSurface* s)->void {delete s;};
1162         for_each(mMockSurfaces.begin(), mMockSurfaces.end(), removeSurfaces);
1163         mMockSurfaces.clear();
1164
1165         auto removePolicySurfaces = [&](MockPolicySurface* i)->void {delete i;};
1166         for_each(mPolicySurfaces.begin(), mPolicySurfaces.end(), removePolicySurfaces);
1167         mPolicySurfaces.clear();
1168
1169         wl_list_remove(&mNewSurfaceListener.link);
1170     }
1171
1172     static void TestSetup(void *data)
1173     {
1174         MockPolicyCompositor *mockComp =
1175             static_cast<MockPolicyCompositor *>(data);
1176         Compositor *comp = mockComp->compositor;
1177
1178         ds_inf("%s: mockComp(%p)", __func__, mockComp);
1179
1180         // new surface listener
1181         mockComp->mNewSurfaceListener.notify =
1182             MockPolicyCompositor::NewSurfaceCallback;
1183         mockComp->mNewSurfaceListener.parent = mockComp;
1184         ds_compositor_add_new_surface_listener(comp->compositor,
1185                 &mockComp->mNewSurfaceListener);
1186
1187         mockComp->mPolicy =
1188             ds_tizen_policy_create(comp->display);
1189
1190         // policy destroy listener
1191         mockComp->mDestroyListener.notify =
1192             MockPolicyCompositor::DestroyCallback;
1193         mockComp->mDestroyListener.parent = mockComp;
1194         ds_tizen_policy_add_destroy_listener(mockComp->mPolicy,
1195             &mockComp->mDestroyListener);
1196
1197         // policy listeners
1198         mockComp->mNewPolicySurfaceListener.notify =
1199             MockPolicyCompositor::NewPolicySurfaceCallback;
1200         mockComp->mNewPolicySurfaceListener.parent = mockComp;
1201         ds_tizen_policy_add_new_surface_listener(
1202             mockComp->mPolicy,
1203             &mockComp->mNewPolicySurfaceListener);
1204
1205         mockComp->mActivateBelowByUniversalIdListener.notify =
1206             MockPolicyCompositor::ActivateBelowByUniversalIdCallback;
1207         mockComp->mActivateBelowByUniversalIdListener.parent = mockComp;
1208         ds_tizen_policy_add_activate_below_by_univeral_id_listener(
1209             mockComp->mPolicy,
1210             &mockComp->mActivateBelowByUniversalIdListener);
1211
1212         mockComp->mLowerByUniversalIdListener.notify =
1213             MockPolicyCompositor::LowerByUniversalIdCallback;
1214         mockComp->mLowerByUniversalIdListener.parent = mockComp;
1215         ds_tizen_policy_add_lower_by_universal_id_listener(
1216             mockComp->mPolicy,
1217             &mockComp->mLowerByUniversalIdListener);
1218
1219         mockComp->mSetTransientForListener.notify =
1220             MockPolicyCompositor::SetTransientForCallback;
1221         mockComp->mSetTransientForListener.parent = mockComp;
1222         ds_tizen_policy_add_set_transient_for_listener(
1223             mockComp->mPolicy,
1224             &mockComp->mSetTransientForListener);
1225
1226         mockComp->mUnsetTransientForListener.notify =
1227             MockPolicyCompositor::UnsetTransientForCallback;
1228         mockComp->mUnsetTransientForListener.parent = mockComp;
1229         ds_tizen_policy_add_unset_transient_for_listener(
1230             mockComp->mPolicy,
1231             &mockComp->mUnsetTransientForListener);
1232
1233         mockComp->mPlaceSubsurfaceBelowParentListener.notify =
1234             MockPolicyCompositor::PlaceSubsurfaceBelowParentCallback;
1235         mockComp->mPlaceSubsurfaceBelowParentListener.parent = mockComp;
1236         ds_tizen_policy_add_place_subsurface_below_parent_listener(
1237             mockComp->mPolicy,
1238             &mockComp->mPlaceSubsurfaceBelowParentListener);
1239
1240         mockComp->mSetSubsurfaceStandAloneListener.notify =
1241             MockPolicyCompositor::SetSubsurfaceStandAloneCallback;
1242         mockComp->mSetSubsurfaceStandAloneListener.parent = mockComp;
1243         ds_tizen_policy_add_set_subsurface_stand_alone_listener(
1244             mockComp->mPolicy,
1245             &mockComp->mSetSubsurfaceStandAloneListener);
1246
1247         mockComp->mSetBackgroundStateListener.notify =
1248             MockPolicyCompositor::SetBackgroundStateCallback;
1249         mockComp->mSetBackgroundStateListener.parent = mockComp;
1250         ds_tizen_policy_add_set_background_state_listener(
1251             mockComp->mPolicy,
1252             &mockComp->mSetBackgroundStateListener);
1253
1254         mockComp->mUnsetBackgroundStateListener.notify =
1255             MockPolicyCompositor::UnsetBackgroundStateCallback;
1256         mockComp->mUnsetBackgroundStateListener.parent = mockComp;
1257         ds_tizen_policy_add_unset_background_state_listener(
1258             mockComp->mPolicy,
1259             &mockComp->mUnsetBackgroundStateListener);
1260
1261         mockComp->mActivateAboveByUniversalIdListener.notify =
1262             MockPolicyCompositor::ActivateAboveByUniversalIdCallback;
1263         mockComp->mActivateAboveByUniversalIdListener.parent = mockComp;
1264         ds_tizen_policy_add_activate_above_by_universal_id_listener(
1265             mockComp->mPolicy,
1266             &mockComp->mActivateAboveByUniversalIdListener);
1267
1268         mockComp->mSetAppIdListener.notify =
1269             MockPolicyCompositor::SetAppIdCallback;
1270         mockComp->mSetAppIdListener.parent = mockComp;
1271         ds_tizen_policy_add_set_appid_listener(
1272             mockComp->mPolicy,
1273             &mockComp->mSetAppIdListener);
1274
1275         mockComp->mSetTransientForBelowListener.notify =
1276             MockPolicyCompositor::SetTransientForBelowCallback;
1277         mockComp->mSetTransientForBelowListener.parent = mockComp;
1278         ds_tizen_policy_add_set_transient_for_below_listener(
1279             mockComp->mPolicy,
1280             &mockComp->mSetTransientForBelowListener);
1281     }
1282
1283     static void NewSurfaceCallback(struct wl_listener *listener, void *data)
1284     {
1285         MockPolicyCompositor *mockComp =
1286             reinterpret_cast<NewSurfaceListener *>(listener)->parent;
1287         struct ds_surface *surface = static_cast<struct ds_surface *>(data);
1288         MockSurface *mockSurf = new MockSurface(surface);
1289
1290         ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
1291
1292         mockComp->mMockSurfaces.push_back(mockSurf);
1293     }
1294
1295     static void DestroyCallback(struct wl_listener *listener, void *data)
1296     {
1297         ds_inf("%s", __func__);
1298
1299         MockPolicyCompositor *mockComp =
1300             reinterpret_cast<DestroyListener *>(listener)->parent;
1301
1302         mockComp->bDestroyed = true;
1303     }
1304
1305     static void NewPolicySurfaceCallback(struct wl_listener *listener,
1306         void *data)
1307     {
1308         ds_inf("%s", __func__);
1309
1310         MockPolicyCompositor *mockComp =
1311             reinterpret_cast<NewPolicySurfaceListener *>(listener)->parent;
1312         struct ds_tizen_event_policy_new_surface *event =
1313             static_cast<struct ds_tizen_event_policy_new_surface *>(data);
1314
1315         struct ds_tizen_policy_surface *policy_surface = event->policy_surface;
1316
1317         ds_inf("%s: mockComp(%p), policy_surface(%p)", __func__, mockComp, policy_surface);
1318
1319         mockComp->bNewPolicySurface = true;
1320
1321         MockPolicySurface *policySurface = new MockPolicySurface(event->policy_surface);
1322         mockComp->mPolicySurfaces.push_back(policySurface);
1323     }
1324
1325     static void ActivateBelowByUniversalIdCallback(struct wl_listener *listener,
1326         void *data)
1327     {
1328         ds_inf("%s", __func__);
1329
1330         MockPolicyCompositor *mockComp =
1331             reinterpret_cast<ActivateBelowByUniversalIdListener *>(listener)->parent;
1332         struct ds_tizen_event_policy_activate_below_by_univeral_id *event =
1333             static_cast<struct ds_tizen_event_policy_activate_below_by_univeral_id *>(data);
1334
1335         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1336         mockComp->mUniversalId = event->universal_id;
1337         mockComp->mBelowUniversalId = event->below_universal_id;
1338     }
1339
1340     static void LowerByUniversalIdCallback(struct wl_listener *listener,
1341         void *data)
1342     {
1343         ds_inf("%s", __func__);
1344
1345         MockPolicyCompositor *mockComp =
1346             reinterpret_cast<LowerByUniversalIdListener *>(listener)->parent;
1347         struct ds_tizen_event_policy_lower_by_universal_id *event =
1348             static_cast<struct ds_tizen_event_policy_lower_by_universal_id *>(data);
1349
1350         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1351         mockComp->mUniversalId = event->universal_id;
1352     }
1353
1354     static void SetTransientForCallback(struct wl_listener *listener,
1355         void *data)
1356     {
1357         ds_inf("%s", __func__);
1358
1359         MockPolicyCompositor *mockComp =
1360             reinterpret_cast<SetTransientForListener *>(listener)->parent;
1361         struct ds_tizen_event_policy_set_transient_for *event =
1362             static_cast<struct ds_tizen_event_policy_set_transient_for *>(data);
1363
1364         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1365         mockComp->mChildUniversalId = event->child_universal_id;
1366         mockComp->mParentUniversalId = event->parent_universal_id;
1367     }
1368
1369     static void UnsetTransientForCallback(struct wl_listener *listener,
1370         void *data)
1371     {
1372         ds_inf("%s", __func__);
1373
1374         MockPolicyCompositor *mockComp =
1375             reinterpret_cast<UnsetTransientForListener *>(listener)->parent;
1376         struct ds_tizen_event_policy_unset_transient_for *event =
1377             static_cast<struct ds_tizen_event_policy_unset_transient_for *>(data);
1378
1379         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1380         mockComp->mChildUniversalId = event->child_universal_id;
1381     }
1382
1383     static void PlaceSubsurfaceBelowParentCallback(struct wl_listener *listener,
1384         void *data)
1385     {
1386         ds_inf("%s", __func__);
1387
1388         MockPolicyCompositor *mockComp =
1389             reinterpret_cast<PlaceSubsurfaceBelowParentListener *>(listener)->parent;
1390         struct ds_tizen_event_policy_place_subsurface_below_parent *event =
1391             static_cast<struct ds_tizen_event_policy_place_subsurface_below_parent *>(data);
1392
1393         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1394         mockComp->bPlaceSubsurfaceBelowParent = true;
1395     }
1396
1397     static void SetSubsurfaceStandAloneCallback(struct wl_listener *listener,
1398         void *data)
1399     {
1400         ds_inf("%s", __func__);
1401
1402         MockPolicyCompositor *mockComp =
1403             reinterpret_cast<SetSubsurfaceStandAloneListener *>(listener)->parent;
1404         struct ds_tizen_event_policy_set_subsurface_stand_alone *event =
1405             static_cast<struct ds_tizen_event_policy_set_subsurface_stand_alone *>(data);
1406
1407         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1408         mockComp->bSetSubsurfaceStandAlone = true;
1409     }
1410
1411     static void SetBackgroundStateCallback(struct wl_listener *listener, void *data)
1412     {
1413         MockPolicyCompositor *mockComp =
1414             reinterpret_cast<SetBackgroundStateListener *>(listener)->parent;
1415         struct ds_tizen_event_policy_set_background_state *event =
1416             static_cast<struct ds_tizen_event_policy_set_background_state *>(data);
1417
1418         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1419         mockComp->mPid = event->pid;
1420     }
1421
1422     static void UnsetBackgroundStateCallback(struct wl_listener *listener, void *data)
1423     {
1424         MockPolicyCompositor *mockComp =
1425             reinterpret_cast<UnsetBackgroundStateListener *>(listener)->parent;
1426         struct ds_tizen_event_policy_unset_background_state *event =
1427             static_cast<struct ds_tizen_event_policy_unset_background_state *>(data);
1428
1429         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1430         mockComp->mPid = event->pid;
1431     }
1432
1433     static void ActivateAboveByUniversalIdCallback(struct wl_listener *listener,
1434         void *data)
1435     {
1436         ds_inf("%s", __func__);
1437
1438         MockPolicyCompositor *mockComp =
1439             reinterpret_cast<ActivateAboveByUniversalIdListener *>(listener)->parent;
1440         struct ds_tizen_event_policy_activate_above_by_universal_id *event =
1441             static_cast<struct ds_tizen_event_policy_activate_above_by_universal_id *>(data);
1442
1443         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1444         mockComp->mUniversalId = event->universal_id;
1445         mockComp->mAboveUniversalId = event->above_universal_id;
1446     }
1447
1448     static void SetAppIdCallback(struct wl_listener *listener,
1449         void *data)
1450     {
1451         ds_inf("%s", __func__);
1452
1453         MockPolicyCompositor *mockComp =
1454             reinterpret_cast<SetAppIdListener *>(listener)->parent;
1455         struct ds_tizen_event_policy_set_appid *event =
1456             static_cast<struct ds_tizen_event_policy_set_appid *>(data);
1457
1458         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1459         mockComp->mPid = event->pid;
1460         mockComp->mAppId = event->appid; // char -> string
1461     }
1462
1463     static void SetTransientForBelowCallback(struct wl_listener *listener,
1464         void *data)
1465     {
1466         ds_inf("%s", __func__);
1467
1468         MockPolicyCompositor *mockComp =
1469             reinterpret_cast<SetTransientForBelowListener *>(listener)->parent;
1470         struct ds_tizen_event_policy_set_transient_for_below *event =
1471             static_cast<struct ds_tizen_event_policy_set_transient_for_below *>(data);
1472
1473         EXPECT_TRUE(mockComp->mPolicy == event->policy);
1474         mockComp->mUniversalId = event->universal_id;
1475         mockComp->mParentUniversalId = event->parent_universal_id;
1476     }
1477
1478     MockPolicySurface* FindPolicySurfaceWidthResId(uint32_t res_id)
1479     {
1480         auto is_matched = [&](MockPolicySurface* i)->bool {
1481                 return (i->GetSurfaceResId() == res_id);
1482         };
1483         auto result = std::find_if(begin(mPolicySurfaces), end(mPolicySurfaces),
1484                             is_matched);
1485         if (result != std::end(mPolicySurfaces))
1486             return *result;
1487
1488         return nullptr;
1489     }
1490
1491 public:
1492     bool bDestroyed;
1493     bool bNewPolicySurface;
1494     int32_t mPid;
1495     std::string mAppId;
1496     uint32_t mUniversalId;
1497     uint32_t mAboveUniversalId;
1498     uint32_t mBelowUniversalId;
1499     uint32_t mParentUniversalId;
1500     uint32_t mChildUniversalId;
1501     bool bPlaceSubsurfaceBelowParent;
1502     bool bSetSubsurfaceStandAlone;
1503
1504 private:
1505     struct ds_tizen_policy *mPolicy;
1506
1507     std::vector<MockSurface *> mMockSurfaces;
1508     std::vector<MockPolicySurface *> mPolicySurfaces;
1509
1510     struct NewSurfaceListener : ::wl_listener {
1511         MockPolicyCompositor *parent;
1512     };
1513     NewSurfaceListener mNewSurfaceListener;
1514
1515     struct DestroyListener : ::wl_listener {
1516         MockPolicyCompositor *parent;
1517     };
1518     DestroyListener mDestroyListener;
1519
1520     // policy listener structure
1521     struct NewPolicySurfaceListener : ::wl_listener {
1522         MockPolicyCompositor *parent;
1523     };
1524     NewPolicySurfaceListener mNewPolicySurfaceListener;
1525
1526     struct ActivateBelowByUniversalIdListener: ::wl_listener {
1527         MockPolicyCompositor *parent;
1528     };
1529     ActivateBelowByUniversalIdListener mActivateBelowByUniversalIdListener;
1530
1531     struct LowerByUniversalIdListener: ::wl_listener {
1532         MockPolicyCompositor *parent;
1533     };
1534     LowerByUniversalIdListener mLowerByUniversalIdListener;
1535
1536     struct SetTransientForListener: ::wl_listener {
1537         MockPolicyCompositor *parent;
1538     };
1539     SetTransientForListener mSetTransientForListener;
1540
1541     struct UnsetTransientForListener: ::wl_listener {
1542         MockPolicyCompositor *parent;
1543     };
1544     UnsetTransientForListener mUnsetTransientForListener;
1545
1546     struct PlaceSubsurfaceBelowParentListener: ::wl_listener {
1547         MockPolicyCompositor *parent;
1548     };
1549     PlaceSubsurfaceBelowParentListener mPlaceSubsurfaceBelowParentListener;
1550
1551     struct  SetSubsurfaceStandAloneListener: ::wl_listener {
1552         MockPolicyCompositor *parent;
1553     };
1554     SetSubsurfaceStandAloneListener mSetSubsurfaceStandAloneListener;
1555
1556     struct SetBackgroundStateListener : ::wl_listener {
1557         MockPolicyCompositor *parent;
1558     };
1559     SetBackgroundStateListener mSetBackgroundStateListener;
1560
1561     struct UnsetBackgroundStateListener : ::wl_listener {
1562         MockPolicyCompositor *parent;
1563     };
1564     UnsetBackgroundStateListener mUnsetBackgroundStateListener;
1565
1566     struct  ActivateAboveByUniversalIdListener: ::wl_listener {
1567         MockPolicyCompositor *parent;
1568     };
1569     ActivateAboveByUniversalIdListener mActivateAboveByUniversalIdListener;
1570
1571     struct  SetAppIdListener: ::wl_listener {
1572         MockPolicyCompositor *parent;
1573     };
1574     SetAppIdListener mSetAppIdListener;
1575
1576     struct  SetTransientForBelowListener: ::wl_listener {
1577         MockPolicyCompositor *parent;
1578     };
1579     SetTransientForBelowListener mSetTransientForBelowListener;
1580
1581     // policy_surface listener structure
1582     struct PolicySurfaceDestroyListener : ::wl_listener {
1583         MockPolicyCompositor *parent;
1584     };
1585     PolicySurfaceDestroyListener mPolicySurfaceDestroyListener;
1586 };
1587
1588 class MockPolicyClient : public MockClient
1589 {
1590 public:
1591     MockPolicyClient()
1592         :  mSurfaceRes(nullptr),
1593            mIsConformant(0),
1594            mLevel(-1),
1595            mErrorState(0),
1596            mChildId(0),
1597            mWindowScreenMode(0),
1598            mIconified(0),
1599            mForce(0),
1600            mHints(nullptr),
1601            mNumHints(0),
1602            mHintId(-1),
1603            mKey(nullptr),
1604            mValue(nullptr),
1605            mOptions(nullptr),
1606            mConformantPart(0),
1607            mState(0),
1608            mX(-1), mY(-1), mW(0), mH(0),
1609            mSerial(0),
1610            mVisibilityType(0),
1611            mVisibilityOption(0),
1612            mPositionX(-1), mPositionY(-1)
1613     {}
1614     MockPolicyClient(const struct wl_registry_listener *listener)
1615         : MockClient(listener, this)
1616     {
1617         ds_inf("%s", __func__);
1618     }
1619     ~MockPolicyClient()
1620     {
1621         ds_inf("%s", __func__);
1622     }
1623
1624     void SetWlCompositor(struct wl_compositor *global_res)
1625     {
1626         ds_inf("%s", __func__);
1627
1628         compositor_res = global_res;
1629     }
1630
1631     void SetWlSubCompositor(struct wl_subcompositor *global_res)
1632     {
1633         ds_inf("%s", __func__);
1634
1635         subcompositor_res = global_res;
1636     }
1637
1638     struct wl_compositor *GetWlCompositor()
1639     {
1640         ds_inf("%s", __func__);
1641
1642         return compositor_res;
1643     }
1644
1645     struct wl_subcompositor *GetWlSubCompositor()
1646     {
1647         ds_inf("%s", __func__);
1648
1649         return subcompositor_res;
1650     }
1651
1652     void SetTizenPolicy(struct tizen_policy *resource)
1653     {
1654         ds_inf("%s", __func__);
1655
1656         policy_res = resource;
1657     }
1658
1659     struct tizen_policy *GetTizenPolicy()
1660     {
1661         ds_inf("%s", __func__);
1662
1663         return policy_res;
1664     }
1665
1666 public:
1667     struct wl_surface *mSurfaceRes;
1668     uint32_t mIsConformant;
1669     int32_t mLevel;
1670     uint32_t mErrorState;
1671     uint32_t mChildId;
1672     uint32_t mWindowScreenMode;
1673     uint32_t mIconified;
1674     uint32_t mForce;
1675     struct wl_array *mHints;
1676     uint32_t mNumHints;
1677     int32_t mHintId;
1678     const char *mKey;
1679     const char *mValue;
1680     struct wl_array *mOptions;
1681     uint32_t mConformantPart;
1682     uint32_t mState;
1683     int32_t mX, mY, mW, mH;
1684     uint32_t mSerial;
1685     uint32_t mVisibilityType;
1686     uint32_t mVisibilityOption;
1687     int32_t mPositionX;
1688     int32_t mPositionY;
1689
1690 private:
1691     struct wl_compositor *compositor_res;
1692     struct wl_subcompositor *subcompositor_res;
1693     struct tizen_policy *policy_res;
1694 };
1695
1696 static void
1697 client_tizen_policy_cb_conformant(void *data, struct tizen_policy *policy_res,
1698     struct wl_surface *surface_resource, uint32_t is_conformant)
1699 {
1700     ds_inf("%s", __func__);
1701
1702     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1703
1704     client->mSurfaceRes = surface_resource;
1705     client->mIsConformant = is_conformant;
1706 }
1707
1708 static void
1709 client_tizen_policy_cb_conformant_area(void *data,
1710     struct tizen_policy *policy_res,
1711     struct wl_surface *surface_resource, uint32_t conformant_part,
1712     uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
1713 {
1714     ds_inf("%s", __func__);
1715
1716     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1717
1718     client->mSurfaceRes = surface_resource;
1719     client->mConformantPart = conformant_part;
1720     client->mState = state;
1721     client->mX = x;
1722     client->mY = y;
1723     client->mW = w;
1724     client->mH = h;
1725 }
1726
1727 static void
1728 client_tizen_policy_cb_notification_done(void *data,
1729     struct tizen_policy *policy_res,
1730     struct wl_surface *surface_resource, int32_t level, uint32_t error_state)
1731 {
1732     ds_inf("%s", __func__);
1733
1734     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1735
1736     client->mSurfaceRes = surface_resource;
1737     client->mLevel = level;
1738     client->mErrorState = error_state;
1739 }
1740
1741 static void
1742 client_tizen_policy_cb_transient_for_done(void *data,
1743     struct tizen_policy *policy_res, uint32_t child_id)
1744 {
1745     ds_inf("%s", __func__);
1746
1747     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1748
1749     client->mChildId = child_id;
1750 }
1751
1752 static void
1753 client_tizen_policy_cb_window_screen_mode_done(void *data,
1754     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1755     uint32_t mode, uint32_t error_state)
1756 {
1757     ds_inf("%s", __func__);
1758
1759     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1760
1761     client->mSurfaceRes = surface_resource;
1762     client->mWindowScreenMode = mode;
1763     client->mErrorState = error_state;
1764 }
1765
1766 static void
1767 client_tizen_policy_cb_iconify_state_changed(void *data,
1768     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1769     uint32_t iconified, uint32_t force)
1770 {
1771     ds_inf("%s", __func__);
1772
1773     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1774
1775     client->mSurfaceRes = surface_resource;
1776     client->mIconified = iconified;
1777     client->mForce = force;
1778 }
1779
1780 static void
1781 client_tizen_policy_cb_supported_aux_hints(void *data,
1782     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1783     struct wl_array *hints, uint32_t num_hints)
1784 {
1785     ds_inf("%s", __func__);
1786
1787     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1788
1789     client->mSurfaceRes = surface_resource;
1790     client->mHints = hints;
1791     client->mNumHints = num_hints;
1792 }
1793
1794 static void
1795 client_tizen_policy_cb_allowed_aux_hint(void *data,
1796     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1797     int32_t id)
1798 {
1799     ds_inf("%s", __func__);
1800
1801     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1802
1803     client->mSurfaceRes = surface_resource;
1804     client->mHintId = id;
1805 }
1806
1807 static void
1808 client_tizen_policy_cb_aux_message(void *data,
1809     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1810     const char *key, const char *value, struct wl_array *options)
1811 {
1812     ds_inf("%s", __func__);
1813
1814     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1815
1816     client->mSurfaceRes = surface_resource;
1817     client->mKey = key;
1818     client->mValue = value;
1819     client->mOptions = options;
1820 }
1821
1822 static void
1823 client_tizen_policy_cb_conformant_region(void *data,
1824     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1825     uint32_t conformant_part, uint32_t state,
1826     int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial)
1827 {
1828     ds_inf("%s", __func__);
1829
1830     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1831
1832     client->mSurfaceRes = surface_resource;
1833     client->mConformantPart = conformant_part;
1834     client->mState = state;
1835     client->mX = x;
1836     client->mY = y;
1837     client->mW = w;
1838     client->mH = h;
1839     client->mSerial = serial;
1840 }
1841
1842 static void
1843 client_tizen_policy_cb_interactive_mode_done(void *data,
1844     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1845     int32_t x, int32_t y, uint32_t w, uint32_t h)
1846 {
1847     ds_inf("%s", __func__);
1848
1849     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1850
1851     client->mSurfaceRes = surface_resource;
1852     client->mX = x;
1853     client->mY = y;
1854     client->mW = w;
1855     client->mH = h;
1856 }
1857
1858 static void
1859 client_tizen_policy_cb_interactive_resize_done(void *data,
1860     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1861     int32_t x, int32_t y, uint32_t w, uint32_t h)
1862 {
1863     ds_inf("%s", __func__);
1864
1865     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1866
1867     client->mSurfaceRes = surface_resource;
1868     client->mX = x;
1869     client->mY = y;
1870     client->mW = w;
1871     client->mH = h;
1872 }
1873
1874 static const struct
1875 tizen_policy_listener policy_cb_listener =
1876 {
1877    .conformant = client_tizen_policy_cb_conformant,
1878    .conformant_area = client_tizen_policy_cb_conformant_area,
1879    .notification_done = client_tizen_policy_cb_notification_done,
1880    .transient_for_done = client_tizen_policy_cb_transient_for_done,
1881    .window_screen_mode_done = client_tizen_policy_cb_window_screen_mode_done,
1882    .iconify_state_changed = client_tizen_policy_cb_iconify_state_changed,
1883    .supported_aux_hints = client_tizen_policy_cb_supported_aux_hints,
1884    .allowed_aux_hint = client_tizen_policy_cb_allowed_aux_hint,
1885    .aux_message = client_tizen_policy_cb_aux_message,
1886    .conformant_region = client_tizen_policy_cb_conformant_region,
1887    .interactive_move_done = client_tizen_policy_cb_interactive_mode_done,
1888    .interactive_resize_done = client_tizen_policy_cb_interactive_resize_done,
1889 };
1890
1891 static void
1892 client_registry_cb_global(void *data, struct wl_registry *registry,
1893     uint32_t name, const char *interface, uint32_t version)
1894 {
1895     ds_inf("%s", __func__);
1896
1897     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1898     struct wl_compositor *compositor_res;
1899     struct wl_subcompositor *subcompositor_res;
1900     struct tizen_policy *policy_res;
1901
1902     if (!strcmp(interface, "wl_compositor")) {
1903         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
1904             name, &wl_compositor_interface, 1);
1905         if (compositor_res == nullptr) {
1906             ds_err("wl_registry_bind() failed. wl_compositor resource.");
1907             return;
1908         }
1909         client->SetWlCompositor(compositor_res);
1910     } else if (!strcmp(interface, "wl_subcompositor")) {
1911         subcompositor_res = (struct wl_subcompositor *)
1912            wl_registry_bind(registry, name, &wl_subcompositor_interface, 1);
1913         if (subcompositor_res == nullptr) {
1914             ds_err("wl_registry_bind() failed. wl_subcompositor resource.");
1915             return;
1916         }
1917         client->SetWlSubCompositor(subcompositor_res);
1918     } else if (!strcmp(interface, "tizen_policy")) {
1919         policy_res = (struct tizen_policy *)wl_registry_bind(registry,
1920             name, &tizen_policy_interface, TIZEN_POLICY_VERSION);
1921         if (policy_res == nullptr) {
1922             ds_err("wl_registry_bind() failed. tizen_policy resource.");
1923             return;
1924         }
1925         client->SetTizenPolicy(policy_res);
1926
1927         tizen_policy_add_listener(policy_res,
1928             &policy_cb_listener, client);
1929     }
1930 }
1931
1932 static void
1933 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
1934     uint32_t name)
1935 {
1936     ds_inf("%s", __func__);
1937
1938     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1939     struct wl_compositor *compositor_res = client->GetWlCompositor();
1940     struct tizen_policy *policy_res = client->GetTizenPolicy();
1941
1942     tizen_policy_destroy(policy_res);
1943     wl_compositor_destroy(compositor_res);
1944 }
1945
1946 static const struct wl_registry_listener registry_listener = {
1947     .global = client_registry_cb_global,
1948     .global_remove = client_registry_cb_global_remove
1949 };
1950
1951 class PolicyTest : public ::testing::Test
1952 {
1953 public:
1954     void SetUp(void) override;
1955     void TearDown(void) override;
1956
1957     MockPolicyCompositor *comp;
1958     MockPolicyClient *client;
1959     struct wl_compositor *compositor_res;
1960     struct wl_subcompositor *subcompositor_res;
1961     struct tizen_policy *policy_res;
1962     struct wl_surface *surface_res;
1963 };
1964
1965 void
1966 PolicyTest::SetUp(void)
1967 {
1968     //ds_log_init(DS_DBG, NULL);
1969
1970     ds_inf("%s", __func__);
1971
1972     comp = new MockPolicyCompositor();
1973     client = new MockPolicyClient(&registry_listener);
1974     compositor_res = client->GetWlCompositor();
1975     subcompositor_res = client->GetWlSubCompositor();
1976     policy_res = client->GetTizenPolicy();
1977     surface_res = wl_compositor_create_surface(compositor_res);
1978
1979     client->RoundTrip();
1980 }
1981
1982 void
1983 PolicyTest::TearDown(void)
1984 {
1985     ds_inf("%s", __func__);
1986
1987     wl_surface_destroy(surface_res);
1988     client->RoundTrip();
1989
1990     delete client;
1991     delete comp;
1992 }
1993
1994 TEST_F(PolicyTest, Create_P)
1995 {
1996     EXPECT_TRUE(true);
1997 }
1998
1999 TEST_F(PolicyTest, Req_ActivateBelowByUniversalId)
2000 {
2001     uint32_t universal_id = 100;
2002     uint32_t below_universal_id = 200;
2003
2004     tizen_policy_activate_below_by_res_id(policy_res,
2005         universal_id, below_universal_id);
2006     client->RoundTrip();
2007
2008     EXPECT_TRUE(comp->mUniversalId == universal_id)
2009         << comp->mUniversalId << ", " << universal_id;
2010     EXPECT_TRUE(comp->mBelowUniversalId == below_universal_id)
2011         << comp->mBelowUniversalId << ", " << below_universal_id;
2012 }
2013
2014 TEST_F(PolicyTest, Req_LowerByUniversalId)
2015 {
2016     uint32_t universal_id = 100;
2017
2018     tizen_policy_lower_by_res_id(policy_res,universal_id);
2019     client->RoundTrip();
2020
2021     EXPECT_TRUE(comp->mUniversalId == universal_id)
2022         << comp->mUniversalId << ", " << universal_id;
2023 }
2024
2025 TEST_F(PolicyTest, Req_SetTransientFor)
2026 {
2027     uint32_t child_universal_id = 100;
2028     uint32_t parent_universal_id = 200;
2029
2030     tizen_policy_set_transient_for(policy_res,
2031         child_universal_id, parent_universal_id);
2032     client->RoundTrip();
2033
2034     EXPECT_TRUE(comp->mChildUniversalId == child_universal_id)
2035         << comp->mChildUniversalId << ", " << child_universal_id;
2036     EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id)
2037         << comp->mParentUniversalId << ", " << parent_universal_id;
2038
2039     EXPECT_TRUE(client->mChildId == child_universal_id);
2040 }
2041
2042 TEST_F(PolicyTest, Req_UnsetTransientFor)
2043 {
2044     uint32_t child_universal_id = 100;
2045
2046     tizen_policy_unset_transient_for(policy_res, child_universal_id);
2047     client->RoundTrip();
2048
2049     EXPECT_TRUE(comp->mChildUniversalId == child_universal_id)
2050         << comp->mChildUniversalId << ", " << child_universal_id;
2051
2052     EXPECT_TRUE(client->mChildId == child_universal_id);
2053 }
2054
2055 TEST_F(PolicyTest, Req_PlaceSubsurfaceBelowParent)
2056 {
2057     struct wl_surface *parent_surface_res;
2058     struct wl_subsurface *subsurface_res;
2059
2060     parent_surface_res = wl_compositor_create_surface(compositor_res);
2061     if (!parent_surface_res)
2062         return;
2063
2064     subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res,
2065         surface_res, parent_surface_res);
2066     if (!subsurface_res) {
2067         wl_surface_destroy(parent_surface_res);
2068         return;
2069      }
2070
2071     tizen_policy_place_subsurface_below_parent(policy_res, subsurface_res);
2072     client->RoundTrip();
2073
2074     EXPECT_TRUE(comp->bPlaceSubsurfaceBelowParent);
2075
2076     wl_subsurface_destroy(subsurface_res);
2077     wl_surface_destroy(parent_surface_res);
2078 }
2079
2080 TEST_F(PolicyTest, Req_SetSubsurfaceStandAlone)
2081 {
2082     struct wl_surface *parent_surface_res;
2083     struct wl_subsurface *subsurface_res;
2084
2085     parent_surface_res = wl_compositor_create_surface(compositor_res);
2086     if (!parent_surface_res)
2087         return;
2088
2089     subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res,
2090         surface_res, parent_surface_res);
2091     if (!subsurface_res) {
2092         wl_surface_destroy(parent_surface_res);
2093         return;
2094      }
2095
2096     tizen_policy_set_subsurface_stand_alone(policy_res, subsurface_res);
2097     client->RoundTrip();
2098
2099     EXPECT_TRUE(comp->bSetSubsurfaceStandAlone);
2100
2101     wl_subsurface_destroy(subsurface_res);
2102     wl_surface_destroy(parent_surface_res);
2103 }
2104
2105 TEST_F(PolicyTest, Req_ActivateAboveByUniversalId)
2106 {
2107     uint32_t universal_id = 100;
2108     uint32_t above_universal_id = 100;
2109
2110     tizen_policy_activate_above_by_res_id(policy_res, universal_id,
2111         above_universal_id);
2112     client->RoundTrip();
2113
2114     EXPECT_TRUE(comp->mUniversalId == universal_id)
2115         << comp->mUniversalId << ", " << universal_id;
2116     EXPECT_TRUE(comp->mAboveUniversalId == above_universal_id)
2117         << comp->mAboveUniversalId << ", " << above_universal_id;
2118 }
2119
2120 TEST_F(PolicyTest, Req_SetAppId)
2121 {
2122     int32_t pid = getpid();
2123     std::string appid("APPLICATION_ID");
2124     char* c_appid = const_cast<char *>(appid.c_str());
2125
2126     tizen_policy_set_appid(policy_res, pid, c_appid);
2127     client->RoundTrip();
2128
2129     EXPECT_TRUE(comp->mPid == pid)
2130         << comp->mPid << ", " << pid;
2131     EXPECT_TRUE(comp->mAppId.compare(appid) == false)
2132         << comp->mAppId << ", " << appid;
2133 }
2134
2135 TEST_F(PolicyTest, Req_SetTransientForBelow)
2136 {
2137     uint32_t universal_id = 100;
2138     uint32_t parent_universal_id = 200;
2139
2140     tizen_policy_set_transient_for_below(policy_res, universal_id,
2141         parent_universal_id);
2142     client->RoundTrip();
2143
2144     EXPECT_TRUE(comp->mUniversalId == universal_id)
2145         << comp->mUniversalId << ", " << universal_id;
2146     EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id)
2147         << comp->mParentUniversalId << ", " << parent_universal_id;
2148 }
2149
2150 static void
2151 client_tizen_visibility_cb_notify(void *data,
2152     struct tizen_visibility *visibility_res, uint32_t visibility)
2153 {
2154     ds_inf("%s", __func__);
2155
2156     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2157
2158     client->mVisibilityType = visibility;
2159 }
2160
2161 static void
2162 client_tizen_visibility_cb_changed(void *data,
2163     struct tizen_visibility *visibility_res, uint32_t type, uint32_t option)
2164 {
2165     ds_inf("%s", __func__);
2166
2167     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2168
2169     client->mVisibilityType = type;
2170     client->mVisibilityOption = option;
2171 }
2172
2173 static const struct
2174 tizen_visibility_listener visibility_cb_listener =
2175 {
2176    .notify = client_tizen_visibility_cb_notify,
2177    .changed = client_tizen_visibility_cb_changed,
2178 };
2179
2180 TEST_F(PolicyTest, Req_PolicySurfaceNewVisibility)
2181 {
2182     MockPolicySurface *policy_surface;
2183     MockPolicyVisibility *visibility;
2184     struct tizen_visibility *visibility_res;
2185     uint32_t surface_res_id;
2186
2187     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2188     EXPECT_TRUE(visibility_res != NULL);
2189
2190     tizen_visibility_add_listener(visibility_res,
2191             &visibility_cb_listener, client);
2192     client->RoundTrip();
2193
2194     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2195     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2196     EXPECT_TRUE(policy_surface->bNewVisibility);
2197
2198     visibility = policy_surface->NewVisibility();
2199
2200     tizen_visibility_destroy(visibility_res);
2201     client->RoundTrip();
2202
2203     EXPECT_TRUE(visibility->bDestroyed);
2204 }
2205
2206 TEST_F(PolicyTest, Ev_VisibilityNotify)
2207 {
2208     MockPolicySurface *policy_surface;
2209     MockPolicyVisibility *visibility;
2210     struct tizen_visibility *visibility_res;
2211     enum ds_tizen_policy_visibility_type type =
2212         DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED;
2213     uint32_t surface_res_id;
2214
2215     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2216     EXPECT_TRUE(visibility_res != NULL);
2217
2218     tizen_visibility_add_listener(visibility_res,
2219             &visibility_cb_listener, client);
2220     client->RoundTrip();
2221
2222     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2223     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2224     EXPECT_TRUE(policy_surface->bNewVisibility);
2225
2226     visibility = policy_surface->NewVisibility();
2227     visibility->SendNotify(type);
2228     comp->Process();
2229
2230     client->RoundTrip();
2231     EXPECT_TRUE(client->mVisibilityType ==
2232         TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED);
2233
2234     tizen_visibility_destroy(visibility_res);
2235     client->RoundTrip();
2236
2237     EXPECT_TRUE(visibility->bDestroyed);
2238 }
2239
2240 TEST_F(PolicyTest, Ev_VisibilityChanged)
2241 {
2242     MockPolicySurface *policy_surface;
2243     MockPolicyVisibility *visibility;
2244     struct tizen_visibility *visibility_res;
2245     enum ds_tizen_policy_visibility_type type =
2246         DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED;
2247     uint32_t surface_res_id;
2248     uint32_t option = 4;
2249
2250     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2251     EXPECT_TRUE(visibility_res != NULL);
2252
2253     tizen_visibility_add_listener(visibility_res,
2254             &visibility_cb_listener, client);
2255     client->RoundTrip();
2256
2257     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2258     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2259     EXPECT_TRUE(policy_surface->bNewVisibility);
2260
2261     visibility = policy_surface->NewVisibility();
2262     visibility->SendChanged(type, option);
2263     comp->Process();
2264
2265     client->RoundTrip();
2266     EXPECT_TRUE(client->mVisibilityType ==
2267         TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED);
2268     EXPECT_TRUE(client->mVisibilityOption == option);
2269
2270     tizen_visibility_destroy(visibility_res);
2271     client->RoundTrip();
2272
2273     EXPECT_TRUE(visibility->bDestroyed);
2274 }
2275
2276 static void
2277 client_tizen_position_cb_changed(void *data,
2278     struct tizen_position *position_res, int32_t x, int32_t y)
2279 {
2280     ds_inf("%s", __func__);
2281
2282     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2283
2284     client->mPositionX = x;
2285     client->mPositionY = y;
2286 }
2287
2288 static const struct
2289 tizen_position_listener position_cb_listener =
2290 {
2291    .changed = client_tizen_position_cb_changed,
2292 };
2293
2294 TEST_F(PolicyTest, Req_PolicySurfaceGetPosition)
2295 {
2296     MockPolicySurface *policy_surface;
2297     struct tizen_position *position_res;
2298     uint32_t surface_res_id;
2299
2300     position_res = tizen_policy_get_position(policy_res, surface_res);
2301     EXPECT_TRUE(position_res != NULL);
2302
2303     tizen_position_add_listener(position_res,
2304             &position_cb_listener, client);
2305     client->RoundTrip();
2306
2307     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2308     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2309     EXPECT_TRUE(policy_surface->bGetPosition);
2310
2311     tizen_position_destroy(position_res);
2312 }
2313
2314 TEST_F(PolicyTest, Req_PositionSet)
2315 {
2316     MockPolicySurface *policy_surface;
2317     MockPolicyPosition *position;
2318     struct tizen_position *position_res;
2319     uint32_t surface_res_id;
2320     int32_t x = 100, y = 200;
2321
2322     position_res = tizen_policy_get_position(policy_res, surface_res);
2323     EXPECT_TRUE(position_res != NULL);
2324
2325     tizen_position_add_listener(position_res,
2326             &position_cb_listener, client);
2327
2328     tizen_position_set(position_res, x, y);
2329     client->RoundTrip();
2330
2331     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2332     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2333     EXPECT_TRUE(policy_surface->bGetPosition);
2334
2335     position = policy_surface->GetPosition();
2336     EXPECT_TRUE(position->mX == x);
2337     EXPECT_TRUE(position->mY == y);
2338
2339     tizen_position_destroy(position_res);
2340 }
2341
2342 TEST_F(PolicyTest, Ev_PositionChanged)
2343 {
2344     MockPolicySurface *policy_surface;
2345     MockPolicyPosition *position;
2346     struct tizen_position *position_res;
2347     uint32_t surface_res_id;
2348     int32_t x = 100, y = 200;
2349
2350     position_res = tizen_policy_get_position(policy_res, surface_res);
2351     EXPECT_TRUE(position_res != NULL);
2352
2353     tizen_position_add_listener(position_res,
2354             &position_cb_listener, client);
2355     client->RoundTrip();
2356
2357     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2358     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2359     EXPECT_TRUE(policy_surface->bGetPosition);
2360
2361     position = policy_surface->GetPosition();
2362     position->SendChanged(x, y);
2363     comp->Process();
2364
2365     client->RoundTrip();
2366     EXPECT_TRUE(client->mPositionX == x);
2367     EXPECT_TRUE(client->mPositionY == y);
2368
2369     tizen_position_destroy(position_res);
2370 }
2371
2372 TEST_F(PolicyTest, Req_PolicySurfaceActivate)
2373 {
2374     MockPolicySurface *policy_surface;
2375     uint32_t surface_res_id;
2376
2377     tizen_policy_activate(policy_res, surface_res);
2378     client->RoundTrip();
2379
2380     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2381     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2382     EXPECT_TRUE(policy_surface->bActivate);
2383 }
2384
2385 TEST_F(PolicyTest, Req_PolicySurfaceRaise)
2386 {
2387     MockPolicySurface *policy_surface;
2388     uint32_t surface_res_id;
2389
2390     tizen_policy_raise(policy_res, surface_res);
2391     client->RoundTrip();
2392
2393     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2394     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2395     EXPECT_TRUE(policy_surface->bRaise);
2396 }
2397
2398 TEST_F(PolicyTest, Req_PolicySurfaceLower)
2399 {
2400     MockPolicySurface *policy_surface;
2401     uint32_t surface_res_id;
2402
2403     tizen_policy_lower(policy_res, surface_res);
2404     client->RoundTrip();
2405
2406     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2407     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2408     EXPECT_TRUE(policy_surface->bLower);
2409 }
2410
2411 TEST_F(PolicyTest, Req_PolicySurfaceSetFocusSkip)
2412 {
2413     MockPolicySurface *policy_surface;
2414     uint32_t surface_res_id;
2415
2416     tizen_policy_set_focus_skip(policy_res, surface_res);
2417     client->RoundTrip();
2418
2419     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2420     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2421     EXPECT_TRUE(policy_surface->bSetFocusSkip);
2422 }
2423
2424 TEST_F(PolicyTest, Req_PolicySurfaceUnsetFocusSkip)
2425 {
2426     MockPolicySurface *policy_surface;
2427     uint32_t surface_res_id;
2428
2429     tizen_policy_unset_focus_skip(policy_res, surface_res);
2430     client->RoundTrip();
2431
2432     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2433     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2434     EXPECT_TRUE(policy_surface->bSetFocusSkip == false);
2435 }
2436
2437 TEST_F(PolicyTest, Req_PolicySurfaceSetRole)
2438 {
2439     MockPolicySurface *policy_surface;
2440     uint32_t surface_res_id;
2441     std::string role("APPLICATION_ID");
2442     char* c_role = const_cast<char *>(role.c_str());
2443
2444     tizen_policy_set_role(policy_res, surface_res, c_role);
2445     client->RoundTrip();
2446
2447     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2448     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2449
2450     EXPECT_TRUE(policy_surface->mRole.compare(role) == false)
2451         << policy_surface->mRole << ", " << role;
2452 }
2453
2454 TEST_F(PolicyTest, Req_PolicySurfaceSetType)
2455 {
2456     MockPolicySurface *policy_surface;
2457     uint32_t surface_res_id;
2458     uint32_t win_type = TIZEN_POLICY_WIN_TYPE_TOPLEVEL;
2459
2460     tizen_policy_set_type(policy_res, surface_res, win_type);
2461     client->RoundTrip();
2462
2463     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2464     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2465
2466     EXPECT_TRUE(policy_surface->mWinType == DS_TIZEN_POLICY_WINDOW_TYPE_TOPLEVEL);
2467 }
2468
2469 TEST_F(PolicyTest, Req_PolicySurfaceSetConformant)
2470 {
2471     MockPolicySurface *policy_surface;
2472     uint32_t surface_res_id;
2473
2474     tizen_policy_set_conformant(policy_res, surface_res);
2475     client->RoundTrip();
2476
2477     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2478     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2479
2480     EXPECT_TRUE(policy_surface->bSetConformant == true);
2481 }
2482
2483 TEST_F(PolicyTest, Req_PolicySurfaceUnsetConformant)
2484 {
2485     MockPolicySurface *policy_surface;
2486     uint32_t surface_res_id;
2487
2488     tizen_policy_unset_conformant(policy_res, surface_res);
2489     client->RoundTrip();
2490
2491     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2492     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2493
2494     EXPECT_TRUE(policy_surface->bSetConformant == false);
2495 }
2496
2497 TEST_F(PolicyTest, Req_Ev_PolicySurfaceGetConformant)
2498 {
2499     MockPolicySurface *policy_surface;
2500     uint32_t surface_res_id;
2501
2502     tizen_policy_get_conformant(policy_res, surface_res);
2503     client->RoundTrip();
2504
2505     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2506     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2507
2508     EXPECT_TRUE(policy_surface->bGetConformant == true);
2509 }
2510
2511 TEST_F(PolicyTest, Req_PolicySurfaceSetNotificationLevel)
2512 {
2513     MockPolicySurface *policy_surface;
2514     uint32_t surface_res_id;
2515     uint32_t noti_level = TIZEN_POLICY_LEVEL_HIGH;
2516
2517     tizen_policy_set_notification_level(policy_res, surface_res, noti_level);
2518     client->RoundTrip();
2519
2520     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2521     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2522
2523     EXPECT_TRUE(policy_surface->mNotificationLevel == DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH);
2524 }
2525
2526 TEST_F(PolicyTest, Req_PolicySurfaceSetWindowScreenMode)
2527 {
2528     MockPolicySurface *policy_surface;
2529     uint32_t surface_res_id;
2530     uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON;
2531
2532     tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode);
2533     client->RoundTrip();
2534
2535     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2536     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2537
2538     EXPECT_TRUE(policy_surface->mWindowScreenMode == DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON);
2539 }
2540
2541 TEST_F(PolicyTest, Req_PolicySurfaceGetSubsurface)
2542 {
2543     MockPolicySurface *policy_surface;
2544     uint32_t surface_res_id;
2545     struct wl_subsurface *subsurface_res;
2546     uint32_t parent_universal_id = 100;
2547
2548     subsurface_res = tizen_policy_get_subsurface(policy_res, surface_res, parent_universal_id);
2549     EXPECT_TRUE(subsurface_res != NULL);
2550     client->RoundTrip();
2551
2552     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2553     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2554
2555     EXPECT_TRUE(policy_surface->mParentUniversalId == parent_universal_id);
2556 }
2557
2558 TEST_F(PolicyTest, Req_PolicySurfaceIconify)
2559 {
2560     MockPolicySurface *policy_surface;
2561     uint32_t surface_res_id;
2562
2563     tizen_policy_iconify(policy_res, surface_res);
2564     client->RoundTrip();
2565
2566     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2567     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2568
2569     EXPECT_TRUE(policy_surface->bIconify == true);
2570 }
2571
2572 TEST_F(PolicyTest, Req_PolicySurfaceUniconify)
2573 {
2574     MockPolicySurface *policy_surface;
2575     uint32_t surface_res_id;
2576
2577     tizen_policy_uniconify(policy_res, surface_res);
2578     client->RoundTrip();
2579
2580     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2581     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2582
2583     EXPECT_TRUE(policy_surface->bIconify == false);
2584 }
2585
2586 TEST_F(PolicyTest, Req_PolicySurfaceAddAuxHint)
2587 {
2588     MockPolicySurface *policy_surface;
2589     uint32_t surface_res_id;
2590     int32_t auxhint_id = 100;
2591     std::string auxhint_name("AUX_HINT_NAME");
2592     std::string auxhint_value("AUX_HINT_VALUE");
2593     char* c_auxhint_name = const_cast<char *>(auxhint_name.c_str());
2594     char* c_auxhint_value = const_cast<char *>(auxhint_value.c_str());
2595
2596     tizen_policy_add_aux_hint(policy_res, surface_res, auxhint_id,
2597         c_auxhint_name, c_auxhint_value);
2598     client->RoundTrip();
2599
2600     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2601     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2602
2603     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2604     EXPECT_TRUE(policy_surface->mAuxHintName.compare(auxhint_name) == false)
2605         << policy_surface->mAuxHintName << ", " << auxhint_name;
2606     EXPECT_TRUE(policy_surface->mAuxHintValue.compare(auxhint_value) == false)
2607         << policy_surface->mAuxHintValue << ", " << auxhint_value;
2608 }
2609
2610 TEST_F(PolicyTest, Req_PolicySurfaceChangeAuxHint)
2611 {
2612     MockPolicySurface *policy_surface;
2613     uint32_t surface_res_id;
2614     int32_t auxhint_id = 100;
2615     std::string auxhint_value("AUX_HINT_VALUE");
2616     char* c_auxhint_value = const_cast<char *>(auxhint_value.c_str());
2617
2618     tizen_policy_change_aux_hint(policy_res, surface_res, auxhint_id,
2619         c_auxhint_value);
2620     client->RoundTrip();
2621
2622     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2623     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2624
2625     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2626     EXPECT_TRUE(policy_surface->mAuxHintValue.compare(auxhint_value) == false)
2627         << policy_surface->mAuxHintValue << ", " << auxhint_value;
2628 }
2629
2630 TEST_F(PolicyTest, Req_PolicySurfaceDeleteAuxHint)
2631 {
2632     MockPolicySurface *policy_surface;
2633     uint32_t surface_res_id;
2634     int32_t auxhint_id = 100;
2635
2636     tizen_policy_del_aux_hint(policy_res, surface_res, auxhint_id);
2637     client->RoundTrip();
2638
2639     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2640     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2641
2642     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2643 }
2644
2645 TEST_F(PolicyTest, Req_PolicySurfaceGetSupportAuxHints)
2646 {
2647     MockPolicySurface *policy_surface;
2648     uint32_t surface_res_id;
2649
2650     tizen_policy_get_supported_aux_hints(policy_res, surface_res);
2651     client->RoundTrip();
2652
2653     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2654     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2655
2656     EXPECT_TRUE(policy_surface->bGetSupportedAuxHints);
2657 }
2658
2659 TEST_F(PolicyTest, Req_PolicySurfaceSetBackgroundState)
2660 {
2661     int32_t pid = getpid();
2662
2663     tizen_policy_set_background_state(policy_res, pid);
2664     client->RoundTrip();
2665
2666     EXPECT_TRUE(comp->mPid == pid);
2667 }
2668
2669 TEST_F(PolicyTest, Req_PolicySurfaceUnsetBackgroundState)
2670 {
2671     int32_t pid = getpid();
2672
2673     tizen_policy_unset_background_state(policy_res, pid);
2674     client->RoundTrip();
2675
2676     EXPECT_TRUE(comp->mPid == pid);
2677 }
2678
2679 TEST_F(PolicyTest, Req_PolicySurfaceSetFloatingMode)
2680 {
2681     MockPolicySurface *policy_surface;
2682     uint32_t surface_res_id;
2683
2684     tizen_policy_set_floating_mode(policy_res, surface_res);
2685     client->RoundTrip();
2686
2687     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2688     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2689
2690     EXPECT_TRUE(policy_surface->bSetFloatingMode == true);
2691 }
2692
2693 TEST_F(PolicyTest, Req_PolicySurfaceUnsetFloatingMode)
2694 {
2695     MockPolicySurface *policy_surface;
2696     uint32_t surface_res_id;
2697
2698     tizen_policy_unset_floating_mode(policy_res, surface_res);
2699     client->RoundTrip();
2700
2701     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2702     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2703
2704     EXPECT_TRUE(policy_surface->bSetFloatingMode == false);
2705 }
2706
2707 TEST_F(PolicyTest, Req_PolicySurfaceSetStackMode)
2708 {
2709     MockPolicySurface *policy_surface;
2710     uint32_t surface_res_id;
2711
2712     tizen_policy_set_floating_mode(policy_res, surface_res);
2713     client->RoundTrip();
2714
2715     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2716     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2717
2718     EXPECT_TRUE(policy_surface->bSetFloatingMode == true);
2719 }
2720
2721 TEST_F(PolicyTest, Req_PolicySurfaceGetSubsurfaceWatcher)
2722 {
2723     MockPolicySurface *policy_surface;
2724     uint32_t surface_res_id;
2725     struct tizen_subsurface_watcher *subsuface_watcher_res;
2726
2727     subsuface_watcher_res = tizen_policy_get_subsurface_watcher(policy_res, surface_res);
2728     EXPECT_TRUE(subsuface_watcher_res != NULL);
2729
2730     client->RoundTrip();
2731
2732     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2733     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2734
2735     EXPECT_TRUE(policy_surface->bGetSubsurfaceWatcher == true);
2736
2737     tizen_subsurface_watcher_destroy(subsuface_watcher_res);
2738 }
2739
2740 TEST_F(PolicyTest, Req_PolicySurfaceSetParent)
2741 {
2742     MockPolicySurface *policy_surface;
2743     uint32_t surface_res_id;
2744     struct wl_surface *parent_surface_res;
2745
2746     parent_surface_res = wl_compositor_create_surface(compositor_res);
2747     if (!parent_surface_res)
2748         return;
2749
2750     tizen_policy_set_parent(policy_res, surface_res, parent_surface_res);
2751
2752     client->RoundTrip();
2753
2754     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2755     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2756
2757     EXPECT_TRUE(policy_surface->mParentSurface);
2758 }
2759
2760 TEST_F(PolicyTest, Req_PolicySurfaceAckConformantRegion)
2761 {
2762     MockPolicySurface *policy_surface;
2763     uint32_t surface_res_id;
2764     uint32_t serial = 100;
2765
2766     tizen_policy_ack_conformant_region(policy_res, surface_res, serial);
2767
2768     client->RoundTrip();
2769
2770     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2771     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2772
2773     EXPECT_TRUE(policy_surface->mSerial == serial);
2774 }
2775
2776 TEST_F(PolicyTest, Req_PolicySurfaceHasVideo)
2777 {
2778     MockPolicySurface *policy_surface;
2779     uint32_t surface_res_id;
2780     bool has_video = true;
2781
2782     tizen_policy_has_video(policy_res, surface_res, (uint32_t)has_video);
2783
2784     client->RoundTrip();
2785
2786     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2787     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2788
2789     EXPECT_TRUE(policy_surface->bVideo == has_video);
2790 }
2791
2792 TEST_F(PolicyTest, Req_PolicySurfaceShow)
2793 {
2794     MockPolicySurface *policy_surface;
2795     uint32_t surface_res_id;
2796
2797     tizen_policy_show(policy_res, surface_res);
2798     client->RoundTrip();
2799
2800     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2801     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2802
2803     EXPECT_TRUE(policy_surface->bShow == true);
2804 }
2805
2806 TEST_F(PolicyTest, Req_PolicySurfaceHide)
2807 {
2808     MockPolicySurface *policy_surface;
2809     uint32_t surface_res_id;
2810
2811     tizen_policy_hide(policy_res, surface_res);
2812     client->RoundTrip();
2813
2814     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2815     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2816     EXPECT_TRUE(policy_surface->bHide == true);
2817 }
2818
2819 TEST_F(PolicyTest, Req_PolicySurfaceSetParentWithBelow)
2820 {
2821     MockPolicySurface *policy_surface;
2822     uint32_t surface_res_id;
2823     struct wl_surface *parent_surface_res;
2824
2825     parent_surface_res = wl_compositor_create_surface(compositor_res);
2826     if (!parent_surface_res)
2827         return;
2828
2829     tizen_policy_set_parent_with_below(policy_res, surface_res,
2830         parent_surface_res);
2831
2832     client->RoundTrip();
2833
2834     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2835     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2836     EXPECT_TRUE(policy_surface->mParentSurface);
2837 }
2838
2839 TEST_F(PolicyTest, Ev_PolicySurfaceConformant)
2840 {
2841     MockPolicySurface *policy_surface;
2842     uint32_t surface_res_id;
2843     bool is_conformant = true;
2844
2845     tizen_policy_get_conformant(policy_res, surface_res);
2846     client->RoundTrip();
2847
2848     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2849     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2850     EXPECT_TRUE(policy_surface->bGetConformant);
2851
2852     policy_surface->SendConformant(is_conformant);
2853     comp->Process();
2854
2855     client->RoundTrip();
2856     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2857     EXPECT_TRUE(client->mIsConformant == is_conformant);
2858 }
2859
2860 TEST_F(PolicyTest, Ev_PolicySurfaceConformant_Area)
2861 {
2862     MockPolicySurface *policy_surface;
2863     uint32_t surface_res_id;
2864     enum ds_tizen_policy_conformant_part part =
2865         DS_TIZEN_POLICY_CONFORMANT_PART_INDICATOR;
2866     bool visible = 1;
2867     int32_t x = 100, y = 200, w = 300, h = 400;
2868
2869     tizen_policy_get_conformant(policy_res, surface_res);
2870     client->RoundTrip();
2871
2872     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2873     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2874     EXPECT_TRUE(policy_surface->bGetConformant);
2875
2876     policy_surface->SendConformantArea(part, visible, x, y, w, h);
2877     comp->Process();
2878
2879     client->RoundTrip();
2880     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2881     EXPECT_TRUE(client->mConformantPart == TIZEN_POLICY_CONFORMANT_PART_INDICATOR);
2882     EXPECT_TRUE(client->mState == (uint32_t)visible);
2883     EXPECT_TRUE(client->mX == x);
2884     EXPECT_TRUE(client->mY == y);
2885     EXPECT_TRUE(client->mW == w);
2886     EXPECT_TRUE(client->mH == h);
2887 }
2888
2889 TEST_F(PolicyTest, Ev_PolicySurfaceNotificationDone)
2890 {
2891     MockPolicySurface *policy_surface;
2892     uint32_t surface_res_id;
2893     int32_t noti_level = TIZEN_POLICY_LEVEL_HIGH;
2894     enum ds_tizen_policy_notification_level notification_level =
2895         DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH;
2896
2897     tizen_policy_set_notification_level(policy_res, surface_res, noti_level);
2898     client->RoundTrip();
2899
2900     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2901     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2902     EXPECT_TRUE(policy_surface->mNotificationLevel == notification_level);
2903
2904     policy_surface->SendNotificationDone(notification_level,
2905         DS_TIZEN_POLICY_ERROR_STATE_NONE);
2906     comp->Process();
2907
2908     client->RoundTrip();
2909     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2910     EXPECT_TRUE(client->mLevel == noti_level);
2911     EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE);
2912 }
2913
2914 TEST_F(PolicyTest, Ev_PolicySurfaceWindowScreenModeDone)
2915 {
2916     MockPolicySurface *policy_surface;
2917     uint32_t surface_res_id;
2918     uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON;
2919     enum ds_tizen_policy_window_screen_mode window_screen_mode =
2920         DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON;
2921
2922     tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode);
2923     client->RoundTrip();
2924
2925     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2926     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2927     EXPECT_TRUE(policy_surface->mWindowScreenMode == window_screen_mode);
2928
2929     policy_surface->SendWindowScreenModeDone(window_screen_mode,
2930         DS_TIZEN_POLICY_ERROR_STATE_NONE);
2931     comp->Process();
2932
2933     client->RoundTrip();
2934     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2935     EXPECT_TRUE(client->mWindowScreenMode == window_screen_mode);
2936     EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE);
2937 }
2938
2939 TEST_F(PolicyTest, Ev_PolicySurfaceIconifyStateChanged)
2940 {
2941     MockPolicySurface *policy_surface;
2942     uint32_t surface_res_id;
2943     bool iconified = true;
2944     bool force = true;
2945
2946     tizen_policy_iconify(policy_res, surface_res);
2947     client->RoundTrip();
2948
2949     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2950     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2951     EXPECT_TRUE(policy_surface->bIconify == true);
2952
2953     policy_surface->SendIconifyStateChanged(iconified, force);
2954     comp->Process();
2955
2956     client->RoundTrip();
2957     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2958     EXPECT_TRUE(client->mIconified == iconified);
2959     EXPECT_TRUE(client->mForce == force);
2960 }
2961
2962 TEST_F(PolicyTest, Ev_PolicySurfaceSupportedAuxHits)
2963 {
2964     // TODO:
2965 }
2966
2967 TEST_F(PolicyTest, Ev_PolicySurfaceAllowedAuxHint)
2968 {
2969     // TODO:
2970 }
2971
2972 TEST_F(PolicyTest, Ev_PolicySurfaceAuxMessage)
2973 {
2974     // TODO:
2975 }
2976
2977 TEST_F(PolicyTest, Ev_PolicySurfaceConformantRegion)
2978 {
2979 }
2980
2981 TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveModeDone)
2982 {
2983     // TODO:
2984 }
2985
2986 TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveResizeDone)
2987 {
2988     // TODO:
2989 }