From a19d23162d919defba77e0be189803d68de51fb3 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Sun, 28 Aug 2022 13:05:36 +0900 Subject: [PATCH] add testcases for ds_tizen_policy Change-Id: Ia93e8f7caf52713beaf6dd175f2443337252266e --- packaging/libds-tizen.spec | 1 + tests/meson.build | 20 + tests/tc_policy.cpp | 2989 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 3010 insertions(+) create mode 100644 tests/tc_policy.cpp diff --git a/packaging/libds-tizen.spec b/packaging/libds-tizen.spec index 1ef64cc..e1d4c25 100644 --- a/packaging/libds-tizen.spec +++ b/packaging/libds-tizen.spec @@ -630,3 +630,4 @@ ninja -C builddir install %{_includedir}/libds-tizen/policy.h %{_libdir}/pkgconfig/libds-tizen-policy.pc %{_libdir}/libds-tizen-policy.so +%{_bindir}/libds-tizen-policy-tests diff --git a/tests/meson.build b/tests/meson.build index 1b78a64..030c3b0 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -304,3 +304,23 @@ executable('libds-tizen-hwc-tests', install_dir: libds_tizen_bindir, install : true ) + +## policy tests +tc_policy_files = [ + 'tc_main.cpp', + 'tc_policy.cpp', +] + +executable('libds-tizen-policy-tests', + [ + tc_mock_files, + tc_policy_files + ], + dependencies: [ + deps_test_common, + deps_libds_tizen_policy, + dependency('tizen-extension-client', required: true), + ], + install_dir: libds_tizen_bindir, + install : true +) diff --git a/tests/tc_policy.cpp b/tests/tc_policy.cpp new file mode 100644 index 0000000..e099014 --- /dev/null +++ b/tests/tc_policy.cpp @@ -0,0 +1,2989 @@ +#include "tc_main.h" +#include "mockclient.h" +#include "mockcompositor.h" +#include +#include + +#define TIZEN_POLICY_VERSION 11 + +class MockPolicyVisibility +{ +public: + MockPolicyVisibility() + : mVisibility(nullptr) + {} + MockPolicyVisibility(struct ds_tizen_policy_visibility *visibility) + : mVisibility(visibility) + { + ds_inf("%s", __func__); + + // policy_surface destroy listener + mDestroyListener.notify = MockPolicyVisibility::DestroyCallback; + mDestroyListener.parent = this; + ds_tizen_policy_visibility_add_destroy_listener(visibility, &mDestroyListener); + } + ~MockPolicyVisibility() + { + ds_inf("%s", __func__); + + if (mDestroyListener.notify) { + wl_list_remove(&mDestroyListener.link); + mDestroyListener.notify = nullptr; + } + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + MockPolicyVisibility *policyVisibility = + reinterpret_cast(listener)->parent; + struct ds_tizen_policy_visibility *visibility = + static_cast(data); + + ds_inf("%s: policyVisibility(%p), visibility(%p)", __func__, + policyVisibility, visibility); + + wl_list_remove(&policyVisibility->mDestroyListener.link); + policyVisibility->mDestroyListener.notify = nullptr; + + policyVisibility->bDestroyed = true; + } + + void SendNotify(enum ds_tizen_policy_visibility_type type) + { + ds_tizen_policy_visibility_send_notify(mVisibility, type); + } + + void SendChanged(enum ds_tizen_policy_visibility_type type, uint32_t option) + { + ds_tizen_policy_visibility_send_changed(mVisibility, type, option); + } + +public: + bool bDestroyed; + +private: + struct ds_tizen_policy_visibility *mVisibility; + + struct DestroyListener : ::wl_listener { + MockPolicyVisibility *parent; + }; + DestroyListener mDestroyListener; +}; + +class MockPolicyPosition +{ +public: + MockPolicyPosition() + : mX(-1), + mY(-1), + mPosition(nullptr) + {} + MockPolicyPosition(struct ds_tizen_policy_position *position) + : mX(-1), + mY(-1), + mPosition(position) + { + ds_inf("%s", __func__); + + // policy_surface destroy listener + mDestroyListener.notify = MockPolicyPosition::DestroyCallback; + mDestroyListener.parent = this; + ds_tizen_policy_position_add_destroy_listener(position, &mDestroyListener); + + // position listener + mSetListener.notify = MockPolicyPosition::SetCallback; + mSetListener.parent = this; + ds_tizen_policy_position_add_set_listener(position, &mSetListener); + } + ~MockPolicyPosition() + { + ds_inf("%s", __func__); + + if (mSetListener.notify) { + wl_list_remove(&mSetListener.link); + mSetListener.notify = nullptr; + } + + if (mDestroyListener.notify) { + wl_list_remove(&mDestroyListener.link); + mDestroyListener.notify = nullptr; + } + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + MockPolicyPosition *policyPosition = + reinterpret_cast(listener)->parent; + struct ds_tizen_policy_position *position = + static_cast(data); + + ds_inf("%s: policyPosition(%p), position(%p)", __func__, + policyPosition, position); + + wl_list_remove(&policyPosition->mSetListener.link); + policyPosition->mSetListener.notify = nullptr; + + wl_list_remove(&policyPosition->mDestroyListener.link); + policyPosition->mDestroyListener.notify = nullptr; + + policyPosition->bDestroyed = true; + } + + static void SetCallback(struct wl_listener *listener, void *data) + { + MockPolicyPosition *mockPosition = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_position_set *event = + static_cast(data); + + EXPECT_TRUE(mockPosition->mPosition == event->position); + mockPosition->mX = event->x; + mockPosition->mY = event->y; + } + + void SendChanged(int32_t x, int32_t y) + { + ds_tizen_policy_position_send_changed(mPosition, x, y); + mX = x; + mY = y; + } + +public: + bool bDestroyed; + + int32_t mX; + int32_t mY; + +private: + struct ds_tizen_policy_position *mPosition; + + struct DestroyListener : ::wl_listener { + MockPolicyPosition *parent; + }; + DestroyListener mDestroyListener; + + struct SetListener : ::wl_listener { + MockPolicyPosition *parent; + }; + SetListener mSetListener; +}; + +class MockPolicySubsurfaceWatcher +{ +public: + MockPolicySubsurfaceWatcher() + : mSubsurfaceWatcher(nullptr) + {} + MockPolicySubsurfaceWatcher(struct ds_tizen_policy_subsurface_watcher *subsurface_watcher) + : mSubsurfaceWatcher(subsurface_watcher) + { + ds_inf("%s", __func__); + + // policy_surface destroy listener + mDestroyListener.notify = MockPolicySubsurfaceWatcher::DestroyCallback; + mDestroyListener.parent = this; + ds_tizen_policy_subsurface_watcher_add_destroy_listener(subsurface_watcher, &mDestroyListener); + } + ~MockPolicySubsurfaceWatcher() + { + ds_inf("%s", __func__); + + if (mDestroyListener.notify) { + wl_list_remove(&mDestroyListener.link); + mDestroyListener.notify = nullptr; + } + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + MockPolicySubsurfaceWatcher *policySubsurfaceWatcher = + reinterpret_cast(listener)->parent; + struct ds_tizen_policy_subsurface_watcher *subsurface_watcher = + static_cast(data); + + ds_inf("%s: policySubsurfaceWatcher(%p), subsurface_watcher(%p)", __func__, + policySubsurfaceWatcher, subsurface_watcher); + + wl_list_remove(&policySubsurfaceWatcher->mDestroyListener.link); + policySubsurfaceWatcher->mDestroyListener.notify = nullptr; + + policySubsurfaceWatcher->bDestroyed = true; + } + +#if 0 // TODO: + void SendMessage(enum ds_tizen_policy_subsurface_watcher_message message) + { + ds_tizen_policy_subsurface_watcher_send_message(mSubsurfaceWatcher, message); + } +#endif + +public: + bool bDestroyed; + +private: + struct ds_tizen_policy_subsurface_watcher *mSubsurfaceWatcher; + + struct DestroyListener : ::wl_listener { + MockPolicySubsurfaceWatcher *parent; + }; + DestroyListener mDestroyListener; +}; + +class MockPolicySurface +{ +public: + MockPolicySurface(struct ds_tizen_policy_surface *policy_surface) + : mPolicySurface(policy_surface), + mPolicyVisibility(nullptr), + mPolicyPosition(nullptr), + mPolicySubsurfaceWatcher(nullptr) + { + ds_inf("%s", __func__); + + // policy_surface destroy listener + mDestroyListener.notify = MockPolicySurface::DestroyCallback; + mDestroyListener.parent = this; + ds_tizen_policy_surface_add_destroy_listener(policy_surface, &mDestroyListener); + + // policy_surface listeners + mGetVisibilityListener.notify = MockPolicySurface::GetVisibilityCallback; + mGetVisibilityListener.parent = this; + ds_tizen_policy_surface_add_get_visibility_listener(policy_surface, + &mGetVisibilityListener); + + mGetPositionListener.notify = MockPolicySurface::GetPositionCallback; + mGetPositionListener.parent = this; + ds_tizen_policy_surface_add_get_position_listener(policy_surface, + &mGetPositionListener); + + mActivateListener.notify = MockPolicySurface::ActivateCallback; + mActivateListener.parent = this; + ds_tizen_policy_surface_add_activate_listener(policy_surface, + &mActivateListener); + + mRaiseListener.notify = MockPolicySurface::RaiseCallback; + mRaiseListener.parent = this; + ds_tizen_policy_surface_add_raise_listener(policy_surface, + &mRaiseListener); + + mLowerListener.notify = MockPolicySurface::LowerCallback; + mLowerListener.parent = this; + ds_tizen_policy_surface_add_lower_listener(policy_surface, + &mLowerListener); + + mSetFocusSkipListener.notify = MockPolicySurface::SetFocusSkipCallback; + mSetFocusSkipListener.parent = this; + ds_tizen_policy_surface_add_set_focus_skip_listener(policy_surface, + &mSetFocusSkipListener); + + mUnsetFocusSkipListener.notify = MockPolicySurface::UnsetFocusSkipCallback; + mUnsetFocusSkipListener.parent = this; + ds_tizen_policy_surface_add_unset_focus_skip_listener(policy_surface, + &mUnsetFocusSkipListener); + + mSetRoleListener.notify = MockPolicySurface::SetRoleCallback; + mSetRoleListener.parent = this; + ds_tizen_policy_surface_add_set_role_listener(policy_surface, + &mSetRoleListener); + + mWindowTypeListener.notify = MockPolicySurface::WindowTypeCallback; + mWindowTypeListener.parent = this; + ds_tizen_policy_surface_add_set_window_type_listener(policy_surface, + &mWindowTypeListener); + + mSetConformantListener.notify = MockPolicySurface::SetConformantCallback; + mSetConformantListener.parent = this; + ds_tizen_policy_surface_add_set_conformant_listener(policy_surface, + &mSetConformantListener); + + mUnsetConformantListener.notify = MockPolicySurface::UnsetConformantCallback; + mUnsetConformantListener.parent = this; + ds_tizen_policy_surface_add_unset_conformant_listener(policy_surface, + &mUnsetConformantListener); + + mGetConformantListener.notify = MockPolicySurface::GetConformantCallback; + mGetConformantListener.parent = this; + ds_tizen_policy_surface_add_get_conformant_listener(policy_surface, + &mGetConformantListener); + + mSetNotificationLevelListener.notify = MockPolicySurface::SetNotificationLevelCallback; + mSetNotificationLevelListener.parent = this; + ds_tizen_policy_surface_add_set_notification_level_listener(policy_surface, + &mSetNotificationLevelListener); + + mSetWindowScreenModeListener.notify = MockPolicySurface::SetWindowScreenModeCallback; + mSetWindowScreenModeListener.parent = this; + ds_tizen_policy_surface_add_set_window_screen_mode_listener(policy_surface, + &mSetWindowScreenModeListener); + + mGetSubsurfaceListener.notify = MockPolicySurface::GetSubsurfaceCallback; + mGetSubsurfaceListener.parent = this; + ds_tizen_policy_surface_add_get_subsurface_listener(policy_surface, + &mGetSubsurfaceListener); + + mIconifyListener.notify = MockPolicySurface::IconifyCallback; + mIconifyListener.parent = this; + ds_tizen_policy_surface_add_iconify_listener(policy_surface, + &mIconifyListener); + + mUniconifyListener.notify = MockPolicySurface::UniconifyCallback; + mUniconifyListener.parent = this; + ds_tizen_policy_surface_add_uniconify_listener(policy_surface, + &mUniconifyListener); + + mAddAuxHintListener.notify = MockPolicySurface::AddAuxHintCallback; + mAddAuxHintListener.parent = this; + ds_tizen_policy_surface_add_add_aux_hint_listener(policy_surface, + &mAddAuxHintListener); + + mChangeAuxHintListener.notify = MockPolicySurface::ChangeAuxHintCallback; + mChangeAuxHintListener.parent = this; + ds_tizen_policy_surface_add_change_aux_hint_listener(policy_surface, + &mChangeAuxHintListener); + + mDeleteAuxHintListener.notify = MockPolicySurface::DeleteAuxHintCallback; + mDeleteAuxHintListener.parent = this; + ds_tizen_policy_surface_add_delete_aux_hint_listener(policy_surface, + &mDeleteAuxHintListener); + + mGetSupportAuxHintsListener.notify = MockPolicySurface::GetSupportAuxHintsCallback; + mGetSupportAuxHintsListener.parent = this; + ds_tizen_policy_surface_add_get_supported_aux_hints_listener(policy_surface, + &mGetSupportAuxHintsListener); + + mSetFloatingModeListener.notify = MockPolicySurface::SetFloatingModeCallback; + mSetFloatingModeListener.parent = this; + ds_tizen_policy_surface_add_set_floating_mode_listener(policy_surface, + &mSetFloatingModeListener); + + mUnsetFloatingModeListener.notify = MockPolicySurface::UnsetFloatingModeCallback; + mUnsetFloatingModeListener.parent = this; + ds_tizen_policy_surface_add_unset_floating_mode_listener(policy_surface, + &mUnsetFloatingModeListener); + + mSetStackModeListener.notify = MockPolicySurface::SetStackModeCallback; + mSetStackModeListener.parent = this; + ds_tizen_policy_surface_add_set_stack_mode_listener(policy_surface, + &mSetStackModeListener); + + mGetSubsurfaceWatcherListener.notify = MockPolicySurface::GetSubsurfaceWatcherCallback; + mGetSubsurfaceWatcherListener.parent = this; + ds_tizen_policy_surface_add_get_subsurface_watcher_listener(policy_surface, + &mGetSubsurfaceWatcherListener); + + mSetParentListener.notify = MockPolicySurface::SetParentCallback; + mSetParentListener.parent = this; + ds_tizen_policy_surface_add_set_parent_listener(policy_surface, + &mSetParentListener); + + mAckConformantRegionListener.notify = MockPolicySurface::AckConformantRegionCallback; + mAckConformantRegionListener.parent = this; + ds_tizen_policy_surface_add_ack_conformant_region_listener(policy_surface, + &mAckConformantRegionListener); + + mSetVideoListener.notify = MockPolicySurface::SetVideoCallback; + mSetVideoListener.parent = this; + ds_tizen_policy_surface_add_set_video_listener(policy_surface, + &mSetVideoListener); + + mShowListener.notify = MockPolicySurface::ShowCallback; + mShowListener.parent = this; + ds_tizen_policy_surface_add_show_listener(policy_surface, + &mShowListener); + + mHideListener.notify = MockPolicySurface::HideCallback; + mHideListener.parent = this; + ds_tizen_policy_surface_add_hide_listener(policy_surface, + &mHideListener); + + mSetParentWithBelowListener.notify = MockPolicySurface::SetParentWithBelowCallback; + mSetParentWithBelowListener.parent = this; + ds_tizen_policy_surface_add_set_parent_with_below_listener(policy_surface, + &mSetParentWithBelowListener); + } + ~MockPolicySurface() + { + ds_inf("%s", __func__); + + if (mGetVisibilityListener.notify) { + wl_list_remove(&mGetVisibilityListener.link); + mGetVisibilityListener.notify = nullptr; + } + + if (mDestroyListener.notify) { + wl_list_remove(&mDestroyListener.link); + mDestroyListener.notify = nullptr; + } + + if (mPolicySubsurfaceWatcher) + delete mPolicySubsurfaceWatcher; + + if (mPolicyPosition) + delete mPolicyPosition; + + if (mPolicyVisibility) + delete mPolicyVisibility; + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_policy_surface *policy_surface = + static_cast(data); + + ds_inf("%s: policySurface(%p), policy_surface(%p)", __func__, policySurface, policy_surface); + + wl_list_remove(&policySurface->mDestroyListener.link); + policySurface->mDestroyListener.notify = nullptr; + + policySurface->bDestroyed = true; + } + + static void GetVisibilityCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_visibility *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + EXPECT_TRUE(event->visibility != NULL); + + policySurface->bGetVisibility = true; + + MockPolicyVisibility *policyVisibility = + new MockPolicyVisibility(event->visibility); + + policySurface->mPolicyVisibility = policyVisibility; + } + + static void GetPositionCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_position *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + EXPECT_TRUE(event->position != NULL); + + policySurface->bGetPosition = true; + + MockPolicyPosition *policyPosition = + new MockPolicyPosition(event->position); + + policySurface->mPolicyPosition = policyPosition; + } + + static void ActivateCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_activate *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bActivate = true; + } + + static void RaiseCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_raise *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bRaise = true; + } + + static void LowerCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_lower *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bLower = true; + } + + static void SetFocusSkipCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_focus_skip *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetFocusSkip = true; + } + + static void UnsetFocusSkipCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_unset_focus_skip *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetFocusSkip = false; + } + + static void SetRoleCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_role *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + policySurface->mRole = event->role; // char -> string + } + + static void WindowTypeCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_window_type *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mWinType = event->win_type; + } + + static void SetConformantCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_conformant *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetConformant = true; + } + + static void UnsetConformantCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_unset_conformant *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetConformant = false; + } + + static void GetConformantCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_conformant *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bGetConformant = true; + } + + static void SetNotificationLevelCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_notification_level *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mNotificationLevel = event->level; + } + + static void SetWindowScreenModeCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_window_screen_mode *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mWindowScreenMode = event->mode; + } + + static void GetSubsurfaceCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_subsurface *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mParentUniversalId = event->parent_universal_id; + } + + static void IconifyCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_iconify *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bIconify = true; + } + + static void UniconifyCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_uniconify *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bIconify = false; + } + + static void AddAuxHintCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_add_aux_hint *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mAuxHintId = event->id; + policySurface->mAuxHintName = event->name; + policySurface->mAuxHintValue = event->value; + } + + static void ChangeAuxHintCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_change_aux_hint *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mAuxHintId = event->id; + policySurface->mAuxHintValue = event->value; + } + + static void DeleteAuxHintCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_delete_aux_hint *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mAuxHintId = event->id; + } + + static void GetSupportAuxHintsCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_supported_aux_hints *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bGetSupportedAuxHints = true; + } + + static void SetFloatingModeCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_floating_mode *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetFloatingMode = true; + } + + static void UnsetFloatingModeCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_unset_floating_mode *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bSetFloatingMode = false; + } + + static void SetStackModeCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_stack_mode *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mStackMode = event->mode; + } + + static void GetSubsurfaceWatcherCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_get_subsurface_watcher *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + EXPECT_TRUE(event->subsurface_watcher != NULL); + + policySurface->bGetSubsurfaceWatcher = true; + + MockPolicySubsurfaceWatcher *policySubsurfaceWatcher = + new MockPolicySubsurfaceWatcher(event->subsurface_watcher); + + policySurface->mPolicySubsurfaceWatcher = policySubsurfaceWatcher; + } + + static void SetParentCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_parent *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mParentSurface = event->parent_surface; + } + + static void AckConformantRegionCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_ack_conformant_region *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mSerial = event->serial; + } + + static void SetVideoCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_video *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bVideo = event->video; + } + + static void ShowCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_show *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bShow = true; + } + + static void HideCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_hide *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->bHide = true; + } + + static void SetParentWithBelowCallback(struct wl_listener *listener, void *data) + { + MockPolicySurface *policySurface = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_surface_set_parent_with_below *event = + static_cast(data); + + EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface); + + policySurface->mParentSurface = event->parent_surface; + } + + uint32_t GetSurfaceResId() + { + struct ds_surface *surface = ds_tizen_policy_surface_get_surface(mPolicySurface); + struct wl_resource *surface_res = ds_surface_get_wl_resource(surface); + + return wl_resource_get_id(surface_res); + } + + MockPolicyVisibility *GetVisibility() + { + return mPolicyVisibility; + } + + MockPolicyPosition *GetPosition() + { + return mPolicyPosition; + } + + MockPolicySubsurfaceWatcher*GetSubsurfaceWatcher() + { + return mPolicySubsurfaceWatcher; + } + + void SendConformant(bool active) + { + ds_inf("%s", __func__); + + ds_tizen_policy_surface_send_conformant(mPolicySurface, active); + } + + void SendConformantArea(enum ds_tizen_policy_conformant_part part, + bool visible, int32_t x, int32_t y, int32_t w, int32_t h) + { + ds_inf("%s", __func__); + + ds_tizen_policy_surface_send_conformant_area(mPolicySurface, part, visible, + x, y, w, h); + } + + void SendNotificationDone( + enum ds_tizen_policy_notification_level notification_level, + enum ds_tizen_policy_error_state error_state) + { + ds_inf("%s", __func__); + + ds_tizen_policy_surface_send_notification_done(mPolicySurface, notification_level, + error_state); + } + + void SendWindowScreenModeDone( + enum ds_tizen_policy_window_screen_mode window_screen_mode, + enum ds_tizen_policy_error_state error_state) + { + ds_inf("%s", __func__); + + ds_tizen_policy_surface_send_window_screen_mode_done(mPolicySurface, window_screen_mode, + error_state); + } + + void SendIconifyStateChanged(bool iconified, bool force) + { + ds_inf("%s", __func__); + + ds_tizen_policy_surface_send_iconify_state_changed(mPolicySurface, iconified, force); + } + +public: + bool bDestroyed; + + bool bGetVisibility; + bool bGetPosition; + bool bActivate; + bool bRaise; + bool bLower; + bool bSetFocusSkip; + std::string mRole; + enum ds_tizen_policy_window_type mWinType; + bool bSetConformant; + bool bGetConformant; + enum ds_tizen_policy_notification_level mNotificationLevel; + enum ds_tizen_policy_window_screen_mode mWindowScreenMode; + uint32_t mUniversalId; + uint32_t mParentUniversalId; + bool bIconify; + int32_t mAuxHintId; + std::string mAuxHintName; + std::string mAuxHintValue; + bool bGetSupportedAuxHints; + bool bSetFloatingMode; + enum ds_tizen_policy_stack_mode mStackMode; + bool bGetSubsurfaceWatcher; + struct ds_surface *mParentSurface; + uint32_t mSerial; + bool bVideo; + bool bShow; + bool bHide; + +private: + struct ds_tizen_policy_surface *mPolicySurface; + MockPolicyVisibility *mPolicyVisibility; + MockPolicyPosition *mPolicyPosition; + MockPolicySubsurfaceWatcher *mPolicySubsurfaceWatcher; + + struct DestroyListener : ::wl_listener { + MockPolicySurface *parent; + }; + DestroyListener mDestroyListener; + + // policy policy_surface listener structure + struct GetVisibilityListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetVisibilityListener mGetVisibilityListener; + + struct GetPositionListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetPositionListener mGetPositionListener; + + struct ActivateListener : ::wl_listener { + MockPolicySurface *parent; + }; + ActivateListener mActivateListener; + + struct RaiseListener : ::wl_listener { + MockPolicySurface *parent; + }; + RaiseListener mRaiseListener; + + struct LowerListener : ::wl_listener { + MockPolicySurface *parent; + }; + LowerListener mLowerListener; + + struct SetFocusSkipListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetFocusSkipListener mSetFocusSkipListener; + + struct UnsetFocusSkipListener : ::wl_listener { + MockPolicySurface *parent; + }; + UnsetFocusSkipListener mUnsetFocusSkipListener; + + struct SetRoleListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetRoleListener mSetRoleListener; + + struct WindowTypeListener : ::wl_listener { + MockPolicySurface *parent; + }; + WindowTypeListener mWindowTypeListener; + + struct SetConformantListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetConformantListener mSetConformantListener; + + struct UnsetConformantListener : ::wl_listener { + MockPolicySurface *parent; + }; + UnsetConformantListener mUnsetConformantListener; + + struct GetConformantListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetConformantListener mGetConformantListener; + + struct SetNotificationLevelListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetNotificationLevelListener mSetNotificationLevelListener; + + struct SetWindowScreenModeListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetWindowScreenModeListener mSetWindowScreenModeListener; + + struct GetSubsurfaceListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetSubsurfaceListener mGetSubsurfaceListener; + + struct IconifyListener : ::wl_listener { + MockPolicySurface *parent; + }; + IconifyListener mIconifyListener; + + struct UniconifyListener : ::wl_listener { + MockPolicySurface *parent; + }; + UniconifyListener mUniconifyListener; + + struct AddAuxHintListener : ::wl_listener { + MockPolicySurface *parent; + }; + AddAuxHintListener mAddAuxHintListener; + + struct ChangeAuxHintListener : ::wl_listener { + MockPolicySurface *parent; + }; + ChangeAuxHintListener mChangeAuxHintListener; + + struct DeleteAuxHintListener : ::wl_listener { + MockPolicySurface *parent; + }; + DeleteAuxHintListener mDeleteAuxHintListener; + + struct GetSupportAuxHintsListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetSupportAuxHintsListener mGetSupportAuxHintsListener; + + struct SetFloatingModeListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetFloatingModeListener mSetFloatingModeListener; + + struct UnsetFloatingModeListener : ::wl_listener { + MockPolicySurface *parent; + }; + UnsetFloatingModeListener mUnsetFloatingModeListener; + + struct SetStackModeListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetStackModeListener mSetStackModeListener; + + struct GetSubsurfaceWatcherListener : ::wl_listener { + MockPolicySurface *parent; + }; + GetSubsurfaceWatcherListener mGetSubsurfaceWatcherListener; + + struct SetParentListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetParentListener mSetParentListener; + + struct AckConformantRegionListener : ::wl_listener { + MockPolicySurface *parent; + }; + AckConformantRegionListener mAckConformantRegionListener; + + struct SetVideoListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetVideoListener mSetVideoListener; + + struct ShowListener : ::wl_listener { + MockPolicySurface *parent; + }; + ShowListener mShowListener; + + struct HideListener : ::wl_listener { + MockPolicySurface *parent; + }; + HideListener mHideListener; + + struct SetParentWithBelowListener : ::wl_listener { + MockPolicySurface *parent; + }; + SetParentWithBelowListener mSetParentWithBelowListener; +}; + +class MockSurface +{ +public: + MockSurface(struct ds_surface *surface) + : mSurface(surface) + { + ds_inf("%s", __func__); + + // del surface listener + mDestroyListener.notify = MockSurface::DestroyCallback; + mDestroyListener.parent = this; + ds_surface_add_destroy_listener(surface, &mDestroyListener); + } + ~MockSurface() + { + ds_inf("%s", __func__); + + if (mDestroyListener.notify) { + wl_list_remove(&mDestroyListener.link); + mDestroyListener.notify = nullptr; + } + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + MockSurface *mockSurface = + reinterpret_cast(listener)->parent; + struct ds_surface *surface = static_cast(data); + + ds_inf("%s: mockSurface(%p), surface(%p)", __func__, mockSurface, surface); + + wl_list_remove(&mockSurface->mDestroyListener.link); + mockSurface->mDestroyListener.notify = nullptr; + } + +private: + struct ds_surface *mSurface; + + struct DestroyListener : ::wl_listener { + MockSurface *parent; + }; + DestroyListener mDestroyListener; +}; + +class MockPolicyCompositor : public MockCompositor +{ +public: + MockPolicyCompositor() + : MockCompositor(&MockPolicyCompositor::TestSetup, this) + { + ds_inf("%s : this(%p)", __func__, this); + + // initialize the flags to check + bDestroyed = false; + bGetPolicySurface = false; + } + + ~MockPolicyCompositor() + { + ds_inf("%s : this(%p)", __func__, this); + + auto removeSurfaces = [&](MockSurface* s)->void {delete s;}; + for_each(mMockSurfaces.begin(), mMockSurfaces.end(), removeSurfaces); + mMockSurfaces.clear(); + + auto removePolicySurfaces = [&](MockPolicySurface* i)->void {delete i;}; + for_each(mPolicySurfaces.begin(), mPolicySurfaces.end(), removePolicySurfaces); + mPolicySurfaces.clear(); + + wl_list_remove(&mNewSurfaceListener.link); + } + + static void TestSetup(void *data) + { + MockPolicyCompositor *mockComp = + static_cast(data); + Compositor *comp = mockComp->compositor; + + ds_inf("%s: mockComp(%p)", __func__, mockComp); + + // new surface listener + mockComp->mNewSurfaceListener.notify = + MockPolicyCompositor::NewSurfaceCallback; + mockComp->mNewSurfaceListener.parent = mockComp; + ds_compositor_add_new_surface_listener(comp->compositor, + &mockComp->mNewSurfaceListener); + + mockComp->mPolicy = + ds_tizen_policy_create(comp->display); + + // policy destroy listener + mockComp->mDestroyListener.notify = + MockPolicyCompositor::DestroyCallback; + mockComp->mDestroyListener.parent = mockComp; + ds_tizen_policy_add_destroy_listener(mockComp->mPolicy, + &mockComp->mDestroyListener); + + // policy listeners + mockComp->mGetPolicySurfaceListener.notify = + MockPolicyCompositor::GetPolicySurfaceCallback; + mockComp->mGetPolicySurfaceListener.parent = mockComp; + ds_tizen_policy_add_get_surface_listener( + mockComp->mPolicy, + &mockComp->mGetPolicySurfaceListener); + + mockComp->mActivateBelowByUniversalIdListener.notify = + MockPolicyCompositor::ActivateBelowByUniversalIdCallback; + mockComp->mActivateBelowByUniversalIdListener.parent = mockComp; + ds_tizen_policy_add_activate_below_by_univeral_id_listener( + mockComp->mPolicy, + &mockComp->mActivateBelowByUniversalIdListener); + + mockComp->mLowerByUniversalIdListener.notify = + MockPolicyCompositor::LowerByUniversalIdCallback; + mockComp->mLowerByUniversalIdListener.parent = mockComp; + ds_tizen_policy_add_lower_by_universal_id_listener( + mockComp->mPolicy, + &mockComp->mLowerByUniversalIdListener); + + mockComp->mSetTransientForListener.notify = + MockPolicyCompositor::SetTransientForCallback; + mockComp->mSetTransientForListener.parent = mockComp; + ds_tizen_policy_add_set_transient_for_listener( + mockComp->mPolicy, + &mockComp->mSetTransientForListener); + + mockComp->mUnsetTransientForListener.notify = + MockPolicyCompositor::UnsetTransientForCallback; + mockComp->mUnsetTransientForListener.parent = mockComp; + ds_tizen_policy_add_unset_transient_for_listener( + mockComp->mPolicy, + &mockComp->mUnsetTransientForListener); + + mockComp->mPlaceSubsurfaceBelowParentListener.notify = + MockPolicyCompositor::PlaceSubsurfaceBelowParentCallback; + mockComp->mPlaceSubsurfaceBelowParentListener.parent = mockComp; + ds_tizen_policy_add_place_subsurface_below_parent_listener( + mockComp->mPolicy, + &mockComp->mPlaceSubsurfaceBelowParentListener); + + mockComp->mSetSubsurfaceStandAloneListener.notify = + MockPolicyCompositor::SetSubsurfaceStandAloneCallback; + mockComp->mSetSubsurfaceStandAloneListener.parent = mockComp; + ds_tizen_policy_add_set_subsurface_stand_alone_listener( + mockComp->mPolicy, + &mockComp->mSetSubsurfaceStandAloneListener); + + mockComp->mSetBackgroundStateListener.notify = + MockPolicyCompositor::SetBackgroundStateCallback; + mockComp->mSetBackgroundStateListener.parent = mockComp; + ds_tizen_policy_add_set_background_state_listener( + mockComp->mPolicy, + &mockComp->mSetBackgroundStateListener); + + mockComp->mUnsetBackgroundStateListener.notify = + MockPolicyCompositor::UnsetBackgroundStateCallback; + mockComp->mUnsetBackgroundStateListener.parent = mockComp; + ds_tizen_policy_add_unset_background_state_listener( + mockComp->mPolicy, + &mockComp->mUnsetBackgroundStateListener); + + mockComp->mActivateAboveByUniversalIdListener.notify = + MockPolicyCompositor::ActivateAboveByUniversalIdCallback; + mockComp->mActivateAboveByUniversalIdListener.parent = mockComp; + ds_tizen_policy_add_activate_above_by_universal_id_listener( + mockComp->mPolicy, + &mockComp->mActivateAboveByUniversalIdListener); + + mockComp->mSetAppIdListener.notify = + MockPolicyCompositor::SetAppIdCallback; + mockComp->mSetAppIdListener.parent = mockComp; + ds_tizen_policy_add_set_appid_listener( + mockComp->mPolicy, + &mockComp->mSetAppIdListener); + + mockComp->mSetTransientForBelowListener.notify = + MockPolicyCompositor::SetTransientForBelowCallback; + mockComp->mSetTransientForBelowListener.parent = mockComp; + ds_tizen_policy_add_set_transient_for_below_listener( + mockComp->mPolicy, + &mockComp->mSetTransientForBelowListener); + } + + static void NewSurfaceCallback(struct wl_listener *listener, void *data) + { + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_surface *surface = static_cast(data); + MockSurface *mockSurf = new MockSurface(surface); + + ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface); + + mockComp->mMockSurfaces.push_back(mockSurf); + } + + static void DestroyCallback(struct wl_listener *listener, void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + + mockComp->bDestroyed = true; + } + + static void GetPolicySurfaceCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_get_surface *event = + static_cast(data); + + struct ds_tizen_policy_surface *policy_surface = event->policy_surface; + + ds_inf("%s: mockComp(%p), policy_surface(%p)", __func__, mockComp, policy_surface); + + mockComp->bGetPolicySurface = true; + + MockPolicySurface *policySurface = new MockPolicySurface(event->policy_surface); + mockComp->mPolicySurfaces.push_back(policySurface); + } + + static void ActivateBelowByUniversalIdCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_activate_below_by_univeral_id *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mUniversalId = event->universal_id; + mockComp->mBelowUniversalId = event->below_universal_id; + } + + static void LowerByUniversalIdCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_lower_by_universal_id *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mUniversalId = event->universal_id; + } + + static void SetTransientForCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_set_transient_for *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mChildUniversalId = event->child_universal_id; + mockComp->mParentUniversalId = event->parent_universal_id; + } + + static void UnsetTransientForCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_unset_transient_for *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mChildUniversalId = event->child_universal_id; + } + + static void PlaceSubsurfaceBelowParentCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_place_subsurface_below_parent *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->bPlaceSubsurfaceBelowParent = true; + } + + static void SetSubsurfaceStandAloneCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_set_subsurface_stand_alone *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->bSetSubsurfaceStandAlone = true; + } + + static void SetBackgroundStateCallback(struct wl_listener *listener, void *data) + { + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_set_background_state *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mPid = event->pid; + } + + static void UnsetBackgroundStateCallback(struct wl_listener *listener, void *data) + { + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_unset_background_state *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mPid = event->pid; + } + + static void ActivateAboveByUniversalIdCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_activate_above_by_universal_id *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mUniversalId = event->universal_id; + mockComp->mAboveUniversalId = event->above_universal_id; + } + + static void SetAppIdCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_set_appid *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mPid = event->pid; + mockComp->mAppId = event->appid; // char -> string + } + + static void SetTransientForBelowCallback(struct wl_listener *listener, + void *data) + { + ds_inf("%s", __func__); + + MockPolicyCompositor *mockComp = + reinterpret_cast(listener)->parent; + struct ds_tizen_event_policy_set_transient_for_below *event = + static_cast(data); + + EXPECT_TRUE(mockComp->mPolicy == event->policy); + mockComp->mUniversalId = event->universal_id; + mockComp->mParentUniversalId = event->parent_universal_id; + } + + MockPolicySurface* FindPolicySurfaceWidthResId(uint32_t res_id) + { + auto is_matched = [&](MockPolicySurface* i)->bool { + return (i->GetSurfaceResId() == res_id); + }; + auto result = std::find_if(begin(mPolicySurfaces), end(mPolicySurfaces), + is_matched); + if (result != std::end(mPolicySurfaces)) + return *result; + + return nullptr; + } + +public: + bool bDestroyed; + bool bGetPolicySurface; + int32_t mPid; + std::string mAppId; + uint32_t mUniversalId; + uint32_t mAboveUniversalId; + uint32_t mBelowUniversalId; + uint32_t mParentUniversalId; + uint32_t mChildUniversalId; + bool bPlaceSubsurfaceBelowParent; + bool bSetSubsurfaceStandAlone; + +private: + struct ds_tizen_policy *mPolicy; + + std::vector mMockSurfaces; + std::vector mPolicySurfaces; + + struct NewSurfaceListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + NewSurfaceListener mNewSurfaceListener; + + struct DestroyListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + DestroyListener mDestroyListener; + + // policy listener structure + struct GetPolicySurfaceListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + GetPolicySurfaceListener mGetPolicySurfaceListener; + + struct ActivateBelowByUniversalIdListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + ActivateBelowByUniversalIdListener mActivateBelowByUniversalIdListener; + + struct LowerByUniversalIdListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + LowerByUniversalIdListener mLowerByUniversalIdListener; + + struct SetTransientForListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + SetTransientForListener mSetTransientForListener; + + struct UnsetTransientForListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + UnsetTransientForListener mUnsetTransientForListener; + + struct PlaceSubsurfaceBelowParentListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + PlaceSubsurfaceBelowParentListener mPlaceSubsurfaceBelowParentListener; + + struct SetSubsurfaceStandAloneListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + SetSubsurfaceStandAloneListener mSetSubsurfaceStandAloneListener; + + struct SetBackgroundStateListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + SetBackgroundStateListener mSetBackgroundStateListener; + + struct UnsetBackgroundStateListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + UnsetBackgroundStateListener mUnsetBackgroundStateListener; + + struct ActivateAboveByUniversalIdListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + ActivateAboveByUniversalIdListener mActivateAboveByUniversalIdListener; + + struct SetAppIdListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + SetAppIdListener mSetAppIdListener; + + struct SetTransientForBelowListener: ::wl_listener { + MockPolicyCompositor *parent; + }; + SetTransientForBelowListener mSetTransientForBelowListener; + + // policy_surface listener structure + struct PolicySurfaceDestroyListener : ::wl_listener { + MockPolicyCompositor *parent; + }; + PolicySurfaceDestroyListener mPolicySurfaceDestroyListener; +}; + +class MockPolicyClient : public MockClient +{ +public: + MockPolicyClient() + : mSurfaceRes(nullptr), + mIsConformant(0), + mLevel(-1), + mErrorState(0), + mChildId(0), + mWindowScreenMode(0), + mIconified(0), + mForce(0), + mHints(nullptr), + mNumHints(0), + mHintId(-1), + mKey(nullptr), + mValue(nullptr), + mOptions(nullptr), + mConformantPart(0), + mState(0), + mX(-1), mY(-1), mW(0), mH(0), + mSerial(0), + mVisibilityType(0), + mVisibilityOption(0), + mPositionX(-1), mPositionY(-1) + {} + MockPolicyClient(const struct wl_registry_listener *listener) + : MockClient(listener, this) + { + ds_inf("%s", __func__); + } + ~MockPolicyClient() + { + ds_inf("%s", __func__); + } + + void SetWlCompositor(struct wl_compositor *global_res) + { + ds_inf("%s", __func__); + + compositor_res = global_res; + } + + void SetWlSubCompositor(struct wl_subcompositor *global_res) + { + ds_inf("%s", __func__); + + subcompositor_res = global_res; + } + + struct wl_compositor *GetWlCompositor() + { + ds_inf("%s", __func__); + + return compositor_res; + } + + struct wl_subcompositor *GetWlSubCompositor() + { + ds_inf("%s", __func__); + + return subcompositor_res; + } + + void SetTizenPolicy(struct tizen_policy *resource) + { + ds_inf("%s", __func__); + + policy_res = resource; + } + + struct tizen_policy *GetTizenPolicy() + { + ds_inf("%s", __func__); + + return policy_res; + } + +public: + struct wl_surface *mSurfaceRes; + uint32_t mIsConformant; + int32_t mLevel; + uint32_t mErrorState; + uint32_t mChildId; + uint32_t mWindowScreenMode; + uint32_t mIconified; + uint32_t mForce; + struct wl_array *mHints; + uint32_t mNumHints; + int32_t mHintId; + const char *mKey; + const char *mValue; + struct wl_array *mOptions; + uint32_t mConformantPart; + uint32_t mState; + int32_t mX, mY, mW, mH; + uint32_t mSerial; + uint32_t mVisibilityType; + uint32_t mVisibilityOption; + int32_t mPositionX; + int32_t mPositionY; + +private: + struct wl_compositor *compositor_res; + struct wl_subcompositor *subcompositor_res; + struct tizen_policy *policy_res; +}; + +static void +client_tizen_policy_cb_conformant(void *data, struct tizen_policy *policy_res, + struct wl_surface *surface_resource, uint32_t is_conformant) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mIsConformant = is_conformant; +} + +static void +client_tizen_policy_cb_conformant_area(void *data, + struct tizen_policy *policy_res, + struct wl_surface *surface_resource, uint32_t conformant_part, + uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mConformantPart = conformant_part; + client->mState = state; + client->mX = x; + client->mY = y; + client->mW = w; + client->mH = h; +} + +static void +client_tizen_policy_cb_notification_done(void *data, + struct tizen_policy *policy_res, + struct wl_surface *surface_resource, int32_t level, uint32_t error_state) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mLevel = level; + client->mErrorState = error_state; +} + +static void +client_tizen_policy_cb_transient_for_done(void *data, + struct tizen_policy *policy_res, uint32_t child_id) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mChildId = child_id; +} + +static void +client_tizen_policy_cb_window_screen_mode_done(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + uint32_t mode, uint32_t error_state) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mWindowScreenMode = mode; + client->mErrorState = error_state; +} + +static void +client_tizen_policy_cb_iconify_state_changed(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + uint32_t iconified, uint32_t force) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mIconified = iconified; + client->mForce = force; +} + +static void +client_tizen_policy_cb_supported_aux_hints(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + struct wl_array *hints, uint32_t num_hints) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mHints = hints; + client->mNumHints = num_hints; +} + +static void +client_tizen_policy_cb_allowed_aux_hint(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + int32_t id) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mHintId = id; +} + +static void +client_tizen_policy_cb_aux_message(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + const char *key, const char *value, struct wl_array *options) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mKey = key; + client->mValue = value; + client->mOptions = options; +} + +static void +client_tizen_policy_cb_conformant_region(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + uint32_t conformant_part, uint32_t state, + int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mConformantPart = conformant_part; + client->mState = state; + client->mX = x; + client->mY = y; + client->mW = w; + client->mH = h; + client->mSerial = serial; +} + +static void +client_tizen_policy_cb_interactive_mode_done(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + int32_t x, int32_t y, uint32_t w, uint32_t h) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mX = x; + client->mY = y; + client->mW = w; + client->mH = h; +} + +static void +client_tizen_policy_cb_interactive_resize_done(void *data, + struct tizen_policy *policy_res, struct wl_surface *surface_resource, + int32_t x, int32_t y, uint32_t w, uint32_t h) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mSurfaceRes = surface_resource; + client->mX = x; + client->mY = y; + client->mW = w; + client->mH = h; +} + +static const struct +tizen_policy_listener policy_cb_listener = +{ + .conformant = client_tizen_policy_cb_conformant, + .conformant_area = client_tizen_policy_cb_conformant_area, + .notification_done = client_tizen_policy_cb_notification_done, + .transient_for_done = client_tizen_policy_cb_transient_for_done, + .window_screen_mode_done = client_tizen_policy_cb_window_screen_mode_done, + .iconify_state_changed = client_tizen_policy_cb_iconify_state_changed, + .supported_aux_hints = client_tizen_policy_cb_supported_aux_hints, + .allowed_aux_hint = client_tizen_policy_cb_allowed_aux_hint, + .aux_message = client_tizen_policy_cb_aux_message, + .conformant_region = client_tizen_policy_cb_conformant_region, + .interactive_move_done = client_tizen_policy_cb_interactive_mode_done, + .interactive_resize_done = client_tizen_policy_cb_interactive_resize_done, +}; + +static void +client_registry_cb_global(void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + struct wl_compositor *compositor_res; + struct wl_subcompositor *subcompositor_res; + struct tizen_policy *policy_res; + + if (!strcmp(interface, "wl_compositor")) { + compositor_res = (struct wl_compositor *)wl_registry_bind(registry, + name, &wl_compositor_interface, 1); + if (compositor_res == nullptr) { + ds_err("wl_registry_bind() failed. wl_compositor resource."); + return; + } + client->SetWlCompositor(compositor_res); + } else if (!strcmp(interface, "wl_subcompositor")) { + subcompositor_res = (struct wl_subcompositor *) + wl_registry_bind(registry, name, &wl_subcompositor_interface, 1); + if (subcompositor_res == nullptr) { + ds_err("wl_registry_bind() failed. wl_subcompositor resource."); + return; + } + client->SetWlSubCompositor(subcompositor_res); + } else if (!strcmp(interface, "tizen_policy")) { + policy_res = (struct tizen_policy *)wl_registry_bind(registry, + name, &tizen_policy_interface, TIZEN_POLICY_VERSION); + if (policy_res == nullptr) { + ds_err("wl_registry_bind() failed. tizen_policy resource."); + return; + } + client->SetTizenPolicy(policy_res); + + tizen_policy_add_listener(policy_res, + &policy_cb_listener, client); + } +} + +static void +client_registry_cb_global_remove(void *data, struct wl_registry *registry, + uint32_t name) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + struct wl_compositor *compositor_res = client->GetWlCompositor(); + struct tizen_policy *policy_res = client->GetTizenPolicy(); + + tizen_policy_destroy(policy_res); + wl_compositor_destroy(compositor_res); +} + +static const struct wl_registry_listener registry_listener = { + .global = client_registry_cb_global, + .global_remove = client_registry_cb_global_remove +}; + +class PolicyTest : public ::testing::Test +{ +public: + void SetUp(void) override; + void TearDown(void) override; + + MockPolicyCompositor *comp; + MockPolicyClient *client; + struct wl_compositor *compositor_res; + struct wl_subcompositor *subcompositor_res; + struct tizen_policy *policy_res; + struct wl_surface *surface_res; +}; + +void +PolicyTest::SetUp(void) +{ + //ds_log_init(DS_DBG, NULL); + + ds_inf("%s", __func__); + + comp = new MockPolicyCompositor(); + client = new MockPolicyClient(®istry_listener); + compositor_res = client->GetWlCompositor(); + subcompositor_res = client->GetWlSubCompositor(); + policy_res = client->GetTizenPolicy(); + surface_res = wl_compositor_create_surface(compositor_res); + + client->RoundTrip(); +} + +void +PolicyTest::TearDown(void) +{ + ds_inf("%s", __func__); + + wl_surface_destroy(surface_res); + client->RoundTrip(); + + delete client; + delete comp; +} + +TEST_F(PolicyTest, Create_P) +{ + EXPECT_TRUE(true); +} + +TEST_F(PolicyTest, Req_ActivateBelowByUniversalId) +{ + uint32_t universal_id = 100; + uint32_t below_universal_id = 200; + + tizen_policy_activate_below_by_res_id(policy_res, + universal_id, below_universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mUniversalId == universal_id) + << comp->mUniversalId << ", " << universal_id; + EXPECT_TRUE(comp->mBelowUniversalId == below_universal_id) + << comp->mBelowUniversalId << ", " << below_universal_id; +} + +TEST_F(PolicyTest, Req_LowerByUniversalId) +{ + uint32_t universal_id = 100; + + tizen_policy_lower_by_res_id(policy_res,universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mUniversalId == universal_id) + << comp->mUniversalId << ", " << universal_id; +} + +TEST_F(PolicyTest, Req_SetTransientFor) +{ + uint32_t child_universal_id = 100; + uint32_t parent_universal_id = 200; + + tizen_policy_set_transient_for(policy_res, + child_universal_id, parent_universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mChildUniversalId == child_universal_id) + << comp->mChildUniversalId << ", " << child_universal_id; + EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id) + << comp->mParentUniversalId << ", " << parent_universal_id; + + EXPECT_TRUE(client->mChildId == child_universal_id); +} + +TEST_F(PolicyTest, Req_UnsetTransientFor) +{ + uint32_t child_universal_id = 100; + + tizen_policy_unset_transient_for(policy_res, child_universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mChildUniversalId == child_universal_id) + << comp->mChildUniversalId << ", " << child_universal_id; + + EXPECT_TRUE(client->mChildId == child_universal_id); +} + +TEST_F(PolicyTest, Req_PlaceSubsurfaceBelowParent) +{ + struct wl_surface *parent_surface_res; + struct wl_subsurface *subsurface_res; + + parent_surface_res = wl_compositor_create_surface(compositor_res); + if (!parent_surface_res) + return; + + subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res, + surface_res, parent_surface_res); + if (!subsurface_res) { + wl_surface_destroy(parent_surface_res); + return; + } + + tizen_policy_place_subsurface_below_parent(policy_res, subsurface_res); + client->RoundTrip(); + + EXPECT_TRUE(comp->bPlaceSubsurfaceBelowParent); + + wl_subsurface_destroy(subsurface_res); + wl_surface_destroy(parent_surface_res); +} + +TEST_F(PolicyTest, Req_SetSubsurfaceStandAlone) +{ + struct wl_surface *parent_surface_res; + struct wl_subsurface *subsurface_res; + + parent_surface_res = wl_compositor_create_surface(compositor_res); + if (!parent_surface_res) + return; + + subsurface_res = wl_subcompositor_get_subsurface(subcompositor_res, + surface_res, parent_surface_res); + if (!subsurface_res) { + wl_surface_destroy(parent_surface_res); + return; + } + + tizen_policy_set_subsurface_stand_alone(policy_res, subsurface_res); + client->RoundTrip(); + + EXPECT_TRUE(comp->bSetSubsurfaceStandAlone); + + wl_subsurface_destroy(subsurface_res); + wl_surface_destroy(parent_surface_res); +} + +TEST_F(PolicyTest, Req_ActivateAboveByUniversalId) +{ + uint32_t universal_id = 100; + uint32_t above_universal_id = 100; + + tizen_policy_activate_above_by_res_id(policy_res, universal_id, + above_universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mUniversalId == universal_id) + << comp->mUniversalId << ", " << universal_id; + EXPECT_TRUE(comp->mAboveUniversalId == above_universal_id) + << comp->mAboveUniversalId << ", " << above_universal_id; +} + +TEST_F(PolicyTest, Req_SetAppId) +{ + int32_t pid = getpid(); + std::string appid("APPLICATION_ID"); + char* c_appid = const_cast(appid.c_str()); + + tizen_policy_set_appid(policy_res, pid, c_appid); + client->RoundTrip(); + + EXPECT_TRUE(comp->mPid == pid) + << comp->mPid << ", " << pid; + EXPECT_TRUE(comp->mAppId.compare(appid) == false) + << comp->mAppId << ", " << appid; +} + +TEST_F(PolicyTest, Req_SetTransientForBelow) +{ + uint32_t universal_id = 100; + uint32_t parent_universal_id = 200; + + tizen_policy_set_transient_for_below(policy_res, universal_id, + parent_universal_id); + client->RoundTrip(); + + EXPECT_TRUE(comp->mUniversalId == universal_id) + << comp->mUniversalId << ", " << universal_id; + EXPECT_TRUE(comp->mParentUniversalId == parent_universal_id) + << comp->mParentUniversalId << ", " << parent_universal_id; +} + +static void +client_tizen_visibility_cb_notify(void *data, + struct tizen_visibility *visibility_res, uint32_t visibility) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mVisibilityType = visibility; +} + +static void +client_tizen_visibility_cb_changed(void *data, + struct tizen_visibility *visibility_res, uint32_t type, uint32_t option) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mVisibilityType = type; + client->mVisibilityOption = option; +} + +static const struct +tizen_visibility_listener visibility_cb_listener = +{ + .notify = client_tizen_visibility_cb_notify, + .changed = client_tizen_visibility_cb_changed, +}; + +TEST_F(PolicyTest, Req_PolicySurfaceGetVisibility) +{ + MockPolicySurface *policy_surface; + MockPolicyVisibility *visibility; + struct tizen_visibility *visibility_res; + uint32_t surface_res_id; + + visibility_res = tizen_policy_get_visibility(policy_res, surface_res); + EXPECT_TRUE(visibility_res != NULL); + + tizen_visibility_add_listener(visibility_res, + &visibility_cb_listener, client); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetVisibility); + + visibility = policy_surface->GetVisibility(); + + tizen_visibility_destroy(visibility_res); + client->RoundTrip(); + + EXPECT_TRUE(visibility->bDestroyed); +} + +TEST_F(PolicyTest, Ev_VisibilityNotify) +{ + MockPolicySurface *policy_surface; + MockPolicyVisibility *visibility; + struct tizen_visibility *visibility_res; + enum ds_tizen_policy_visibility_type type = + DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED; + uint32_t surface_res_id; + + visibility_res = tizen_policy_get_visibility(policy_res, surface_res); + EXPECT_TRUE(visibility_res != NULL); + + tizen_visibility_add_listener(visibility_res, + &visibility_cb_listener, client); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetVisibility); + + visibility = policy_surface->GetVisibility(); + visibility->SendNotify(type); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mVisibilityType == + TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED); + + tizen_visibility_destroy(visibility_res); + client->RoundTrip(); + + EXPECT_TRUE(visibility->bDestroyed); +} + +TEST_F(PolicyTest, Ev_VisibilityChanged) +{ + MockPolicySurface *policy_surface; + MockPolicyVisibility *visibility; + struct tizen_visibility *visibility_res; + enum ds_tizen_policy_visibility_type type = + DS_TIZEN_POLICY_VISIBILITY_TYPE_FULLY_OBSCURED; + uint32_t surface_res_id; + uint32_t option = 4; + + visibility_res = tizen_policy_get_visibility(policy_res, surface_res); + EXPECT_TRUE(visibility_res != NULL); + + tizen_visibility_add_listener(visibility_res, + &visibility_cb_listener, client); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetVisibility); + + visibility = policy_surface->GetVisibility(); + visibility->SendChanged(type, option); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mVisibilityType == + TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED); + EXPECT_TRUE(client->mVisibilityOption == option); + + tizen_visibility_destroy(visibility_res); + client->RoundTrip(); + + EXPECT_TRUE(visibility->bDestroyed); +} + +static void +client_tizen_position_cb_changed(void *data, + struct tizen_position *position_res, int32_t x, int32_t y) +{ + ds_inf("%s", __func__); + + MockPolicyClient *client = static_cast(data); + + client->mPositionX = x; + client->mPositionY = y; +} + +static const struct +tizen_position_listener position_cb_listener = +{ + .changed = client_tizen_position_cb_changed, +}; + +TEST_F(PolicyTest, Req_PolicySurfaceGetPosition) +{ + MockPolicySurface *policy_surface; + struct tizen_position *position_res; + uint32_t surface_res_id; + + position_res = tizen_policy_get_position(policy_res, surface_res); + EXPECT_TRUE(position_res != NULL); + + tizen_position_add_listener(position_res, + &position_cb_listener, client); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetPosition); + + tizen_position_destroy(position_res); +} + +TEST_F(PolicyTest, Req_PositionSet) +{ + MockPolicySurface *policy_surface; + MockPolicyPosition *position; + struct tizen_position *position_res; + uint32_t surface_res_id; + int32_t x = 100, y = 200; + + position_res = tizen_policy_get_position(policy_res, surface_res); + EXPECT_TRUE(position_res != NULL); + + tizen_position_add_listener(position_res, + &position_cb_listener, client); + + tizen_position_set(position_res, x, y); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetPosition); + + position = policy_surface->GetPosition(); + EXPECT_TRUE(position->mX == x); + EXPECT_TRUE(position->mY == y); + + tizen_position_destroy(position_res); +} + +TEST_F(PolicyTest, Ev_PositionChanged) +{ + MockPolicySurface *policy_surface; + MockPolicyPosition *position; + struct tizen_position *position_res; + uint32_t surface_res_id; + int32_t x = 100, y = 200; + + position_res = tizen_policy_get_position(policy_res, surface_res); + EXPECT_TRUE(position_res != NULL); + + tizen_position_add_listener(position_res, + &position_cb_listener, client); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetPosition); + + position = policy_surface->GetPosition(); + position->SendChanged(x, y); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mPositionX == x); + EXPECT_TRUE(client->mPositionY == y); + + tizen_position_destroy(position_res); +} + +TEST_F(PolicyTest, Req_PolicySurfaceActivate) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_activate(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bActivate); +} + +TEST_F(PolicyTest, Req_PolicySurfaceRaise) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_raise(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bRaise); +} + +TEST_F(PolicyTest, Req_PolicySurfaceLower) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_lower(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bLower); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetFocusSkip) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_set_focus_skip(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bSetFocusSkip); +} + +TEST_F(PolicyTest, Req_PolicySurfaceUnsetFocusSkip) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_unset_focus_skip(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bSetFocusSkip == false); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetRole) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + std::string role("APPLICATION_ID"); + char* c_role = const_cast(role.c_str()); + + tizen_policy_set_role(policy_res, surface_res, c_role); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mRole.compare(role) == false) + << policy_surface->mRole << ", " << role; +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetType) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + uint32_t win_type = TIZEN_POLICY_WIN_TYPE_TOPLEVEL; + + tizen_policy_set_type(policy_res, surface_res, win_type); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mWinType == DS_TIZEN_POLICY_WINDOW_TYPE_TOPLEVEL); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetConformant) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_set_conformant(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bSetConformant == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceUnsetConformant) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_unset_conformant(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bSetConformant == false); +} + +TEST_F(PolicyTest, Req_Ev_PolicySurfaceGetConformant) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_get_conformant(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bGetConformant == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetNotificationLevel) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + uint32_t noti_level = TIZEN_POLICY_LEVEL_HIGH; + + tizen_policy_set_notification_level(policy_res, surface_res, noti_level); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mNotificationLevel == DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetWindowScreenMode) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON; + + tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mWindowScreenMode == DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON); +} + +TEST_F(PolicyTest, Req_PolicySurfaceGetSubsurface) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + struct wl_subsurface *subsurface_res; + uint32_t parent_universal_id = 100; + + subsurface_res = tizen_policy_get_subsurface(policy_res, surface_res, parent_universal_id); + EXPECT_TRUE(subsurface_res != NULL); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mParentUniversalId == parent_universal_id); +} + +TEST_F(PolicyTest, Req_PolicySurfaceIconify) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_iconify(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bIconify == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceUniconify) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_uniconify(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bIconify == false); +} + +TEST_F(PolicyTest, Req_PolicySurfaceAddAuxHint) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + int32_t auxhint_id = 100; + std::string auxhint_name("AUX_HINT_NAME"); + std::string auxhint_value("AUX_HINT_VALUE"); + char* c_auxhint_name = const_cast(auxhint_name.c_str()); + char* c_auxhint_value = const_cast(auxhint_value.c_str()); + + tizen_policy_add_aux_hint(policy_res, surface_res, auxhint_id, + c_auxhint_name, c_auxhint_value); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id); + EXPECT_TRUE(policy_surface->mAuxHintName.compare(auxhint_name) == false) + << policy_surface->mAuxHintName << ", " << auxhint_name; + EXPECT_TRUE(policy_surface->mAuxHintValue.compare(auxhint_value) == false) + << policy_surface->mAuxHintValue << ", " << auxhint_value; +} + +TEST_F(PolicyTest, Req_PolicySurfaceChangeAuxHint) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + int32_t auxhint_id = 100; + std::string auxhint_value("AUX_HINT_VALUE"); + char* c_auxhint_value = const_cast(auxhint_value.c_str()); + + tizen_policy_change_aux_hint(policy_res, surface_res, auxhint_id, + c_auxhint_value); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id); + EXPECT_TRUE(policy_surface->mAuxHintValue.compare(auxhint_value) == false) + << policy_surface->mAuxHintValue << ", " << auxhint_value; +} + +TEST_F(PolicyTest, Req_PolicySurfaceDeleteAuxHint) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + int32_t auxhint_id = 100; + + tizen_policy_del_aux_hint(policy_res, surface_res, auxhint_id); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mAuxHintId == auxhint_id); +} + +TEST_F(PolicyTest, Req_PolicySurfaceGetSupportAuxHints) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_get_supported_aux_hints(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bGetSupportedAuxHints); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetBackgroundState) +{ + int32_t pid = getpid(); + + tizen_policy_set_background_state(policy_res, pid); + client->RoundTrip(); + + EXPECT_TRUE(comp->mPid == pid); +} + +TEST_F(PolicyTest, Req_PolicySurfaceUnsetBackgroundState) +{ + int32_t pid = getpid(); + + tizen_policy_unset_background_state(policy_res, pid); + client->RoundTrip(); + + EXPECT_TRUE(comp->mPid == pid); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetFloatingMode) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_set_floating_mode(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bSetFloatingMode == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceUnsetFloatingMode) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_unset_floating_mode(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bSetFloatingMode == false); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetStackMode) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_set_floating_mode(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bSetFloatingMode == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceGetSubsurfaceWatcher) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + struct tizen_subsurface_watcher *subsuface_watcher_res; + + subsuface_watcher_res = tizen_policy_get_subsurface_watcher(policy_res, surface_res); + EXPECT_TRUE(subsuface_watcher_res != NULL); + + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bGetSubsurfaceWatcher == true); + + tizen_subsurface_watcher_destroy(subsuface_watcher_res); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetParent) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + struct wl_surface *parent_surface_res; + + parent_surface_res = wl_compositor_create_surface(compositor_res); + if (!parent_surface_res) + return; + + tizen_policy_set_parent(policy_res, surface_res, parent_surface_res); + + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mParentSurface); +} + +TEST_F(PolicyTest, Req_PolicySurfaceAckConformantRegion) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + uint32_t serial = 100; + + tizen_policy_ack_conformant_region(policy_res, surface_res, serial); + + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->mSerial == serial); +} + +TEST_F(PolicyTest, Req_PolicySurfaceHasVideo) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + bool has_video = true; + + tizen_policy_has_video(policy_res, surface_res, (uint32_t)has_video); + + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bVideo == has_video); +} + +TEST_F(PolicyTest, Req_PolicySurfaceShow) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_show(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + + EXPECT_TRUE(policy_surface->bShow == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceHide) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + + tizen_policy_hide(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bHide == true); +} + +TEST_F(PolicyTest, Req_PolicySurfaceSetParentWithBelow) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + struct wl_surface *parent_surface_res; + + parent_surface_res = wl_compositor_create_surface(compositor_res); + if (!parent_surface_res) + return; + + tizen_policy_set_parent_with_below(policy_res, surface_res, + parent_surface_res); + + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->mParentSurface); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceConformant) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + bool is_conformant = true; + + tizen_policy_get_conformant(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetConformant); + + policy_surface->SendConformant(is_conformant); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mSurfaceRes == surface_res); + EXPECT_TRUE(client->mIsConformant == is_conformant); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceConformant_Area) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + enum ds_tizen_policy_conformant_part part = + DS_TIZEN_POLICY_CONFORMANT_PART_INDICATOR; + bool visible = 1; + int32_t x = 100, y = 200, w = 300, h = 400; + + tizen_policy_get_conformant(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bGetConformant); + + policy_surface->SendConformantArea(part, visible, x, y, w, h); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mSurfaceRes == surface_res); + EXPECT_TRUE(client->mConformantPart == TIZEN_POLICY_CONFORMANT_PART_INDICATOR); + EXPECT_TRUE(client->mState == (uint32_t)visible); + EXPECT_TRUE(client->mX == x); + EXPECT_TRUE(client->mY == y); + EXPECT_TRUE(client->mW == w); + EXPECT_TRUE(client->mH == h); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceNotificationDone) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + int32_t noti_level = TIZEN_POLICY_LEVEL_HIGH; + enum ds_tizen_policy_notification_level notification_level = + DS_TIZEN_POLICY_NOTIFICATION_LEVEL_HIGH; + + tizen_policy_set_notification_level(policy_res, surface_res, noti_level); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->mNotificationLevel == notification_level); + + policy_surface->SendNotificationDone(notification_level, + DS_TIZEN_POLICY_ERROR_STATE_NONE); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mSurfaceRes == surface_res); + EXPECT_TRUE(client->mLevel == noti_level); + EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceWindowScreenModeDone) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + uint32_t screen_mode = TIZEN_POLICY_MODE_ALWAYS_ON; + enum ds_tizen_policy_window_screen_mode window_screen_mode = + DS_TIZEN_POLICY_WINDOW_SCREEN_MODE_ALWAYS_ON; + + tizen_policy_set_window_screen_mode(policy_res, surface_res, screen_mode); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->mWindowScreenMode == window_screen_mode); + + policy_surface->SendWindowScreenModeDone(window_screen_mode, + DS_TIZEN_POLICY_ERROR_STATE_NONE); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mSurfaceRes == surface_res); + EXPECT_TRUE(client->mWindowScreenMode == window_screen_mode); + EXPECT_TRUE(client->mErrorState == TIZEN_POLICY_ERROR_STATE_NONE); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceIconifyStateChanged) +{ + MockPolicySurface *policy_surface; + uint32_t surface_res_id; + bool iconified = true; + bool force = true; + + tizen_policy_iconify(policy_res, surface_res); + client->RoundTrip(); + + surface_res_id = wl_proxy_get_id((struct wl_proxy *)surface_res); + policy_surface = comp->FindPolicySurfaceWidthResId(surface_res_id); + EXPECT_TRUE(policy_surface->bIconify == true); + + policy_surface->SendIconifyStateChanged(iconified, force); + comp->Process(); + + client->RoundTrip(); + EXPECT_TRUE(client->mSurfaceRes == surface_res); + EXPECT_TRUE(client->mIconified == iconified); + EXPECT_TRUE(client->mForce == force); +} + +TEST_F(PolicyTest, Ev_PolicySurfaceSupportedAuxHits) +{ + // TODO: +} + +TEST_F(PolicyTest, Ev_PolicySurfaceAllowedAuxHint) +{ + // TODO: +} + +TEST_F(PolicyTest, Ev_PolicySurfaceAuxMessage) +{ + // TODO: +} + +TEST_F(PolicyTest, Ev_PolicySurfaceConformantRegion) +{ +} + +TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveModeDone) +{ + // TODO: +} + +TEST_F(PolicyTest, Ev_PolicySurfaceInteractiveResizeDone) +{ + // TODO: +} -- 2.7.4