1 /*
2 * Copyright (c) 2024 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 #include "input_event_builder_test.h"
16
17 #undef LOG_TAG
18 #define LOG_TAG "InputEventBuilderTest"
19
20 namespace OHOS {
21 namespace Msdp {
22 namespace DeviceStatus {
23 namespace Cooperate {
24 using namespace testing::ext;
25
26 namespace {
27 ContextService *g_instance = nullptr;
28 std::unique_ptr<IInputAdapter> input_;
29 std::unique_ptr<IPluginManager> pluginMgr_;
30 std::unique_ptr<IDSoftbusAdapter> dsoftbus_;
31 SocketSessionManager socketSessionMgr_;
32 InputEventBuilder *builder_ = {nullptr};
33 auto env_ = ContextService::GetInstance();
34 const std::string networkId_ = "1234";
35 } // namespace
36
ContextService()37 ContextService::ContextService() {}
~ContextService()38 ContextService::~ContextService() {}
39
GetDelegateTasks()40 IDelegateTasks& ContextService::GetDelegateTasks()
41 {
42 return delegateTasks_;
43 }
44
GetDeviceManager()45 IDeviceManager& ContextService::GetDeviceManager()
46 {
47 return devMgr_;
48 }
49
GetTimerManager()50 ITimerManager& ContextService::GetTimerManager()
51 {
52 return timerMgr_;
53 }
54
GetDragManager()55 IDragManager& ContextService::GetDragManager()
56 {
57 return dragMgr_;
58 }
59
GetInstance()60 ContextService* ContextService::GetInstance()
61 {
62 static std::once_flag flag;
63 std::call_once(flag, [&]() {
64 ContextService *cooContext = new (std::nothrow) ContextService();
65 CHKPL(cooContext);
66 g_instance = cooContext;
67 });
68 return g_instance;
69 }
70
GetSocketSessionManager()71 ISocketSessionManager& ContextService::GetSocketSessionManager()
72 {
73 return socketSessionMgr_;
74 }
75
GetPluginManager()76 IPluginManager& ContextService::GetPluginManager()
77 {
78 return *pluginMgr_;
79 }
80
GetInput()81 IInputAdapter& ContextService::GetInput()
82 {
83 return *input_;
84 }
85
GetDSoftbus()86 IDSoftbusAdapter& ContextService::GetDSoftbus()
87 {
88 return *dsoftbus_;
89 }
90
SetUpTestCase()91 void InputEventBuilderTest::SetUpTestCase()
92 {
93 ASSERT_NE(env_, nullptr);
94 builder_ = new InputEventBuilder(env_);
95 ASSERT_NE(builder_, nullptr);
96 dsoftbus_ = std::make_unique<DSoftbusAdapter>();
97 input_ = std::make_unique<InputAdapter>();
98 }
99
TearDownTestCase()100 void InputEventBuilderTest::TearDownTestCase()
101 {
102 delete builder_;
103 builder_ = nullptr;
104 }
105
SetUp()106 void InputEventBuilderTest::SetUp() {}
TearDown()107 void InputEventBuilderTest::TearDown() {}
108
109 /**
110 * @tc.name: EnableTest001
111 * @tc.desc: Test EnableTest001
112 * @tc.type: FUNC
113 */
114 HWTEST_F(InputEventBuilderTest, EnableTest001, TestSize.Level1)
115 {
116 CALL_TEST_DEBUG;
117 Context context(env_);
118 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
119 }
120
121 /**
122 * @tc.name: UpdateTest001
123 * @tc.desc: Test UpdateTest001
124 * @tc.type: FUNC
125 */
126 HWTEST_F(InputEventBuilderTest, UpdateTest001, TestSize.Level1)
127 {
128 CALL_TEST_DEBUG;
129 Context context(env_);
130 ASSERT_NO_FATAL_FAILURE(builder_->Update(context));
131 }
132
133 /**
134 * @tc.name: OnPacketTest001
135 * @tc.desc: Test OnPacketTest001
136 * @tc.type: FUNC
137 */
138 HWTEST_F(InputEventBuilderTest, OnPacketTest001, TestSize.Level1)
139 {
140 CALL_TEST_DEBUG;
141 builder_->remoteNetworkId_ = "12345";
142 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
143 bool ret = builder_->OnPacket(networkId_, packet);
144 ASSERT_EQ(ret, false);
145 }
146
147 /**
148 * @tc.name: OnPacketTest002
149 * @tc.desc: Test OnPacketTest002
150 * @tc.type: FUNC
151 */
152 HWTEST_F(InputEventBuilderTest, OnPacketTest002, TestSize.Level1)
153 {
154 CALL_TEST_DEBUG;
155 builder_->remoteNetworkId_ = "1234";
156 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
157 bool ret = builder_->OnPacket(networkId_, packet);
158 ASSERT_EQ(ret, true);
159 NetPacket packet1(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
160 ret = builder_->OnPacket(networkId_, packet1);
161 ASSERT_EQ(ret, true);
162 NetPacket packet2(MessageId::DSOFTBUS_RELAY_COOPERATE);
163 ret = builder_->OnPacket(networkId_, packet2);
164 ASSERT_EQ(ret, false);
165 }
166
167 /**
168 * @tc.name: OnPacketTest003
169 * @tc.desc: Test OnPacketTest003
170 * @tc.type: FUNC
171 */
172 HWTEST_F(InputEventBuilderTest, OnPacketTest003, TestSize.Level1)
173 {
174 CALL_TEST_DEBUG;
175 builder_->remoteNetworkId_ = "1234";
176 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
177 int32_t ret1 = InputEventSerialization::Marshalling(builder_->pointerEvent_, packet);
178 ASSERT_EQ(ret1, RET_OK);
179 bool ret = builder_->OnPacket(networkId_, packet);
180 ASSERT_EQ(ret, true);
181 }
182
183 /**
184 * @tc.name: InputEventBuilderTest_Freeze_001
185 * @tc.desc: Test the funcation Freeze
186 * @tc.type: FUNC
187 */
188 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Freeze_001, TestSize.Level1)
189 {
190 CALL_TEST_DEBUG;
191 builder_->enable_ = false;
192 ASSERT_NO_FATAL_FAILURE(builder_->Freeze());
193 builder_->enable_ = true;
194 ASSERT_NO_FATAL_FAILURE(builder_->Freeze());
195 }
196
197 /**
198 * @tc.name: InputEventBuilderTest_Thaw_001
199 * @tc.desc: Test the funcation Thaw
200 * @tc.type: FUNC
201 */
202 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Thaw_001, TestSize.Level1)
203 {
204 CALL_TEST_DEBUG;
205 builder_->enable_ = false;
206 ASSERT_NO_FATAL_FAILURE(builder_->Thaw());
207 builder_->enable_ = true;
208 ASSERT_NO_FATAL_FAILURE(builder_->Thaw());
209 }
210
211 /**
212 * @tc.name: InputEventBuilderTest_Enable_001
213 * @tc.desc: Test the funcation Enable
214 * @tc.type: FUNC
215 */
216 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Enable_001, TestSize.Level1)
217 {
218 CALL_TEST_DEBUG;
219 Context context(env_);
220 builder_->enable_ = true;
221 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
222 builder_->enable_ = false;
223 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
224 }
225
226 /**
227 * @tc.name: InputEventBuilderTest_UpdatePointerEvent_001
228 * @tc.desc: Test the funcation UpdatePointerEvent
229 * @tc.type: FUNC
230 */
231 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_UpdatePointerEvent_001, TestSize.Level1)
232 {
233 CALL_TEST_DEBUG;
234 auto pointerEvent = MMI::PointerEvent::Create();
235 ASSERT_NE(pointerEvent, nullptr);
236 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
237 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
238 MMI::PointerEvent::PointerItem pointerItem;
239 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
240 bool ret = builder_->UpdatePointerEvent(pointerEvent);
241 ASSERT_FALSE(ret);
242 }
243
244
245 /**
246 * @tc.name: InputEventBuilderTest_IsActive_001
247 * @tc.desc: Test the funcation IsActive
248 * @tc.type: FUNC
249 */
250 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_001, TestSize.Level1)
251 {
252 CALL_TEST_DEBUG;
253 auto pointerEvent = MMI::PointerEvent::Create();
254 ASSERT_NE(pointerEvent, nullptr);
255 MMI::PointerEvent::PointerItem pointerItem;
256 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
257 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
258 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
259 builder_->freezing_ = true;
260 builder_->IsActive(pointerEvent);
261 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_PULL_MOVE);
262 builder_->IsActive(pointerEvent);
263 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
264 bool ret = builder_->IsActive(pointerEvent);
265 ASSERT_TRUE(ret);
266 }
267
268 /**
269 * @tc.name: InputEventBuilderTest_IsActive_002
270 * @tc.desc: Test the funcation IsActive
271 * @tc.type: FUNC
272 */
273 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_002, TestSize.Level1)
274 {
275 CALL_TEST_DEBUG;
276 auto pointerEvent = MMI::PointerEvent::Create();
277 ASSERT_NE(pointerEvent, nullptr);
278 MMI::PointerEvent::PointerItem pointerItem;
279 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
280 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
281 builder_->freezing_ = true;
282 bool ret = builder_->IsActive(pointerEvent);
283 ASSERT_TRUE(ret);
284 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_PULL_MOVE);
285 ret = builder_->IsActive(pointerEvent);
286 ASSERT_TRUE(ret);
287 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
288 ret = builder_->IsActive(pointerEvent);
289 ASSERT_TRUE(ret);
290 }
291
292 /**
293 * @tc.name: InputEventBuilderTest_IsActive_003
294 * @tc.desc: Test the funcation IsActive
295 * @tc.type: FUNC
296 */
297 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_003, TestSize.Level1)
298 {
299 CALL_TEST_DEBUG;
300 auto pointerEvent = MMI::PointerEvent::Create();
301 ASSERT_NE(pointerEvent, nullptr);
302 MMI::PointerEvent::PointerItem pointerItem;
303 pointerItem.SetPointerId(1);
304 pointerEvent->AddPointerItem(pointerItem);
305 builder_->freezing_ = true;
306 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
307 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
308 bool ret = builder_->IsActive(pointerEvent);
309 ASSERT_FALSE(ret);
310 builder_->xDir_ = 1;
311 builder_->IsActive(pointerEvent);
312 builder_->movement_ = -1;
313 ret = builder_->IsActive(pointerEvent);
314 ASSERT_FALSE(ret);
315 }
316 } // namespace Cooperate
317 } // namespace DeviceStatus
318 } // namespace Msdp
319 } // namespace OHOS