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 void SetUp() override;
38 void TearDown() override;
39 std::shared_ptr<MMI::KeyEvent> CreateKeyEvent(int32_t keyCode, int32_t keyAction);
40
41 std::shared_ptr<AccessibilityShortKey> shortKey_ = nullptr;
42 };
43
SetUpTestCase()44 void AccessibilityShortKeyUnitTest::SetUpTestCase()
45 {
46 GTEST_LOG_(INFO) << "###################### AccessibilityShortKeyUnitTest Start ######################";
47 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
48 }
49
TearDownTestCase()50 void AccessibilityShortKeyUnitTest::TearDownTestCase()
51 {
52 GTEST_LOG_(INFO) << "###################### AccessibilityShortKeyUnitTest End ######################";
53 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
54 }
55
SetUp()56 void AccessibilityShortKeyUnitTest::SetUp()
57 {
58 GTEST_LOG_(INFO) << "SetUp";
59 shortKey_ = std::make_shared<AccessibilityShortKey>();
60 }
61
TearDown()62 void AccessibilityShortKeyUnitTest::TearDown()
63 {
64 GTEST_LOG_(INFO) << "TearDown";
65 shortKey_ = nullptr;
66 }
67
CreateKeyEvent(int32_t keyCode,int32_t keyAction)68 std::shared_ptr<MMI::KeyEvent> AccessibilityShortKeyUnitTest::CreateKeyEvent(int32_t keyCode, int32_t keyAction)
69 {
70 std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
71 if (!event) {
72 return nullptr;
73 }
74 event->SetKeyCode(keyCode);
75 event->SetKeyAction(keyAction);
76 return event;
77 }
78
79 /**
80 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_001
81 * @tc.name: OnKeyEvent
82 * @tc.desc: Test function OnKeyEvent(press '5' key)
83 * @tc.require: issueI5NTXH
84 */
85 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_001, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_001 start";
88 if (!shortKey_) {
89 return;
90 }
91 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_NUMPAD_5,
92 MMI::KeyEvent::KEY_ACTION_DOWN);
93 if (!event) {
94 return;
95 }
96 MMI::KeyEvent::KeyItem item;
97 item.SetPressed(true);
98 event->AddKeyItem(item);
99 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
100 shortKey_->OnKeyEvent(*event);
101 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
102 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_NUMPAD_5);
103
104 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_001 end";
105 }
106
107 /**
108 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_002
109 * @tc.name: OnKeyEvent
110 * @tc.desc: Test function OnKeyEvent
111 * @tc.require: issueI5NTXH
112 */
113 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_002, TestSize.Level1)
114 {
115 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_002 start";
116 if (!shortKey_) {
117 return;
118 }
119 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
120 MMI::KeyEvent::KEY_ACTION_DOWN);
121 if (!event) {
122 return;
123 }
124 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
125 shortKey_->OnKeyEvent(*event);
126 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
127 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
128
129 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_002 end";
130 }
131
132 /**
133 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_003
134 * @tc.name: OnKeyEvent
135 * @tc.desc: Test function OnKeyEvent(Long press the power key)
136 * @tc.require: issueI5NTXH
137 */
138 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_003, TestSize.Level1)
139 {
140 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_003 start";
141 if (!shortKey_) {
142 return;
143 }
144 std::shared_ptr<MMI::KeyEvent> event = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
145 MMI::KeyEvent::KEY_ACTION_DOWN);
146 if (!event) {
147 return;
148 }
149 MMI::KeyEvent::KeyItem item;
150 item.SetPressed(true);
151 event->AddKeyItem(item);
152 AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
153 shortKey_->OnKeyEvent(*event);
154 sleep(2);
155 int32_t keyCode = AccessibilityAbilityHelper::GetInstance().GetKeyCode();
156 EXPECT_EQ(keyCode, MMI::KeyEvent::KEYCODE_POWER);
157
158 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_003 end";
159 }
160
161 /**
162 * @tc.number: AccessibilityShortKey_Unittest_OnKeyEvent_004
163 * @tc.name: OnKeyEvent
164 * @tc.desc: Test function OnKeyEvent(Press the power button 3 times)
165 * @tc.require: issueI5NTXH
166 */
167 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_OnKeyEvent_004, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_004 start";
170 if (!shortKey_) {
171 return;
172 }
173 // power key(down)
174 std::shared_ptr<MMI::KeyEvent> downEvent = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
175 MMI::KeyEvent::KEY_ACTION_DOWN);
176 if (!downEvent) {
177 return;
178 }
179 MMI::KeyEvent::KeyItem item;
180 item.SetPressed(true);
181 downEvent->AddKeyItem(item);
182 shortKey_->OnKeyEvent(*downEvent);
183 // power key(up)
184 std::shared_ptr<MMI::KeyEvent> upEvent = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
185 MMI::KeyEvent::KEY_ACTION_UP);
186 if (!upEvent) {
187 return;
188 }
189 shortKey_->OnKeyEvent(*upEvent);
190
191 // power key(down)
192 std::shared_ptr<MMI::KeyEvent> downEvent1 = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
193 MMI::KeyEvent::KEY_ACTION_DOWN);
194 if (!downEvent1) {
195 return;
196 }
197 MMI::KeyEvent::KeyItem item1;
198 item1.SetPressed(true);
199 downEvent1->AddKeyItem(item1);
200 shortKey_->OnKeyEvent(*downEvent1);
201 // power key(up)
202 std::shared_ptr<MMI::KeyEvent> upEvent1 = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
203 MMI::KeyEvent::KEY_ACTION_UP);
204 if (!upEvent1) {
205 return;
206 }
207 shortKey_->OnKeyEvent(*upEvent1);
208
209 // power key(down)
210 std::shared_ptr<MMI::KeyEvent> downEvent2 = CreateKeyEvent(MMI::KeyEvent::KEYCODE_POWER,
211 MMI::KeyEvent::KEY_ACTION_DOWN);
212 if (!downEvent2) {
213 return;
214 }
215 MMI::KeyEvent::KeyItem item2;
216 item2.SetPressed(true);
217 downEvent2->AddKeyItem(item2);
218 shortKey_->OnKeyEvent(*downEvent2);
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