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_policy_event_position_set *event =
 137             static_cast<struct ds_tizen_policy_event_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         mNewPositionListener.notify = MockPolicySurface::NewPositionCallback;
 255         mNewPositionListener.parent = this;
 256         ds_tizen_policy_surface_add_new_position_listener(policy_surface,
 257             &mNewPositionListener);
 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         mNewSubsurfaceWatcherListener.notify = MockPolicySurface::NewSubsurfaceWatcherCallback;
 370         mNewSubsurfaceWatcherListener.parent = this;
 371         ds_tizen_policy_surface_add_new_subsurface_watcher_listener(policy_surface,
 372             &mNewSubsurfaceWatcherListener);
 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_policy_surface_event_new_visibility *event =
 448             static_cast<struct ds_tizen_policy_surface_event_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 NewPositionCallback(struct wl_listener *listener, void *data)
 462     {
 463         MockPolicySurface *policySurface =
 464             reinterpret_cast<NewPositionListener *>(listener)->parent;
 465         struct ds_tizen_policy_surface_event_new_position *event =
 466             static_cast<struct ds_tizen_policy_surface_event_new_position *>(data);
 467
 468         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 469         EXPECT_TRUE(event->position != NULL);
 470
 471         policySurface->bNewPosition = 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_policy_surface_event_activate *event =
 484             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_raise *event =
 496             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_lower *event =
 508             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_focus_skip *event =
 520             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_unset_focus_skip *event =
 532             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_role *event =
 544             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_window_type *event =
 555             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_conformant *event =
 567             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_unset_conformant *event =
 579             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_get_conformant *event =
 591             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_notification_level *event =
 603             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_window_screen_mode *event =
 615             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_get_subsurface *event =
 627             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_iconify *event =
 639             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_uniconify *event =
 651             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_add_aux_hint *event =
 663             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_change_aux_hint *event =
 677             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_delete_aux_hint *event =
 690             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_get_supported_aux_hints *event =
 702             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_floating_mode *event =
 714             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_unset_floating_mode *event =
 726             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_stack_mode *event =
 738             static_cast<struct ds_tizen_policy_surface_event_set_stack_mode *>(data);
 739
 740         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 741
 742         policySurface->mStackMode = event->mode;
 743     }
 744
 745     static void NewSubsurfaceWatcherCallback(struct wl_listener *listener, void *data)
 746     {
 747         MockPolicySurface *policySurface =
 748             reinterpret_cast<NewSubsurfaceWatcherListener *>(listener)->parent;
 749         struct ds_tizen_policy_surface_event_new_subsurface_watcher *event =
 750             static_cast<struct ds_tizen_policy_surface_event_new_subsurface_watcher *>(data);
 751
 752         EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
 753         EXPECT_TRUE(event->subsurface_watcher != NULL);
 754
 755         policySurface->bNewSubsurfaceWatcher = 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_policy_surface_event_set_parent *event =
 768             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_ack_conformant_region *event =
 780             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_video *event =
 792             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_show *event =
 804             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_hide *event =
 816             static_cast<struct ds_tizen_policy_surface_event_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_policy_surface_event_set_parent_with_below *event =
 828             static_cast<struct ds_tizen_policy_surface_event_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 *NewPosition()
 849     {
 850         return mPolicyPosition;
 851     }
 852
 853     MockPolicySubsurfaceWatcher*NewSubsurfaceWatcher()
 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 bNewPosition;
 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 bNewSubsurfaceWatcher;
 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 NewPositionListener : ::wl_listener {
 950         MockPolicySurface *parent;
 951     };
 952     NewPositionListener mNewPositionListener;
 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 NewSubsurfaceWatcherListener : ::wl_listener {
1065         MockPolicySurface *parent;
1066     };
1067     NewSubsurfaceWatcherListener mNewSubsurfaceWatcherListener;
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_policy_event_new_surface *event =
1313             static_cast<struct ds_tizen_policy_event_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_policy_event_activate_below_by_univeral_id *event =
1333             static_cast<struct ds_tizen_policy_event_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_policy_event_lower_by_universal_id *event =
1348             static_cast<struct ds_tizen_policy_event_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_policy_event_set_transient_for *event =
1362             static_cast<struct ds_tizen_policy_event_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_policy_event_unset_transient_for *event =
1377             static_cast<struct ds_tizen_policy_event_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_policy_event_place_subsurface_below_parent *event =
1391             static_cast<struct ds_tizen_policy_event_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_policy_event_set_subsurface_stand_alone *event =
1405             static_cast<struct ds_tizen_policy_event_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_policy_event_set_background_state *event =
1416             static_cast<struct ds_tizen_policy_event_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_policy_event_unset_background_state *event =
1427             static_cast<struct ds_tizen_policy_event_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_policy_event_activate_above_by_universal_id *event =
1441             static_cast<struct ds_tizen_policy_event_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_policy_event_set_appid *event =
1456             static_cast<struct ds_tizen_policy_event_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_policy_event_set_transient_for_below *event =
1471             static_cast<struct ds_tizen_policy_event_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            mAngle(0),
1610            mSerial(0),
1611            mVisibilityType(0),
1612            mVisibilityOption(0),
1613            mPositionX(-1), mPositionY(-1)
1614     {}
1615     MockPolicyClient(const struct wl_registry_listener *listener)
1616         : MockClient(listener, this)
1617     {
1618         ds_inf("%s", __func__);
1619     }
1620     ~MockPolicyClient()
1621     {
1622         ds_inf("%s", __func__);
1623     }
1624
1625     void SetWlCompositor(struct wl_compositor *global_res)
1626     {
1627         ds_inf("%s", __func__);
1628
1629         compositor_res = global_res;
1630     }
1631
1632     void SetWlSubCompositor(struct wl_subcompositor *global_res)
1633     {
1634         ds_inf("%s", __func__);
1635
1636         subcompositor_res = global_res;
1637     }
1638
1639     struct wl_compositor *GetWlCompositor()
1640     {
1641         ds_inf("%s", __func__);
1642
1643         return compositor_res;
1644     }
1645
1646     struct wl_subcompositor *GetWlSubCompositor()
1647     {
1648         ds_inf("%s", __func__);
1649
1650         return subcompositor_res;
1651     }
1652
1653     void SetTizenPolicy(struct tizen_policy *resource)
1654     {
1655         ds_inf("%s", __func__);
1656
1657         policy_res = resource;
1658     }
1659
1660     struct tizen_policy *GetTizenPolicy()
1661     {
1662         ds_inf("%s", __func__);
1663
1664         return policy_res;
1665     }
1666
1667 public:
1668     struct wl_surface *mSurfaceRes;
1669     uint32_t mIsConformant;
1670     int32_t mLevel;
1671     uint32_t mErrorState;
1672     uint32_t mChildId;
1673     uint32_t mWindowScreenMode;
1674     uint32_t mIconified;
1675     uint32_t mForce;
1676     struct wl_array *mHints;
1677     uint32_t mNumHints;
1678     int32_t mHintId;
1679     const char *mKey;
1680     const char *mValue;
1681     struct wl_array *mOptions;
1682     uint32_t mConformantPart;
1683     uint32_t mState;
1684     int32_t mX, mY, mW, mH;
1685     int32_t mAngle;
1686     uint32_t mSerial;
1687     uint32_t mVisibilityType;
1688     uint32_t mVisibilityOption;
1689     int32_t mPositionX;
1690     int32_t mPositionY;
1691
1692 private:
1693     struct wl_compositor *compositor_res;
1694     struct wl_subcompositor *subcompositor_res;
1695     struct tizen_policy *policy_res;
1696 };
1697
1698 static void
1699 client_tizen_policy_cb_conformant(void *data, struct tizen_policy *policy_res,
1700     struct wl_surface *surface_resource, uint32_t is_conformant)
1701 {
1702     ds_inf("%s", __func__);
1703
1704     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1705
1706     client->mSurfaceRes = surface_resource;
1707     client->mIsConformant = is_conformant;
1708 }
1709
1710 static void
1711 client_tizen_policy_cb_conformant_area(void *data,
1712     struct tizen_policy *policy_res,
1713     struct wl_surface *surface_resource, uint32_t conformant_part,
1714     uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
1715 {
1716     ds_inf("%s", __func__);
1717
1718     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1719
1720     client->mSurfaceRes = surface_resource;
1721     client->mConformantPart = conformant_part;
1722     client->mState = state;
1723     client->mX = x;
1724     client->mY = y;
1725     client->mW = w;
1726     client->mH = h;
1727 }
1728
1729 static void
1730 client_tizen_policy_cb_notification_done(void *data,
1731     struct tizen_policy *policy_res,
1732     struct wl_surface *surface_resource, int32_t level, uint32_t error_state)
1733 {
1734     ds_inf("%s", __func__);
1735
1736     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1737
1738     client->mSurfaceRes = surface_resource;
1739     client->mLevel = level;
1740     client->mErrorState = error_state;
1741 }
1742
1743 static void
1744 client_tizen_policy_cb_transient_for_done(void *data,
1745     struct tizen_policy *policy_res, uint32_t child_id)
1746 {
1747     ds_inf("%s", __func__);
1748
1749     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1750
1751     client->mChildId = child_id;
1752 }
1753
1754 static void
1755 client_tizen_policy_cb_window_screen_mode_done(void *data,
1756     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1757     uint32_t mode, uint32_t error_state)
1758 {
1759     ds_inf("%s", __func__);
1760
1761     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1762
1763     client->mSurfaceRes = surface_resource;
1764     client->mWindowScreenMode = mode;
1765     client->mErrorState = error_state;
1766 }
1767
1768 static void
1769 client_tizen_policy_cb_iconify_state_changed(void *data,
1770     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1771     uint32_t iconified, uint32_t force)
1772 {
1773     ds_inf("%s", __func__);
1774
1775     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1776
1777     client->mSurfaceRes = surface_resource;
1778     client->mIconified = iconified;
1779     client->mForce = force;
1780 }
1781
1782 static void
1783 client_tizen_policy_cb_supported_aux_hints(void *data,
1784     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1785     struct wl_array *hints, uint32_t num_hints)
1786 {
1787     ds_inf("%s", __func__);
1788
1789     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1790
1791     client->mSurfaceRes = surface_resource;
1792     client->mHints = hints;
1793     client->mNumHints = num_hints;
1794 }
1795
1796 static void
1797 client_tizen_policy_cb_allowed_aux_hint(void *data,
1798     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1799     int32_t id)
1800 {
1801     ds_inf("%s", __func__);
1802
1803     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1804
1805     client->mSurfaceRes = surface_resource;
1806     client->mHintId = id;
1807 }
1808
1809 static void
1810 client_tizen_policy_cb_aux_message(void *data,
1811     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1812     const char *key, const char *value, struct wl_array *options)
1813 {
1814     ds_inf("%s", __func__);
1815
1816     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1817
1818     client->mSurfaceRes = surface_resource;
1819     client->mKey = key;
1820     client->mValue = value;
1821     client->mOptions = options;
1822 }
1823
1824 static void
1825 client_tizen_policy_cb_conformant_region(void *data,
1826     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1827     uint32_t conformant_part, uint32_t state,
1828     int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial)
1829 {
1830     ds_inf("%s", __func__);
1831
1832     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1833
1834     client->mSurfaceRes = surface_resource;
1835     client->mConformantPart = conformant_part;
1836     client->mState = state;
1837     client->mX = x;
1838     client->mY = y;
1839     client->mW = w;
1840     client->mH = h;
1841     client->mSerial = serial;
1842 }
1843
1844 static void
1845 client_tizen_policy_cb_interactive_mode_done(void *data,
1846     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1847     int32_t x, int32_t y, uint32_t w, uint32_t h, int32_t angle)
1848 {
1849     ds_inf("%s", __func__);
1850
1851     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1852
1853     client->mSurfaceRes = surface_resource;
1854     client->mX = x;
1855     client->mY = y;
1856     client->mW = w;
1857     client->mH = h;
1858     client->mAngle = angle;
1859 }
1860
1861 static void
1862 client_tizen_policy_cb_interactive_resize_done(void *data,
1863     struct tizen_policy *policy_res, struct wl_surface *surface_resource,
1864     int32_t x, int32_t y, uint32_t w, uint32_t h, int32_t angle)
1865 {
1866     ds_inf("%s", __func__);
1867
1868     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1869
1870     client->mSurfaceRes = surface_resource;
1871     client->mX = x;
1872     client->mY = y;
1873     client->mW = w;
1874     client->mH = h;
1875     client->mAngle = angle;
1876 }
1877
1878 static const struct
1879 tizen_policy_listener policy_cb_listener =
1880 {
1881    .conformant = client_tizen_policy_cb_conformant,
1882    .conformant_area = client_tizen_policy_cb_conformant_area,
1883    .notification_done = client_tizen_policy_cb_notification_done,
1884    .transient_for_done = client_tizen_policy_cb_transient_for_done,
1885    .window_screen_mode_done = client_tizen_policy_cb_window_screen_mode_done,
1886    .iconify_state_changed = client_tizen_policy_cb_iconify_state_changed,
1887    .supported_aux_hints = client_tizen_policy_cb_supported_aux_hints,
1888    .allowed_aux_hint = client_tizen_policy_cb_allowed_aux_hint,
1889    .aux_message = client_tizen_policy_cb_aux_message,
1890    .conformant_region = client_tizen_policy_cb_conformant_region,
1891    .interactive_move_done = client_tizen_policy_cb_interactive_mode_done,
1892    .interactive_resize_done = client_tizen_policy_cb_interactive_resize_done,
1893 };
1894
1895 static void
1896 client_registry_cb_global(void *data, struct wl_registry *registry,
1897     uint32_t name, const char *interface, uint32_t version)
1898 {
1899     ds_inf("%s", __func__);
1900
1901     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1902     struct wl_compositor *compositor_res;
1903     struct wl_subcompositor *subcompositor_res;
1904     struct tizen_policy *policy_res;
1905
1906     if (!strcmp(interface, "wl_compositor")) {
1907         compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
1908             name, &wl_compositor_interface, 1);
1909         if (compositor_res == nullptr) {
1910             ds_err("wl_registry_bind() failed. wl_compositor resource.");
1911             return;
1912         }
1913         client->SetWlCompositor(compositor_res);
1914     } else if (!strcmp(interface, "wl_subcompositor")) {
1915         subcompositor_res = (struct wl_subcompositor *)
1916            wl_registry_bind(registry, name, &wl_subcompositor_interface, 1);
1917         if (subcompositor_res == nullptr) {
1918             ds_err("wl_registry_bind() failed. wl_subcompositor resource.");
1919             return;
1920         }
1921         client->SetWlSubCompositor(subcompositor_res);
1922     } else if (!strcmp(interface, "tizen_policy")) {
1923         policy_res = (struct tizen_policy *)wl_registry_bind(registry,
1924             name, &tizen_policy_interface, TIZEN_POLICY_VERSION);
1925         if (policy_res == nullptr) {
1926             ds_err("wl_registry_bind() failed. tizen_policy resource.");
1927             return;
1928         }
1929         client->SetTizenPolicy(policy_res);
1930
1931         tizen_policy_add_listener(policy_res,
1932             &policy_cb_listener, client);
1933     }
1934 }
1935
1936 static void
1937 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
1938     uint32_t name)
1939 {
1940     ds_inf("%s", __func__);
1941
1942     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
1943     struct wl_compositor *compositor_res = client->GetWlCompositor();
1944     struct tizen_policy *policy_res = client->GetTizenPolicy();
1945
1946     tizen_policy_destroy(policy_res);
1947     wl_compositor_destroy(compositor_res);
1948 }
1949
1950 static const struct wl_registry_listener registry_listener = {
1951     .global = client_registry_cb_global,
1952     .global_remove = client_registry_cb_global_remove
1953 };
1954
1955 class PolicyTest : public ::testing::Test
1956 {
1957 public:
1958     void SetUp(void) override;
1959     void TearDown(void) override;
1960
1961     MockPolicyCompositor *comp;
1962     MockPolicyClient *client;
1963     struct wl_compositor *compositor_res;
1964     struct wl_subcompositor *subcompositor_res;
1965     struct tizen_policy *policy_res;
1966     struct wl_surface *surface_res;
1967 };
1968
1969 void
1970 PolicyTest::SetUp(void)
1971 {
1972     //ds_log_init(DS_DBG, NULL);
1973
1974     ds_inf("%s", __func__);
1975
1976     comp = new MockPolicyCompositor();
1977     client = new MockPolicyClient(&registry_listener);
1978     compositor_res = client->GetWlCompositor();
1979     subcompositor_res = client->GetWlSubCompositor();
1980     policy_res = client->GetTizenPolicy();
1981     surface_res = wl_compositor_create_surface(compositor_res);
1982
1983     client->RoundTrip();
1984 }
1985
1986 void
1987 PolicyTest::TearDown(void)
1988 {
1989     ds_inf("%s", __func__);
1990
1991     wl_surface_destroy(surface_res);
1992     client->RoundTrip();
1993
1994     delete client;
1995     delete comp;
1996 }
1997
1998 TEST_F(PolicyTest, Create_P)
1999 {
2000     EXPECT_TRUE(true);
2001 }
2002
2003 TEST_F(PolicyTest, Req_ActivateBelowByUniversalId)
2004 {
2005     uint32_t universal_id = 100;
2006     uint32_t below_universal_id = 200;
2007
2008     tizen_policy_activate_below_by_res_id(policy_res,
2009         universal_id, below_universal_id);
2010     client->RoundTrip();
2011
2012     EXPECT_TRUE(comp->mUniversalId == universal_id)
2013         << comp->mUniversalId << ", " << universal_id;
2014     EXPECT_TRUE(comp->mBelowUniversalId == below_universal_id)
2015         << comp->mBelowUniversalId << ", " << below_universal_id;
2016 }
2017
2018 TEST_F(PolicyTest, Req_LowerByUniversalId)
2019 {
2020     uint32_t universal_id = 100;
2021
2022     tizen_policy_lower_by_res_id(policy_res,universal_id);
2023     client->RoundTrip();
2024
2025     EXPECT_TRUE(comp->mUniversalId == universal_id)
2026         << comp->mUniversalId << ", " << universal_id;
2027 }
2028
2029 TEST_F(PolicyTest, Req_SetTransientFor)
2030 {
2031     uint32_t child_universal_id = 100;
2032     uint32_t parent_universal_id = 200;
2033
2034     tizen_policy_set_transient_for(policy_res,
2035         child_universal_id, parent_universal_id);
2036     client->RoundTrip();
2037
2038     EXPECT_TRUE(comp->mChildUniversalId == child_universal_id)
2039         << comp->mChildUniversalId << ", " << child_universal_id;
2040     EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id)
2041         << comp->mParentUniversalId << ", " << parent_universal_id;
2042
2043     EXPECT_TRUE(client->mChildId == child_universal_id);
2044 }
2045
2046 TEST_F(PolicyTest, Req_UnsetTransientFor)
2047 {
2048     uint32_t child_universal_id = 100;
2049
2050     tizen_policy_unset_transient_for(policy_res, child_universal_id);
2051     client->RoundTrip();
2052
2053     EXPECT_TRUE(comp->mChildUniversalId == child_universal_id)
2054         << comp->mChildUniversalId << ", " << child_universal_id;
2055
2056     EXPECT_TRUE(client->mChildId == child_universal_id);
2057 }
2058
2059 TEST_F(PolicyTest, Req_PlaceSubsurfaceBelowParent)
2060 {
2061     struct wl_surface *parent_surface_res;
2062     struct wl_subsurface *subsurface_res;
2063
2064     parent_surface_res = wl_compositor_create_surface(compositor_res);
2065     if (!parent_surface_res)
2066         return;
2067
2068     subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res,
2069         surface_res, parent_surface_res);
2070     if (!subsurface_res) {
2071         wl_surface_destroy(parent_surface_res);
2072         return;
2073      }
2074
2075     tizen_policy_place_subsurface_below_parent(policy_res, subsurface_res);
2076     client->RoundTrip();
2077
2078     EXPECT_TRUE(comp->bPlaceSubsurfaceBelowParent);
2079
2080     wl_subsurface_destroy(subsurface_res);
2081     wl_surface_destroy(parent_surface_res);
2082 }
2083
2084 TEST_F(PolicyTest, Req_SetSubsurfaceStandAlone)
2085 {
2086     struct wl_surface *parent_surface_res;
2087     struct wl_subsurface *subsurface_res;
2088
2089     parent_surface_res = wl_compositor_create_surface(compositor_res);
2090     if (!parent_surface_res)
2091         return;
2092
2093     subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res,
2094         surface_res, parent_surface_res);
2095     if (!subsurface_res) {
2096         wl_surface_destroy(parent_surface_res);
2097         return;
2098      }
2099
2100     tizen_policy_set_subsurface_stand_alone(policy_res, subsurface_res);
2101     client->RoundTrip();
2102
2103     EXPECT_TRUE(comp->bSetSubsurfaceStandAlone);
2104
2105     wl_subsurface_destroy(subsurface_res);
2106     wl_surface_destroy(parent_surface_res);
2107 }
2108
2109 TEST_F(PolicyTest, Req_ActivateAboveByUniversalId)
2110 {
2111     uint32_t universal_id = 100;
2112     uint32_t above_universal_id = 100;
2113
2114     tizen_policy_activate_above_by_res_id(policy_res, universal_id,
2115         above_universal_id);
2116     client->RoundTrip();
2117
2118     EXPECT_TRUE(comp->mUniversalId == universal_id)
2119         << comp->mUniversalId << ", " << universal_id;
2120     EXPECT_TRUE(comp->mAboveUniversalId == above_universal_id)
2121         << comp->mAboveUniversalId << ", " << above_universal_id;
2122 }
2123
2124 TEST_F(PolicyTest, Req_SetAppId)
2125 {
2126     int32_t pid = getpid();
2127     std::string appid("APPLICATION_ID");
2128     char* c_appid = const_cast<char *>(appid.c_str());
2129
2130     tizen_policy_set_appid(policy_res, pid, c_appid);
2131     client->RoundTrip();
2132
2133     EXPECT_TRUE(comp->mPid == pid)
2134         << comp->mPid << ", " << pid;
2135     EXPECT_EQ(comp->mAppId, appid)
2136         << comp->mAppId << ", " << appid;
2137 }
2138
2139 TEST_F(PolicyTest, Req_SetTransientForBelow)
2140 {
2141     uint32_t universal_id = 100;
2142     uint32_t parent_universal_id = 200;
2143
2144     tizen_policy_set_transient_for_below(policy_res, universal_id,
2145         parent_universal_id);
2146     client->RoundTrip();
2147
2148     EXPECT_TRUE(comp->mUniversalId == universal_id)
2149         << comp->mUniversalId << ", " << universal_id;
2150     EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id)
2151         << comp->mParentUniversalId << ", " << parent_universal_id;
2152 }
2153
2154 static void
2155 client_tizen_visibility_cb_notify(void *data,
2156     struct tizen_visibility *visibility_res, uint32_t visibility)
2157 {
2158     ds_inf("%s", __func__);
2159
2160     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2161
2162     client->mVisibilityType = visibility;
2163 }
2164
2165 static void
2166 client_tizen_visibility_cb_changed(void *data,
2167     struct tizen_visibility *visibility_res, uint32_t type, uint32_t option)
2168 {
2169     ds_inf("%s", __func__);
2170
2171     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2172
2173     client->mVisibilityType = type;
2174     client->mVisibilityOption = option;
2175 }
2176
2177 static const struct
2178 tizen_visibility_listener visibility_cb_listener =
2179 {
2180    .notify = client_tizen_visibility_cb_notify,
2181    .changed = client_tizen_visibility_cb_changed,
2182 };
2183
2184 TEST_F(PolicyTest, Req_PolicySurfaceNewVisibility)
2185 {
2186     MockPolicySurface *policy_surface;
2187     MockPolicyVisibility *visibility;
2188     struct tizen_visibility *visibility_res;
2189     uint32_t surface_res_id;
2190
2191     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2192     EXPECT_TRUE(visibility_res != NULL);
2193
2194     tizen_visibility_add_listener(visibility_res,
2195             &visibility_cb_listener, client);
2196     client->RoundTrip();
2197
2198     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2199     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2200     EXPECT_TRUE(policy_surface->bNewVisibility);
2201
2202     visibility = policy_surface->NewVisibility();
2203
2204     tizen_visibility_destroy(visibility_res);
2205     client->RoundTrip();
2206
2207     EXPECT_TRUE(visibility->bDestroyed);
2208 }
2209
2210 TEST_F(PolicyTest, Ev_VisibilityNotify)
2211 {
2212     MockPolicySurface *policy_surface;
2213     MockPolicyVisibility *visibility;
2214     struct tizen_visibility *visibility_res;
2215     enum ds_tizen_policy_visibility_type type =
2216         DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED;
2217     uint32_t surface_res_id;
2218
2219     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2220     EXPECT_TRUE(visibility_res != NULL);
2221
2222     tizen_visibility_add_listener(visibility_res,
2223             &visibility_cb_listener, client);
2224     client->RoundTrip();
2225
2226     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2227     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2228     EXPECT_TRUE(policy_surface->bNewVisibility);
2229
2230     visibility = policy_surface->NewVisibility();
2231     visibility->SendNotify(type);
2232     comp->Process();
2233
2234     client->RoundTrip();
2235     EXPECT_TRUE(client->mVisibilityType ==
2236         TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED);
2237
2238     tizen_visibility_destroy(visibility_res);
2239     client->RoundTrip();
2240
2241     EXPECT_TRUE(visibility->bDestroyed);
2242 }
2243
2244 TEST_F(PolicyTest, Ev_VisibilityChanged)
2245 {
2246     MockPolicySurface *policy_surface;
2247     MockPolicyVisibility *visibility;
2248     struct tizen_visibility *visibility_res;
2249     enum ds_tizen_policy_visibility_type type =
2250         DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED;
2251     uint32_t surface_res_id;
2252     uint32_t option = 4;
2253
2254     visibility_res = tizen_policy_get_visibility(policy_res, surface_res);
2255     EXPECT_TRUE(visibility_res != NULL);
2256
2257     tizen_visibility_add_listener(visibility_res,
2258             &visibility_cb_listener, client);
2259     client->RoundTrip();
2260
2261     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2262     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2263     EXPECT_TRUE(policy_surface->bNewVisibility);
2264
2265     visibility = policy_surface->NewVisibility();
2266     visibility->SendChanged(type, option);
2267     comp->Process();
2268
2269     client->RoundTrip();
2270     EXPECT_TRUE(client->mVisibilityType ==
2271         TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED);
2272     EXPECT_TRUE(client->mVisibilityOption == option);
2273
2274     tizen_visibility_destroy(visibility_res);
2275     client->RoundTrip();
2276
2277     EXPECT_TRUE(visibility->bDestroyed);
2278 }
2279
2280 static void
2281 client_tizen_position_cb_changed(void *data,
2282     struct tizen_position *position_res, int32_t x, int32_t y)
2283 {
2284     ds_inf("%s", __func__);
2285
2286     MockPolicyClient *client = static_cast<MockPolicyClient *>(data);
2287
2288     client->mPositionX = x;
2289     client->mPositionY = y;
2290 }
2291
2292 static const struct
2293 tizen_position_listener position_cb_listener =
2294 {
2295    .changed = client_tizen_position_cb_changed,
2296 };
2297
2298 TEST_F(PolicyTest, Req_PolicySurfaceNewPosition)
2299 {
2300     MockPolicySurface *policy_surface;
2301     struct tizen_position *position_res;
2302     uint32_t surface_res_id;
2303
2304     position_res = tizen_policy_get_position(policy_res, surface_res);
2305     EXPECT_TRUE(position_res != NULL);
2306
2307     tizen_position_add_listener(position_res,
2308             &position_cb_listener, client);
2309     client->RoundTrip();
2310
2311     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2312     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2313     EXPECT_TRUE(policy_surface->bNewPosition);
2314
2315     tizen_position_destroy(position_res);
2316 }
2317
2318 TEST_F(PolicyTest, Req_PositionSet)
2319 {
2320     MockPolicySurface *policy_surface;
2321     MockPolicyPosition *position;
2322     struct tizen_position *position_res;
2323     uint32_t surface_res_id;
2324     int32_t x = 100, y = 200;
2325
2326     position_res = tizen_policy_get_position(policy_res, surface_res);
2327     EXPECT_TRUE(position_res != NULL);
2328
2329     tizen_position_add_listener(position_res,
2330             &position_cb_listener, client);
2331
2332     tizen_position_set(position_res, x, y);
2333     client->RoundTrip();
2334
2335     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2336     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2337     EXPECT_TRUE(policy_surface->bNewPosition);
2338
2339     position = policy_surface->NewPosition();
2340     EXPECT_TRUE(position->mX == x);
2341     EXPECT_TRUE(position->mY == y);
2342
2343     tizen_position_destroy(position_res);
2344 }
2345
2346 TEST_F(PolicyTest, Ev_PositionChanged)
2347 {
2348     MockPolicySurface *policy_surface;
2349     MockPolicyPosition *position;
2350     struct tizen_position *position_res;
2351     uint32_t surface_res_id;
2352     int32_t x = 100, y = 200;
2353
2354     position_res = tizen_policy_get_position(policy_res, surface_res);
2355     EXPECT_TRUE(position_res != NULL);
2356
2357     tizen_position_add_listener(position_res,
2358             &position_cb_listener, client);
2359     client->RoundTrip();
2360
2361     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2362     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2363     EXPECT_TRUE(policy_surface->bNewPosition);
2364
2365     position = policy_surface->NewPosition();
2366     position->SendChanged(x, y);
2367     comp->Process();
2368
2369     client->RoundTrip();
2370     EXPECT_TRUE(client->mPositionX == x);
2371     EXPECT_TRUE(client->mPositionY == y);
2372
2373     tizen_position_destroy(position_res);
2374 }
2375
2376 TEST_F(PolicyTest, Req_PolicySurfaceActivate)
2377 {
2378     MockPolicySurface *policy_surface;
2379     uint32_t surface_res_id;
2380
2381     tizen_policy_activate(policy_res, surface_res);
2382     client->RoundTrip();
2383
2384     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2385     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2386     EXPECT_TRUE(policy_surface->bActivate);
2387 }
2388
2389 TEST_F(PolicyTest, Req_PolicySurfaceRaise)
2390 {
2391     MockPolicySurface *policy_surface;
2392     uint32_t surface_res_id;
2393
2394     tizen_policy_raise(policy_res, surface_res);
2395     client->RoundTrip();
2396
2397     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2398     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2399     EXPECT_TRUE(policy_surface->bRaise);
2400 }
2401
2402 TEST_F(PolicyTest, Req_PolicySurfaceLower)
2403 {
2404     MockPolicySurface *policy_surface;
2405     uint32_t surface_res_id;
2406
2407     tizen_policy_lower(policy_res, surface_res);
2408     client->RoundTrip();
2409
2410     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2411     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2412     EXPECT_TRUE(policy_surface->bLower);
2413 }
2414
2415 TEST_F(PolicyTest, Req_PolicySurfaceSetFocusSkip)
2416 {
2417     MockPolicySurface *policy_surface;
2418     uint32_t surface_res_id;
2419
2420     tizen_policy_set_focus_skip(policy_res, surface_res);
2421     client->RoundTrip();
2422
2423     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2424     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2425     EXPECT_TRUE(policy_surface->bSetFocusSkip);
2426 }
2427
2428 TEST_F(PolicyTest, Req_PolicySurfaceUnsetFocusSkip)
2429 {
2430     MockPolicySurface *policy_surface;
2431     uint32_t surface_res_id;
2432
2433     tizen_policy_unset_focus_skip(policy_res, surface_res);
2434     client->RoundTrip();
2435
2436     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2437     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2438     EXPECT_TRUE(policy_surface->bSetFocusSkip == false);
2439 }
2440
2441 TEST_F(PolicyTest, Req_PolicySurfaceSetRole)
2442 {
2443     MockPolicySurface *policy_surface;
2444     uint32_t surface_res_id;
2445     std::string role("APPLICATION_ID");
2446     char* c_role = const_cast<char *>(role.c_str());
2447
2448     tizen_policy_set_role(policy_res, surface_res, c_role);
2449     client->RoundTrip();
2450
2451     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2452     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2453
2454     EXPECT_EQ(policy_surface->mRole, role)
2455         << policy_surface->mRole << ", " << role;
2456 }
2457
2458 TEST_F(PolicyTest, Req_PolicySurfaceSetType)
2459 {
2460     MockPolicySurface *policy_surface;
2461     uint32_t surface_res_id;
2462     uint32_t win_type = TIZEN_POLICY_WIN_TYPE_TOPLEVEL;
2463
2464     tizen_policy_set_type(policy_res, surface_res, win_type);
2465     client->RoundTrip();
2466
2467     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2468     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2469
2470     EXPECT_TRUE(policy_surface->mWinType == DS_TIZEN_POLICY_WINDOW_TYPE_TOPLEVEL);
2471 }
2472
2473 TEST_F(PolicyTest, Req_PolicySurfaceSetConformant)
2474 {
2475     MockPolicySurface *policy_surface;
2476     uint32_t surface_res_id;
2477
2478     tizen_policy_set_conformant(policy_res, surface_res);
2479     client->RoundTrip();
2480
2481     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2482     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2483
2484     EXPECT_TRUE(policy_surface->bSetConformant == true);
2485 }
2486
2487 TEST_F(PolicyTest, Req_PolicySurfaceUnsetConformant)
2488 {
2489     MockPolicySurface *policy_surface;
2490     uint32_t surface_res_id;
2491
2492     tizen_policy_unset_conformant(policy_res, surface_res);
2493     client->RoundTrip();
2494
2495     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2496     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2497
2498     EXPECT_TRUE(policy_surface->bSetConformant == false);
2499 }
2500
2501 TEST_F(PolicyTest, Req_Ev_PolicySurfaceGetConformant)
2502 {
2503     MockPolicySurface *policy_surface;
2504     uint32_t surface_res_id;
2505
2506     tizen_policy_get_conformant(policy_res, surface_res);
2507     client->RoundTrip();
2508
2509     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2510     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2511
2512     EXPECT_TRUE(policy_surface->bGetConformant == true);
2513 }
2514
2515 TEST_F(PolicyTest, Req_PolicySurfaceSetNotificationLevel)
2516 {
2517     MockPolicySurface *policy_surface;
2518     uint32_t surface_res_id;
2519     uint32_t noti_level = TIZEN_POLICY_LEVEL_HIGH;
2520
2521     tizen_policy_set_notification_level(policy_res, surface_res, noti_level);
2522     client->RoundTrip();
2523
2524     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2525     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2526
2527     EXPECT_TRUE(policy_surface->mNotificationLevel == DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH);
2528 }
2529
2530 TEST_F(PolicyTest, Req_PolicySurfaceSetWindowScreenMode)
2531 {
2532     MockPolicySurface *policy_surface;
2533     uint32_t surface_res_id;
2534     uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON;
2535
2536     tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode);
2537     client->RoundTrip();
2538
2539     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2540     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2541
2542     EXPECT_TRUE(policy_surface->mWindowScreenMode == DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON);
2543 }
2544
2545 TEST_F(PolicyTest, Req_PolicySurfaceGetSubsurface)
2546 {
2547     MockPolicySurface *policy_surface;
2548     uint32_t surface_res_id;
2549     struct wl_subsurface *subsurface_res;
2550     uint32_t parent_universal_id = 100;
2551
2552     subsurface_res = tizen_policy_get_subsurface(policy_res, surface_res, parent_universal_id);
2553     EXPECT_TRUE(subsurface_res != NULL);
2554     client->RoundTrip();
2555
2556     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2557     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2558
2559     EXPECT_TRUE(policy_surface->mParentUniversalId == parent_universal_id);
2560 }
2561
2562 TEST_F(PolicyTest, Req_PolicySurfaceIconify)
2563 {
2564     MockPolicySurface *policy_surface;
2565     uint32_t surface_res_id;
2566
2567     tizen_policy_iconify(policy_res, surface_res);
2568     client->RoundTrip();
2569
2570     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2571     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2572
2573     EXPECT_TRUE(policy_surface->bIconify == true);
2574 }
2575
2576 TEST_F(PolicyTest, Req_PolicySurfaceUniconify)
2577 {
2578     MockPolicySurface *policy_surface;
2579     uint32_t surface_res_id;
2580
2581     tizen_policy_uniconify(policy_res, surface_res);
2582     client->RoundTrip();
2583
2584     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2585     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2586
2587     EXPECT_TRUE(policy_surface->bIconify == false);
2588 }
2589
2590 TEST_F(PolicyTest, Req_PolicySurfaceAddAuxHint)
2591 {
2592     MockPolicySurface *policy_surface;
2593     uint32_t surface_res_id;
2594     int32_t auxhint_id = 100;
2595     std::string auxhint_name("AUX_HINT_NAME");
2596     std::string auxhint_value("AUX_HINT_VALUE");
2597     char* c_auxhint_name = const_cast<char *>(auxhint_name.c_str());
2598     char* c_auxhint_value = const_cast<char *>(auxhint_value.c_str());
2599
2600     tizen_policy_add_aux_hint(policy_res, surface_res, auxhint_id,
2601         c_auxhint_name, c_auxhint_value);
2602     client->RoundTrip();
2603
2604     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2605     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2606
2607     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2608     EXPECT_EQ(policy_surface->mAuxHintName, auxhint_name)
2609         << policy_surface->mAuxHintName << ", " << auxhint_name;
2610     EXPECT_EQ(policy_surface->mAuxHintValue, auxhint_value)
2611         << policy_surface->mAuxHintValue << ", " << auxhint_value;
2612 }
2613
2614 TEST_F(PolicyTest, Req_PolicySurfaceChangeAuxHint)
2615 {
2616     MockPolicySurface *policy_surface;
2617     uint32_t surface_res_id;
2618     int32_t auxhint_id = 100;
2619     std::string auxhint_value("AUX_HINT_VALUE");
2620     char* c_auxhint_value = const_cast<char *>(auxhint_value.c_str());
2621
2622     tizen_policy_change_aux_hint(policy_res, surface_res, auxhint_id,
2623         c_auxhint_value);
2624     client->RoundTrip();
2625
2626     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2627     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2628
2629     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2630     EXPECT_EQ(policy_surface->mAuxHintValue, auxhint_value)
2631         << policy_surface->mAuxHintValue << ", " << auxhint_value;
2632 }
2633
2634 TEST_F(PolicyTest, Req_PolicySurfaceDeleteAuxHint)
2635 {
2636     MockPolicySurface *policy_surface;
2637     uint32_t surface_res_id;
2638     int32_t auxhint_id = 100;
2639
2640     tizen_policy_del_aux_hint(policy_res, surface_res, auxhint_id);
2641     client->RoundTrip();
2642
2643     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2644     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2645
2646     EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id);
2647 }
2648
2649 TEST_F(PolicyTest, Req_PolicySurfaceGetSupportAuxHints)
2650 {
2651     MockPolicySurface *policy_surface;
2652     uint32_t surface_res_id;
2653
2654     tizen_policy_get_supported_aux_hints(policy_res, surface_res);
2655     client->RoundTrip();
2656
2657     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2658     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2659
2660     EXPECT_TRUE(policy_surface->bGetSupportedAuxHints);
2661 }
2662
2663 TEST_F(PolicyTest, Req_PolicySurfaceSetBackgroundState)
2664 {
2665     int32_t pid = getpid();
2666
2667     tizen_policy_set_background_state(policy_res, pid);
2668     client->RoundTrip();
2669
2670     EXPECT_TRUE(comp->mPid == pid);
2671 }
2672
2673 TEST_F(PolicyTest, Req_PolicySurfaceUnsetBackgroundState)
2674 {
2675     int32_t pid = getpid();
2676
2677     tizen_policy_unset_background_state(policy_res, pid);
2678     client->RoundTrip();
2679
2680     EXPECT_TRUE(comp->mPid == pid);
2681 }
2682
2683 TEST_F(PolicyTest, Req_PolicySurfaceSetFloatingMode)
2684 {
2685     MockPolicySurface *policy_surface;
2686     uint32_t surface_res_id;
2687
2688     tizen_policy_set_floating_mode(policy_res, surface_res);
2689     client->RoundTrip();
2690
2691     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2692     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2693
2694     EXPECT_TRUE(policy_surface->bSetFloatingMode == true);
2695 }
2696
2697 TEST_F(PolicyTest, Req_PolicySurfaceUnsetFloatingMode)
2698 {
2699     MockPolicySurface *policy_surface;
2700     uint32_t surface_res_id;
2701
2702     tizen_policy_unset_floating_mode(policy_res, surface_res);
2703     client->RoundTrip();
2704
2705     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2706     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2707
2708     EXPECT_TRUE(policy_surface->bSetFloatingMode == false);
2709 }
2710
2711 TEST_F(PolicyTest, Req_PolicySurfaceSetStackMode)
2712 {
2713     MockPolicySurface *policy_surface;
2714     uint32_t surface_res_id;
2715
2716     tizen_policy_set_floating_mode(policy_res, surface_res);
2717     client->RoundTrip();
2718
2719     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2720     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2721
2722     EXPECT_TRUE(policy_surface->bSetFloatingMode == true);
2723 }
2724
2725 TEST_F(PolicyTest, Req_PolicySurfaceNewSubsurfaceWatcher)
2726 {
2727     MockPolicySurface *policy_surface;
2728     uint32_t surface_res_id;
2729     struct tizen_subsurface_watcher *subsuface_watcher_res;
2730
2731     subsuface_watcher_res = tizen_policy_get_subsurface_watcher(policy_res, surface_res);
2732     EXPECT_TRUE(subsuface_watcher_res != NULL);
2733
2734     client->RoundTrip();
2735
2736     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2737     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2738
2739     EXPECT_TRUE(policy_surface->bNewSubsurfaceWatcher == true);
2740
2741     tizen_subsurface_watcher_destroy(subsuface_watcher_res);
2742 }
2743
2744 TEST_F(PolicyTest, Req_PolicySurfaceSetParent)
2745 {
2746     MockPolicySurface *policy_surface;
2747     uint32_t surface_res_id;
2748     struct wl_surface *parent_surface_res;
2749
2750     parent_surface_res = wl_compositor_create_surface(compositor_res);
2751     if (!parent_surface_res)
2752         return;
2753
2754     tizen_policy_set_parent(policy_res, surface_res, parent_surface_res);
2755
2756     client->RoundTrip();
2757
2758     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2759     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2760
2761     EXPECT_TRUE(policy_surface->mParentSurface);
2762 }
2763
2764 TEST_F(PolicyTest, Req_PolicySurfaceAckConformantRegion)
2765 {
2766     MockPolicySurface *policy_surface;
2767     uint32_t surface_res_id;
2768     uint32_t serial = 100;
2769
2770     tizen_policy_ack_conformant_region(policy_res, surface_res, serial);
2771
2772     client->RoundTrip();
2773
2774     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2775     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2776
2777     EXPECT_TRUE(policy_surface->mSerial == serial);
2778 }
2779
2780 TEST_F(PolicyTest, Req_PolicySurfaceHasVideo)
2781 {
2782     MockPolicySurface *policy_surface;
2783     uint32_t surface_res_id;
2784     bool has_video = true;
2785
2786     tizen_policy_has_video(policy_res, surface_res, (uint32_t)has_video);
2787
2788     client->RoundTrip();
2789
2790     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2791     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2792
2793     EXPECT_TRUE(policy_surface->bVideo == has_video);
2794 }
2795
2796 TEST_F(PolicyTest, Req_PolicySurfaceShow)
2797 {
2798     MockPolicySurface *policy_surface;
2799     uint32_t surface_res_id;
2800
2801     tizen_policy_show(policy_res, surface_res);
2802     client->RoundTrip();
2803
2804     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2805     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2806
2807     EXPECT_TRUE(policy_surface->bShow == true);
2808 }
2809
2810 TEST_F(PolicyTest, Req_PolicySurfaceHide)
2811 {
2812     MockPolicySurface *policy_surface;
2813     uint32_t surface_res_id;
2814
2815     tizen_policy_hide(policy_res, surface_res);
2816     client->RoundTrip();
2817
2818     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2819     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2820     EXPECT_TRUE(policy_surface->bHide == true);
2821 }
2822
2823 TEST_F(PolicyTest, Req_PolicySurfaceSetParentWithBelow)
2824 {
2825     MockPolicySurface *policy_surface;
2826     uint32_t surface_res_id;
2827     struct wl_surface *parent_surface_res;
2828
2829     parent_surface_res = wl_compositor_create_surface(compositor_res);
2830     if (!parent_surface_res)
2831         return;
2832
2833     tizen_policy_set_parent_with_below(policy_res, surface_res,
2834         parent_surface_res);
2835
2836     client->RoundTrip();
2837
2838     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2839     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2840     EXPECT_TRUE(policy_surface->mParentSurface);
2841 }
2842
2843 TEST_F(PolicyTest, Ev_PolicySurfaceConformant)
2844 {
2845     MockPolicySurface *policy_surface;
2846     uint32_t surface_res_id;
2847     bool is_conformant = true;
2848
2849     tizen_policy_get_conformant(policy_res, surface_res);
2850     client->RoundTrip();
2851
2852     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2853     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2854     EXPECT_TRUE(policy_surface->bGetConformant);
2855
2856     policy_surface->SendConformant(is_conformant);
2857     comp->Process();
2858
2859     client->RoundTrip();
2860     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2861     EXPECT_TRUE(client->mIsConformant == is_conformant);
2862 }
2863
2864 TEST_F(PolicyTest, Ev_PolicySurfaceConformant_Area)
2865 {
2866     MockPolicySurface *policy_surface;
2867     uint32_t surface_res_id;
2868     enum ds_tizen_policy_conformant_part part =
2869         DS_TIZEN_POLICY_CONFORMANT_PART_INDICATOR;
2870     bool visible = 1;
2871     int32_t x = 100, y = 200, w = 300, h = 400;
2872
2873     tizen_policy_get_conformant(policy_res, surface_res);
2874     client->RoundTrip();
2875
2876     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2877     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2878     EXPECT_TRUE(policy_surface->bGetConformant);
2879
2880     policy_surface->SendConformantArea(part, visible, x, y, w, h);
2881     comp->Process();
2882
2883     client->RoundTrip();
2884     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2885     EXPECT_TRUE(client->mConformantPart == TIZEN_POLICY_CONFORMANT_PART_INDICATOR);
2886     EXPECT_TRUE(client->mState == (uint32_t)visible);
2887     EXPECT_TRUE(client->mX == x);
2888     EXPECT_TRUE(client->mY == y);
2889     EXPECT_TRUE(client->mW == w);
2890     EXPECT_TRUE(client->mH == h);
2891 }
2892
2893 TEST_F(PolicyTest, Ev_PolicySurfaceNotificationDone)
2894 {
2895     MockPolicySurface *policy_surface;
2896     uint32_t surface_res_id;
2897     int32_t noti_level = TIZEN_POLICY_LEVEL_HIGH;
2898     enum ds_tizen_policy_notification_level notification_level =
2899         DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH;
2900
2901     tizen_policy_set_notification_level(policy_res, surface_res, noti_level);
2902     client->RoundTrip();
2903
2904     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2905     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2906     EXPECT_TRUE(policy_surface->mNotificationLevel == notification_level);
2907
2908     policy_surface->SendNotificationDone(notification_level,
2909         DS_TIZEN_POLICY_ERROR_STATE_NONE);
2910     comp->Process();
2911
2912     client->RoundTrip();
2913     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2914     EXPECT_TRUE(client->mLevel == noti_level);
2915     EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE);
2916 }
2917
2918 TEST_F(PolicyTest, Ev_PolicySurfaceWindowScreenModeDone)
2919 {
2920     MockPolicySurface *policy_surface;
2921     uint32_t surface_res_id;
2922     uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON;
2923     enum ds_tizen_policy_window_screen_mode window_screen_mode =
2924         DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON;
2925
2926     tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode);
2927     client->RoundTrip();
2928
2929     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2930     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2931     EXPECT_TRUE(policy_surface->mWindowScreenMode == window_screen_mode);
2932
2933     policy_surface->SendWindowScreenModeDone(window_screen_mode,
2934         DS_TIZEN_POLICY_ERROR_STATE_NONE);
2935     comp->Process();
2936
2937     client->RoundTrip();
2938     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2939     EXPECT_TRUE(client->mWindowScreenMode == window_screen_mode);
2940     EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE);
2941 }
2942
2943 TEST_F(PolicyTest, Ev_PolicySurfaceIconifyStateChanged)
2944 {
2945     MockPolicySurface *policy_surface;
2946     uint32_t surface_res_id;
2947     bool iconified = true;
2948     bool force = true;
2949
2950     tizen_policy_iconify(policy_res, surface_res);
2951     client->RoundTrip();
2952
2953     surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res);
2954     policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id);
2955     EXPECT_TRUE(policy_surface->bIconify == true);
2956
2957     policy_surface->SendIconifyStateChanged(iconified, force);
2958     comp->Process();
2959
2960     client->RoundTrip();
2961     EXPECT_TRUE(client->mSurfaceRes == surface_res);
2962     EXPECT_TRUE(client->mIconified == iconified);
2963     EXPECT_TRUE(client->mForce == force);
2964 }
2965
2966 TEST_F(PolicyTest, Ev_PolicySurfaceSupportedAuxHits)
2967 {
2968     // TODO:
2969 }
2970
2971 TEST_F(PolicyTest, Ev_PolicySurfaceAllowedAuxHint)
2972 {
2973     // TODO:
2974 }
2975
2976 TEST_F(PolicyTest, Ev_PolicySurfaceAuxMessage)
2977 {
2978     // TODO:
2979 }
2980
2981 TEST_F(PolicyTest, Ev_PolicySurfaceConformantRegion)
2982 {
2983 }
2984
2985 TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveModeDone)
2986 {
2987     // TODO:
2988 }
2989
2990 TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveResizeDone)
2991 {
2992     // TODO:
2993 }