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
17 #undef LOG_TAG
18 #define LOG_TAG "InputEventInterceptorTest"
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 InputEventInterceptor *interceptor_ = {nullptr};
33 auto env_ = ContextService::GetInstance();
34 } // namespace
35
ContextService()36 ContextService::ContextService() {}
~ContextService()37 ContextService::~ContextService() {}
38
GetDelegateTasks()39 IDelegateTasks& ContextService::GetDelegateTasks()
40 {
41 return delegateTasks_;
42 }
43
GetDeviceManager()44 IDeviceManager& ContextService::GetDeviceManager()
45 {
46 return devMgr_;
47 }
48
GetTimerManager()49 ITimerManager& ContextService::GetTimerManager()
50 {
51 return timerMgr_;
52 }
53
GetDragManager()54 IDragManager& ContextService::GetDragManager()
55 {
56 return dragMgr_;
57 }
58
GetInstance()59 ContextService* ContextService::GetInstance()
60 {
61 static std::once_flag flag;
62 std::call_once(flag, [&]() {
63 ContextService *cooContext = new (std::nothrow) ContextService();
64 CHKPL(cooContext);
65 g_instance = cooContext;
66 });
67 return g_instance;
68 }
69
GetSocketSessionManager()70 ISocketSessionManager& ContextService::GetSocketSessionManager()
71 {
72 return socketSessionMgr_;
73 }
74
GetPluginManager()75 IPluginManager& ContextService::GetPluginManager()
76 {
77 return *pluginMgr_;
78 }
79
GetInput()80 IInputAdapter& ContextService::GetInput()
81 {
82 return *input_;
83 }
84
GetDSoftbus()85 IDSoftbusAdapter& ContextService::GetDSoftbus()
86 {
87 return *dsoftbus_;
88 }
89
SetUpTestCase()90 void InputEventInterceptorTest::SetUpTestCase()
91 {
92 ASSERT_NE(env_, nullptr);
93 interceptor_ = new InputEventInterceptor(env_);
94 ASSERT_NE(interceptor_, nullptr);
95 dsoftbus_ = std::make_unique<DSoftbusAdapter>();
96 input_ = std::make_unique<InputAdapter>();
97 }
98
TearDownTestCase()99 void InputEventInterceptorTest::TearDownTestCase()
100 {
101 delete interceptor_;
102 interceptor_ = nullptr;
103 }
104
SetUp()105 void InputEventInterceptorTest::SetUp() {}
TearDown()106 void InputEventInterceptorTest::TearDown() {}
107
108 /**
109 * @tc.name: EnableTest001
110 * @tc.desc: Test EnableTest001
111 * @tc.type: FUNC
112 */
113 HWTEST_F(InputEventInterceptorTest, EnableTest001, TestSize.Level1)
114 {
115 CALL_TEST_DEBUG;
116 Context context(env_);
117 ASSERT_NO_FATAL_FAILURE(interceptor_->Enable(context));
118 interceptor_->interceptorId_ = 1;
119 ASSERT_NO_FATAL_FAILURE(interceptor_->Enable(context));
120 }
121
122 /**
123 * @tc.name: UpdateTest001
124 * @tc.desc: Test UpdateTest001
125 * @tc.type: FUNC
126 */
127 HWTEST_F(InputEventInterceptorTest, UpdateTest001, TestSize.Level1)
128 {
129 CALL_TEST_DEBUG;
130 Context context(env_);
131 ASSERT_NO_FATAL_FAILURE(interceptor_->Update(context));
132 }
133
134 /**
135 * @tc.name: OnPointerEventTest001
136 * @tc.desc: Test OnPointerEventTest001
137 * @tc.type: FUNC
138 */
139 HWTEST_F(InputEventInterceptorTest, OnPointerEventTest001, TestSize.Level1)
140 {
141 CALL_TEST_DEBUG;
142 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
143 ASSERT_NE(pointerEvent, nullptr);
144 interceptor_->OnPointerEvent(pointerEvent);
145 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
146 interceptor_->OnPointerEvent(pointerEvent);
147 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
148 ASSERT_NO_FATAL_FAILURE(interceptor_->OnPointerEvent(pointerEvent));
149 }
150
151 /**
152 * @tc.name: OnKeyEventTest001
153 * @tc.desc: Test OnKeyEventTest001
154 * @tc.type: FUNC
155 */
156 HWTEST_F(InputEventInterceptorTest, OnKeyEventTest001, TestSize.Level1)
157 {
158 CALL_TEST_DEBUG;
159 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
160 ASSERT_NE(keyEvent, nullptr);
161 interceptor_->OnKeyEvent(keyEvent);
162 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
163 ASSERT_NO_FATAL_FAILURE(interceptor_->OnKeyEvent(keyEvent));
164 }
165
166 /**
167 * @tc.name: InputEventInterceptorTest_ReportPointerEvent
168 * @tc.desc: Test Test the funcation Enable
169 * @tc.type: FUNC
170 */
171 HWTEST_F(InputEventInterceptorTest, InputEventInterceptorTest_ReportPointerEvent, TestSize.Level1)
172 {
173 CALL_TEST_DEBUG;
174 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
175 ASSERT_NE(pointerEvent, nullptr);
176 ASSERT_NO_FATAL_FAILURE(interceptor_->ReportPointerEvent(pointerEvent));
177 MMI::PointerEvent::PointerItem pointerItem;
178 pointerItem.SetPointerId(1);
179 pointerEvent->AddPointerItem(pointerItem);
180 ASSERT_NO_FATAL_FAILURE(interceptor_->ReportPointerEvent(pointerEvent));
181 }
182 } //namespace Cooperate
183 } // namespace DeviceStatus
184 } // namespace Msdp
185 } // namespace OHOS