--- /dev/null
+#include "tc_main.h"
+#include "mockclient.h"
+#include "mockcompositor.h"
+#include <libds-tizen/policy.h>
+#include <tizen-extension-client-protocol.h>
+
+#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<DestroyListener *>(listener)->parent;
+ struct ds_tizen_policy_visibility *visibility =
+ static_cast<struct ds_tizen_policy_visibility *>(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<DestroyListener *>(listener)->parent;
+ struct ds_tizen_policy_position *position =
+ static_cast<struct ds_tizen_policy_position *>(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<SetListener *>(listener)->parent;
+ struct ds_tizen_event_policy_position_set *event =
+ static_cast<struct ds_tizen_event_policy_position_set *>(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<DestroyListener *>(listener)->parent;
+ struct ds_tizen_policy_subsurface_watcher *subsurface_watcher =
+ static_cast<struct ds_tizen_policy_subsurface_watcher *>(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<DestroyListener *>(listener)->parent;
+ struct ds_tizen_policy_surface *policy_surface =
+ static_cast<struct ds_tizen_policy_surface *>(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<GetVisibilityListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_visibility *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_visibility *>(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<GetPositionListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_position *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_position *>(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<ActivateListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_activate *event =
+ static_cast<struct ds_tizen_event_policy_surface_activate *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bActivate = true;
+ }
+
+ static void RaiseCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<RaiseListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_raise *event =
+ static_cast<struct ds_tizen_event_policy_surface_raise *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bRaise = true;
+ }
+
+ static void LowerCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<LowerListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_lower *event =
+ static_cast<struct ds_tizen_event_policy_surface_lower *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bLower = true;
+ }
+
+ static void SetFocusSkipCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetFocusSkipListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_focus_skip *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_focus_skip *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetFocusSkip = true;
+ }
+
+ static void UnsetFocusSkipCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<UnsetFocusSkipListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_unset_focus_skip *event =
+ static_cast<struct ds_tizen_event_policy_surface_unset_focus_skip *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetFocusSkip = false;
+ }
+
+ static void SetRoleCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetRoleListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_role *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_role *>(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<WindowTypeListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_window_type *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_window_type *>(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<SetConformantListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_conformant *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_conformant *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetConformant = true;
+ }
+
+ static void UnsetConformantCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<UnsetConformantListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_unset_conformant *event =
+ static_cast<struct ds_tizen_event_policy_surface_unset_conformant *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetConformant = false;
+ }
+
+ static void GetConformantCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<GetConformantListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_conformant *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_conformant *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bGetConformant = true;
+ }
+
+ static void SetNotificationLevelCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetNotificationLevelListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_notification_level *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_notification_level *>(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<SetWindowScreenModeListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_window_screen_mode *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_window_screen_mode *>(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<GetSubsurfaceListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_subsurface *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_subsurface *>(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<IconifyListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_iconify *event =
+ static_cast<struct ds_tizen_event_policy_surface_iconify *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bIconify = true;
+ }
+
+ static void UniconifyCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<UniconifyListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_uniconify *event =
+ static_cast<struct ds_tizen_event_policy_surface_uniconify *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bIconify = false;
+ }
+
+ static void AddAuxHintCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<AddAuxHintListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_add_aux_hint *event =
+ static_cast<struct ds_tizen_event_policy_surface_add_aux_hint *>(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<ChangeAuxHintListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_change_aux_hint *event =
+ static_cast<struct ds_tizen_event_policy_surface_change_aux_hint *>(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<DeleteAuxHintListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_delete_aux_hint *event =
+ static_cast<struct ds_tizen_event_policy_surface_delete_aux_hint *>(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<GetSupportAuxHintsListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_supported_aux_hints *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_supported_aux_hints *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bGetSupportedAuxHints = true;
+ }
+
+ static void SetFloatingModeCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetFloatingModeListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_floating_mode *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_floating_mode *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetFloatingMode = true;
+ }
+
+ static void UnsetFloatingModeCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<UnsetFloatingModeListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_unset_floating_mode *event =
+ static_cast<struct ds_tizen_event_policy_surface_unset_floating_mode *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bSetFloatingMode = false;
+ }
+
+ static void SetStackModeCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetStackModeListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_stack_mode *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_stack_mode *>(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<GetSubsurfaceWatcherListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_get_subsurface_watcher *event =
+ static_cast<struct ds_tizen_event_policy_surface_get_subsurface_watcher *>(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<SetParentListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_parent *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_parent *>(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<AckConformantRegionListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_ack_conformant_region *event =
+ static_cast<struct ds_tizen_event_policy_surface_ack_conformant_region *>(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<SetVideoListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_video *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_video *>(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<ShowListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_show *event =
+ static_cast<struct ds_tizen_event_policy_surface_show *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bShow = true;
+ }
+
+ static void HideCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<HideListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_hide *event =
+ static_cast<struct ds_tizen_event_policy_surface_hide *>(data);
+
+ EXPECT_TRUE(policySurface->mPolicySurface == event->policy_surface);
+
+ policySurface->bHide = true;
+ }
+
+ static void SetParentWithBelowCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicySurface *policySurface =
+ reinterpret_cast<SetParentWithBelowListener *>(listener)->parent;
+ struct ds_tizen_event_policy_surface_set_parent_with_below *event =
+ static_cast<struct ds_tizen_event_policy_surface_set_parent_with_below *>(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<DestroyListener *>(listener)->parent;
+ struct ds_surface *surface = static_cast<struct ds_surface *>(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<MockPolicyCompositor *>(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<NewSurfaceListener *>(listener)->parent;
+ struct ds_surface *surface = static_cast<struct ds_surface *>(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<DestroyListener *>(listener)->parent;
+
+ mockComp->bDestroyed = true;
+ }
+
+ static void GetPolicySurfaceCallback(struct wl_listener *listener,
+ void *data)
+ {
+ ds_inf("%s", __func__);
+
+ MockPolicyCompositor *mockComp =
+ reinterpret_cast<GetPolicySurfaceListener *>(listener)->parent;
+ struct ds_tizen_event_policy_get_surface *event =
+ static_cast<struct ds_tizen_event_policy_get_surface *>(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<ActivateBelowByUniversalIdListener *>(listener)->parent;
+ struct ds_tizen_event_policy_activate_below_by_univeral_id *event =
+ static_cast<struct ds_tizen_event_policy_activate_below_by_univeral_id *>(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<LowerByUniversalIdListener *>(listener)->parent;
+ struct ds_tizen_event_policy_lower_by_universal_id *event =
+ static_cast<struct ds_tizen_event_policy_lower_by_universal_id *>(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<SetTransientForListener *>(listener)->parent;
+ struct ds_tizen_event_policy_set_transient_for *event =
+ static_cast<struct ds_tizen_event_policy_set_transient_for *>(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<UnsetTransientForListener *>(listener)->parent;
+ struct ds_tizen_event_policy_unset_transient_for *event =
+ static_cast<struct ds_tizen_event_policy_unset_transient_for *>(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<PlaceSubsurfaceBelowParentListener *>(listener)->parent;
+ struct ds_tizen_event_policy_place_subsurface_below_parent *event =
+ static_cast<struct ds_tizen_event_policy_place_subsurface_below_parent *>(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<SetSubsurfaceStandAloneListener *>(listener)->parent;
+ struct ds_tizen_event_policy_set_subsurface_stand_alone *event =
+ static_cast<struct ds_tizen_event_policy_set_subsurface_stand_alone *>(data);
+
+ EXPECT_TRUE(mockComp->mPolicy == event->policy);
+ mockComp->bSetSubsurfaceStandAlone = true;
+ }
+
+ static void SetBackgroundStateCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicyCompositor *mockComp =
+ reinterpret_cast<SetBackgroundStateListener *>(listener)->parent;
+ struct ds_tizen_event_policy_set_background_state *event =
+ static_cast<struct ds_tizen_event_policy_set_background_state *>(data);
+
+ EXPECT_TRUE(mockComp->mPolicy == event->policy);
+ mockComp->mPid = event->pid;
+ }
+
+ static void UnsetBackgroundStateCallback(struct wl_listener *listener, void *data)
+ {
+ MockPolicyCompositor *mockComp =
+ reinterpret_cast<UnsetBackgroundStateListener *>(listener)->parent;
+ struct ds_tizen_event_policy_unset_background_state *event =
+ static_cast<struct ds_tizen_event_policy_unset_background_state *>(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<ActivateAboveByUniversalIdListener *>(listener)->parent;
+ struct ds_tizen_event_policy_activate_above_by_universal_id *event =
+ static_cast<struct ds_tizen_event_policy_activate_above_by_universal_id *>(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<SetAppIdListener *>(listener)->parent;
+ struct ds_tizen_event_policy_set_appid *event =
+ static_cast<struct ds_tizen_event_policy_set_appid *>(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<SetTransientForBelowListener *>(listener)->parent;
+ struct ds_tizen_event_policy_set_transient_for_below *event =
+ static_cast<struct ds_tizen_event_policy_set_transient_for_below *>(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<MockSurface *> mMockSurfaces;
+ std::vector<MockPolicySurface *> 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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<char *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<MockPolicyClient *>(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<char *>(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<char *>(auxhint_name.c_str());
+ char* c_auxhint_value = const_cast<char *>(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<char *>(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:
+}
projects / platform / core / uifw / libds-tizen.git / commitdiff