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_interceptor_test.h"
16 #include "ddm_adapter.h"
17
18 #undef LOG_TAG
19 #define LOG_TAG "InputEventInterceptorTest"
20
21 namespace OHOS {
22 namespace Msdp {
23 namespace DeviceStatus {
24 namespace Cooperate {
25 using namespace testing::ext;
26
27 namespace {
28 ContextService *g_instance = nullptr;
29 std::unique_ptr<IInputAdapter> input_;
30 std::unique_ptr<IPluginManager> pluginMgr_;
31 std::unique_ptr<IDSoftbusAdapter> dsoftbus_;
32 SocketSessionManager socketSessionMgr_;
33 InputEventInterceptor *interceptor_ = {nullptr};
34 auto env_ = ContextService::GetInstance();
35 } // namespace
36
ContextService()37 ContextService::ContextService()
38 {
39 ddm_ = std::make_unique<DDMAdapter>();
40 }
41
~ContextService()42 ContextService::~ContextService() {}
43
GetDelegateTasks()44 IDelegateTasks& ContextService::GetDelegateTasks()
45 {
46 return delegateTasks_;
47 }
48
GetDeviceManager()49 IDeviceManager& ContextService::GetDeviceManager()
50 {
51 return devMgr_;
52 }
53
GetTimerManager()54 ITimerManager& ContextService::GetTimerManager()
55 {
56 return timerMgr_;
57 }
58
GetDragManager()59 IDragManager& ContextService::GetDragManager()
60 {
61 return dragMgr_;
62 }
63
GetInstance()64 ContextService* ContextService::GetInstance()
65 {
66 static std::once_flag flag;
67 std::call_once(flag, [&]() {
68 ContextService *cooContext = new (std::nothrow) ContextService();
69 CHKPL(cooContext);
70 g_instance = cooContext;
71 });
72 return g_instance;
73 }
74
GetSocketSessionManager()75 ISocketSessionManager& ContextService::GetSocketSessionManager()
76 {
77 return socketSessionMgr_;
78 }
79
GetDDM()80 IDDMAdapter& ContextService::GetDDM()
81 {
82 return *ddm_;
83 }
84
GetPluginManager()85 IPluginManager& ContextService::GetPluginManager()
86 {
87 return *pluginMgr_;
88 }
89
GetInput()90 IInputAdapter& ContextService::GetInput()
91 {
92 return *input_;
93 }
94
GetDSoftbus()95 IDSoftbusAdapter& ContextService::GetDSoftbus()
96 {
97 return *dsoftbus_;
98 }
99
SetUpTestCase()100 void InputEventInterceptorTest::SetUpTestCase()
101 {
102 ASSERT_NE(env_, nullptr);
103 interceptor_ = new InputEventInterceptor(env_);
104 ASSERT_NE(interceptor_, nullptr);
105 dsoftbus_ = std::make_unique<DSoftbusAdapter>();
106 input_ = std::make_unique<InputAdapter>();
107 }
108
TearDownTestCase()109 void InputEventInterceptorTest::TearDownTestCase()
110 {
111 delete interceptor_;
112 interceptor_ = nullptr;
113 }
114
SetUp()115 void InputEventInterceptorTest::SetUp() {}
TearDown()116 void InputEventInterceptorTest::TearDown() {}
117
118 /**
119 * @tc.name: EnableTest001
120 * @tc.desc: Test EnableTest001
121 * @tc.type: FUNC
122 */
123 HWTEST_F(InputEventInterceptorTest, EnableTest001, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 Context context(env_);
127 ASSERT_NO_FATAL_FAILURE(interceptor_->Enable(context));
128 ASSERT_NO_FATAL_FAILURE(interceptor_->Disable());
129 interceptor_->interceptorId_ = 1;
130 ASSERT_NO_FATAL_FAILURE(interceptor_->Enable(context));
131 interceptor_->pointerEventTimer_ = 1;
132 ASSERT_NO_FATAL_FAILURE(interceptor_->Disable());
133 }
134
135 /**
136 * @tc.name: UpdateTest001
137 * @tc.desc: Test UpdateTest001
138 * @tc.type: FUNC
139 */
140 HWTEST_F(InputEventInterceptorTest, UpdateTest001, TestSize.Level1)
141 {
142 CALL_TEST_DEBUG;
143 Context context(env_);
144 ASSERT_NO_FATAL_FAILURE(interceptor_->Update(context));
145 }
146
147 /**
148 * @tc.name: OnPointerEventTest01
149 * @tc.desc: Test OnPointerEventTest01
150 * @tc.type: FUNC
151 */
152 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest01, TestSize.Level1)
153 {
154 CALL_TEST_DEBUG;
155 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
156 ASSERT_NE(pointerEvent, nullptr);
157 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
158 interceptor_->scanState_ = false;
159 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
160 }
161
162 /**
163 * @tc.name: OnPointerEventTest02
164 * @tc.desc: Test OnPointerEventTest02
165 * @tc.type: FUNC
166 */
167 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest02, TestSize.Level1)
168 {
169 CALL_TEST_DEBUG;
170 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
171 ASSERT_NE(pointerEvent, nullptr);
172 interceptor_->pointerEventTimer_ = 1;
173 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
174 }
175
176 /**
177 * @tc.name: OnPointerEventTest03
178 * @tc.desc: Test OnPointerEventTest03
179 * @tc.type: FUNC
180 */
181 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest03, TestSize.Level1)
182 {
183 CALL_TEST_DEBUG;
184 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
185 ASSERT_NE(pointerEvent, nullptr);
186 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
187 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
188 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
189 }
190
191 /**
192 * @tc.name: OnPointerEventTest04
193 * @tc.desc: Test OnPointerEventTest04
194 * @tc.type: FUNC
195 */
196 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest04, TestSize.Level1)
197 {
198 CALL_TEST_DEBUG;
199 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
200 ASSERT_NE(pointerEvent, nullptr);
201 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
202 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
203 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
204 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
205 }
206
207 /**
208 * @tc.name: OnPointerEventTest05
209 * @tc.desc: Test OnPointerEventTest05
210 * @tc.type: FUNC
211 */
212 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest05, TestSize.Level1)
213 {
214 CALL_TEST_DEBUG;
215 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
216 ASSERT_NE(pointerEvent, nullptr);
217 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
218 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
219 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
220 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
221 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
222 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
223 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
224 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
225 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
226 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
227 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
228 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
229 }
230
231 /**
232 * @tc.name: OnKeyEventTest001
233 * @tc.desc: Test OnKeyEventTest001
234 * @tc.type: FUNC
235 */
236 HWTEST_F(InputEventInterceptorTest, OnKeyEventTest001, TestSize.Level1)
237 {
238 CALL_TEST_DEBUG;
239 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
240 ASSERT_NE(keyEvent, nullptr);
241 interceptor_->OnKeyEvent(keyEvent);
242 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
243 ASSERT_NO_FATAL_FAILURE(interceptor_->OnKeyEvent(keyEvent));
244 }
245
246 /**
247 * @tc.name: InputEventInterceptorTest_ReportPointerEvent
248 * @tc.desc: Test Test the funcation Enable
249 * @tc.type: FUNC
250 */
251 HWTEST_F(InputEventInterceptorTest, InputEventInterceptorTest_ReportPointerEvent, TestSize.Level1)
252 {
253 CALL_TEST_DEBUG;
254 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
255 ASSERT_NE(pointerEvent, nullptr);
256 ASSERT_NO_FATAL_FAILURE(interceptor_->ReportPointerEvent(pointerEvent));
257 pointerEvent->SetPointerId(1);
258 MMI::PointerEvent::PointerItem pointerItem;
259 pointerItem.SetPointerId(1);
260 pointerItem.SetDeviceId(1);
261 pointerItem.SetDisplayX(0);
262 pointerItem.SetDisplayY(0);
263 pointerEvent->AddPointerItem(pointerItem);
264 ASSERT_NO_FATAL_FAILURE(interceptor_->ReportPointerEvent(pointerEvent));
265 }
266 } //namespace Cooperate
267 } // namespace DeviceStatus
268 } // namespace Msdp
269 } // namespace OHOS