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 #include <map>
18 #include <memory>
19 #include "accessibility_short_key.h"
20 #include "accessibility_ut_helper.h"
21 #include "accessible_ability_manager_service.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Accessibility {
28 class AccessibilityShortKeyUnitTest : public ::testing::Test {
29 public:
AccessibilityShortKeyUnitTest()30 AccessibilityShortKeyUnitTest()
31 {}
~AccessibilityShortKeyUnitTest()32 ~AccessibilityShortKeyUnitTest()
33 {}
34
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 bool OnKeyEventDown();
38 void SetUp() override;
39 void TearDown() override;
40 std::shared_ptr<MMI::KeyEvent> CreateKeyEvent(int32_t keyCode, int32_t keyAction);
41
42 std::shared_ptr<AccessibilityShortKey> shortKey_ = nullptr;
43 };
44
SetUpTestCase()45 void AccessibilityShortKeyUnitTest::SetUpTestCase()
46 {
47 GTEST_LOG_(INFO) << "###################### AccessibilityShortKeyUnitTest Start ######################";
48 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
49 }
50
TearDownTestCase()51 void AccessibilityShortKeyUnitTest::TearDownTestCase()
52 {
53 GTEST_LOG_(INFO) << "###################### AccessibilityShortKeyUnitTest End ######################";
54 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
55 }
56
SetUp()57 void AccessibilityShortKeyUnitTest::SetUp()
58 {
59 GTEST_LOG_(INFO) << "SetUp";
60 shortKey_ = std::make_shared<AccessibilityShortKey>();
61 }
62
TearDown()63 void AccessibilityShortKeyUnitTest::TearDown()
64 {
65 GTEST_LOG_(INFO) << "TearDown";
66 shortKey_ = nullptr;
67 }
68
CreateKeyEvent(int32_t keyCode,int32_t keyAction)69 std::shared_ptr<MMI::KeyEvent> AccessibilityShortKeyUnitTest::CreateKeyEvent(int32_t keyCode, int32_t keyAction)
70 {
71 std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
72 if (!event) {
73 return nullptr;
74 }
75 event->SetKeyCode(keyCode);
76 event->SetKeyAction(keyAction);
77 return event;
78 }
79
OnKeyEventDown()80 bool AccessibilityShortKeyUnitTest::OnKeyEventDown()
81 {
82 std::shared_ptr<MMI::KeyEvent> downEvent = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
83 MMI::KeyEvent::KEY_ACTION_DOWN);
84 if (!downEvent) {
85 return false;
86 }
87 MMI::KeyEvent::KeyItem item;
88 item.SetPressed(true);
89 downEvent->AddKeyItem(item);
90 shortKey_->OnKeyEvent(*downEvent);
91 return true;
92 }
93
94 /**
95 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_001
96 * @tc.name: OnKeyEvent
97 * @tc.desc: Test function OnKeyEvent(press '5' key)
98 * @tc.require: issueI5NTXH
99 */
100 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_001, TestSize.Level1)
101 {
102 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_001 start";
103 if (!shortKey_) {
104 return;
105 }
106 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_NUMPAD_5,
107 MMI::KeyEvent::KEY_ACTION_DOWN);
108 if (!event) {
109 return;
110 }
111 MMI::KeyEvent::KeyItem item;
112 item.SetPressed(true);
113 event->AddKeyItem(item);
114 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
115 shortKey_->OnKeyEvent(*event);
116 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
117 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_NUMPAD_5);
118
119 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_001 end";
120 }
121
122 /**
123 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_002
124 * @tc.name: OnKeyEvent
125 * @tc.desc: Test function OnKeyEvent
126 * @tc.require: issueI5NTXH
127 */
128 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_002, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_002 start";
131 if (!shortKey_) {
132 return;
133 }
134 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
135 MMI::KeyEvent::KEY_ACTION_DOWN);
136 if (!event) {
137 return;
138 }
139 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
140 shortKey_->OnKeyEvent(*event);
141 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
142 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
143
144 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_002 end";
145 }
146
147 /**
148 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_003
149 * @tc.name: OnKeyEvent
150 * @tc.desc: Test function OnKeyEvent(Long press the power key)
151 * @tc.require: issueI5NTXH
152 */
153 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_003, TestSize.Level1)
154 {
155 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_003 start";
156 if (!shortKey_) {
157 return;
158 }
159 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
160 MMI::KeyEvent::KEY_ACTION_DOWN);
161 if (!event) {
162 return;
163 }
164 MMI::KeyEvent::KeyItem item;
165 item.SetPressed(true);
166 event->AddKeyItem(item);
167 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
168 shortKey_->OnKeyEvent(*event);
169 sleep(2);
170 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
171 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
172
173 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_003 end";
174 }
175
176 /**
177 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_004
178 * @tc.name: OnKeyEvent
179 * @tc.desc: Test function OnKeyEvent(Press the power button 3 times)
180 * @tc.require: issueI5NTXH
181 */
182 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_004, TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_004 start";
185 if (!shortKey_) {
186 return;
187 }
188 // power key(down)
189 if (!OnKeyEventDown()) {
190 return;
191 }
192
193 // power key(up)
194 std::shared_ptr<MMI::KeyEvent> upEvent = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
195 MMI::KeyEvent::KEY_ACTION_UP);
196 if (!upEvent) {
197 return;
198 }
199 shortKey_->OnKeyEvent(*upEvent);
200
201 // power key(down)
202 if (!OnKeyEventDown()) {
203 return;
204 }
205
206 // power key(up)
207 std::shared_ptr<MMI::KeyEvent> upEvent1 = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
208 MMI::KeyEvent::KEY_ACTION_UP);
209 if (!upEvent1) {
210 return;
211 }
212 shortKey_->OnKeyEvent(*upEvent1);
213
214 // power key(down)
215 if (!OnKeyEventDown()) {
216 return;
217 }
218
219 // power key(up)
220 std::shared_ptr<MMI::KeyEvent> upEvent2 = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
221 MMI::KeyEvent::KEY_ACTION_UP);
222 if (!upEvent2) {
223 return;
224 }
225 shortKey_->OnKeyEvent(*upEvent2);
226 bool state = AccessibilityAbilityHelper::GetInstance().GetShortKeyTargetAbilityState();
227 EXPECT_TRUE(state);
228
229 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_004 end";
230 }
231
232 /**
233 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_005
234 * @tc.name: OnKeyEvent
235 * @tc.desc: Test function OnKeyEvent(power key up)
236 * @tc.require: issueI5NTXH
237 */
238 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_005, TestSize.Level1)
239 {
240 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_005 start";
241 if (!shortKey_) {
242 return;
243 }
244 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
245 MMI::KeyEvent::KEY_ACTION_UP);
246 if (!event) {
247 return;
248 }
249 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
250 shortKey_->OnKeyEvent(*event);
251 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
252 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
253
254 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_005 end";
255 }
256
257 /**
258 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_006
259 * @tc.name: OnKeyEvent
260 * @tc.desc: Test function OnKeyEvent(power key cancel)
261 * @tc.require: issueI5NTXH
262 */
263 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_006, TestSize.Level1)
264 {
265 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_006 start";
266 if (!shortKey_) {
267 return;
268 }
269 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
270 MMI::KeyEvent::KEY_ACTION_CANCEL);
271 if (!event) {
272 return;
273 }
274 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
275 shortKey_->OnKeyEvent(*event);
276 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
277 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
278
279 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_006 end";
280 }
281 } // namespace Accessibility
282 } // namespace OHOS