1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "event_runner.h"
19 #include "pointer_event.h"
20 #include "window_inner_manager.h"
21 #include "wm_common.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace Rosen {
27 using InnerTask = std::function<void()>;
28 using EventRunner = OHOS::AppExecFwk::EventRunner;
29 using EventHandler = OHOS::AppExecFwk::EventHandler;
30 using EventPriority = OHOS::AppExecFwk::EventQueue::Priority;
31
32 namespace {
33 const std::string INNER_WM_THREAD_NAME = "TestInnerWindowManager";
34 constexpr int32_t TEST_CUSTOM_ID = 100;
35 }
36
37 class WindowInnerManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp() override;
42 void TearDown() override;
43 };
44
SetUpTestCase()45 void WindowInnerManagerTest::SetUpTestCase()
46 {
47 }
48
TearDownTestCase()49 void WindowInnerManagerTest::TearDownTestCase()
50 {
51 }
52
SetUp()53 void WindowInnerManagerTest::SetUp()
54 {
55 }
56
TearDown()57 void WindowInnerManagerTest::TearDown()
58 {
59 }
60
61 namespace {
62 /**
63 * @tc.name: Stop
64 * @tc.desc: test WindowInnerManager Stop
65 * @tc.type: FUNC
66 */
67 HWTEST_F(WindowInnerManagerTest, Stop, Function | SmallTest | Level2)
68 {
69 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
70 windowInnerManager.state_ = InnerWMRunningState::STATE_RUNNING;
71 windowInnerManager.eventLoop_ = nullptr;
72 windowInnerManager.eventHandler_ = nullptr;
73 windowInnerManager.moveDragController_ = nullptr;
74 windowInnerManager.Stop();
75 ASSERT_EQ(InnerWMRunningState::STATE_NOT_START, windowInnerManager.state_);
76
77 windowInnerManager.eventLoop_ = AppExecFwk::EventRunner::Create(INNER_WM_THREAD_NAME);
78 windowInnerManager.eventHandler_ = std::make_shared<EventHandler>(windowInnerManager.eventLoop_);
79 windowInnerManager.moveDragController_ = new MoveDragController();
80 windowInnerManager.Stop();
81 ASSERT_EQ(0, windowInnerManager.eventLoop_.use_count());
82 ASSERT_EQ(0, windowInnerManager.eventHandler_.use_count());
83 }
84
85 /**
86 * @tc.name: NotifyServerReadyToMoveOrDrag
87 * @tc.desc: test WindowInnerManager NotifyServerReadyToMoveOrDrag
88 * @tc.type: FUNC
89 */
90 HWTEST_F(WindowInnerManagerTest, NotifyServerReadyToMoveOrDrag, Function | SmallTest | Level2)
91 {
92 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
93 windowInnerManager.eventHandler_ = nullptr;
94 windowInnerManager.moveDragController_ = new MoveDragController();
95 windowInnerManager.moveDragController_->activeWindowId_ = 1;
96 uint32_t windowId = 1;
97 sptr<WindowProperty> property = new WindowProperty();
98 ASSERT_NE(property, nullptr);
99 sptr<MoveDragProperty> moveDragProperty = new MoveDragProperty();
100 ASSERT_NE(moveDragProperty, nullptr);
101 auto result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
102 ASSERT_EQ(false, result);
103
104 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
105 result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
106 ASSERT_EQ(true, result);
107 }
108
109 /**
110 * @tc.name: NotifyWindowEndUpMovingOrDragging
111 * @tc.desc: test WindowInnerManager NotifyWindowEndUpMovingOrDragging
112 * @tc.type: FUNC
113 */
114 HWTEST_F(WindowInnerManagerTest, NotifyWindowEndUpMovingOrDragging, Function | SmallTest | Level2)
115 {
116 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
117 windowInnerManager.eventHandler_ = nullptr;
118 windowInnerManager.moveDragController_ = new MoveDragController();
119 windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
120
121 uint32_t windowId = INVALID_WINDOW_ID;
122 windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
123 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
124
125 windowId = TEST_CUSTOM_ID;
126 windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
127 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
128 }
129 /**
130 * @tc.name: NotifyWindowRemovedOrDestroyed
131 * @tc.desc: test WindowInnerManager NotifyWindowRemovedOrDestroyed
132 * @tc.type: FUNC
133 */
134 HWTEST_F(WindowInnerManagerTest, NotifyWindowRemovedOrDestroyed, Function | SmallTest | Level2)
135 {
136 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
137 windowInnerManager.eventHandler_ = nullptr;
138 windowInnerManager.moveDragController_ = new MoveDragController();
139 windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
140
141 uint32_t windowId = INVALID_WINDOW_ID;
142 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
143 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
144
145 windowId = TEST_CUSTOM_ID;
146
147 auto moveDragProperty = windowInnerManager.moveDragController_->moveDragProperty_;
148 moveDragProperty->startDragFlag_ = true;
149 moveDragProperty->startMoveFlag_ = true;
150 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
151 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
152 }
153 /**
154 * @tc.name: ConsumePointerEvent
155 * @tc.desc: test WindowInnerManager ConsumePointerEvent
156 * @tc.type: FUNC
157 */
158 HWTEST_F(WindowInnerManagerTest, ConsumePointerEvent, Function | SmallTest | Level2)
159 {
160 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
161 windowInnerManager.eventHandler_ = nullptr;
162 windowInnerManager.moveDragController_ = new MoveDragController();
163
164 auto pointerEvent = MMI::PointerEvent::Create();
165 pointerEvent->processedCallback_ = nullptr;
166 pointerEvent->sourceType_ = MMI::PointerEvent::SOURCE_TYPE_MOUSE;
167 pointerEvent->buttonId_ = MMI::PointerEvent::MOUSE_BUTTON_RIGHT;
168 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_MOVE;
169
170 pointerEvent->agentWindowId_ = 1;
171 windowInnerManager.moveDragController_->activeWindowId_ = 1;
172 windowInnerManager.ConsumePointerEvent(pointerEvent);
173 ASSERT_NE(windowInnerManager.moveDragController_->moveEvent_, nullptr);
174 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
175
176 pointerEvent->agentWindowId_ = 1;
177 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
178 windowInnerManager.ConsumePointerEvent(pointerEvent);
179 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
180
181 pointerEvent->agentWindowId_ = INVALID_WINDOW_ID;
182 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
183 windowInnerManager.ConsumePointerEvent(pointerEvent);
184 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
185 }
186 }
187 }
188 }
189