1 /*
2 * Copyright (c) 2021-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 "white_list_test.h"
17 #include "constants_dinput.h"
18 #include "dinput_errcode.h"
19 #include "white_list_util.h"
20
21 using namespace testing::ext;
22 using namespace OHOS::DistributedHardware::DistributedInput;
23 using namespace std;
24
25 namespace OHOS {
26 namespace DistributedHardware {
27 namespace DistributedInput {
SetUp()28 void WhiteListTest::SetUp()
29 {
30 }
31
TearDown()32 void WhiteListTest::TearDown()
33 {
34 }
35
SetUpTestCase()36 void WhiteListTest::SetUpTestCase()
37 {
38 }
39
TearDownTestCase()40 void WhiteListTest::TearDownTestCase()
41 {
42 }
43
44 HWTEST_F(WhiteListTest, SyncWhiteList01, testing::ext::TestSize.Level0)
45 {
46 // 11|22,33|44,55,66
47 // 1,2|3,4,5
48 std::string deviceId = "test";
49 TYPE_KEY_CODE_VEC vecKeyCode;
50 TYPE_COMBINATION_KEY_VEC vecCombinationKey;
51 TYPE_WHITE_LIST_VEC vecWhiteList;
52 vecKeyCode.push_back(11);
53 vecKeyCode.push_back(22);
54 vecCombinationKey.push_back(vecKeyCode);
55 vecKeyCode.clear();
56 vecKeyCode.push_back(33);
57 vecKeyCode.push_back(44);
58 vecCombinationKey.push_back(vecKeyCode);
59 vecKeyCode.clear();
60 vecKeyCode.push_back(55);
61 vecCombinationKey.push_back(vecKeyCode);
62 vecKeyCode.clear();
63 vecKeyCode.push_back(66);
64 vecCombinationKey.push_back(vecKeyCode);
65 vecWhiteList.push_back(vecCombinationKey);
66 vecKeyCode.clear();
67 vecCombinationKey.clear();
68 int32_t ret = WhiteListUtil::GetInstance().SyncWhiteList(deviceId, vecWhiteList);
69 EXPECT_EQ(DH_SUCCESS, ret);
70 }
71
72 HWTEST_F(WhiteListTest, SyncWhiteList02, testing::ext::TestSize.Level0)
73 {
74 // 11|22,33|44,55,66
75 // 1,2|3,4,5
76 std::string deviceId = "test1";
77 TYPE_KEY_CODE_VEC vecKeyCode;
78 TYPE_COMBINATION_KEY_VEC vecCombinationKey;
79 TYPE_WHITE_LIST_VEC vecWhiteList;
80
81 vecKeyCode.push_back(1);
82 vecCombinationKey.push_back(vecKeyCode);
83 vecKeyCode.clear();
84 vecKeyCode.push_back(2);
85 vecKeyCode.push_back(3);
86 vecCombinationKey.push_back(vecKeyCode);
87 vecKeyCode.clear();
88 vecKeyCode.push_back(4);
89 vecCombinationKey.push_back(vecKeyCode);
90 vecKeyCode.clear();
91 vecKeyCode.push_back(5);
92 vecCombinationKey.push_back(vecKeyCode);
93 vecWhiteList.push_back(vecCombinationKey);
94 vecKeyCode.clear();
95 vecCombinationKey.clear();
96 int32_t ret = WhiteListUtil::GetInstance().SyncWhiteList(deviceId, vecWhiteList);
97 EXPECT_EQ(DH_SUCCESS, ret);
98 }
99
100 HWTEST_F(WhiteListTest, SyncWhiteList03, testing::ext::TestSize.Level0)
101 {
102 // 1,2,1,2
103 std::string deviceId = "test1";
104 TYPE_KEY_CODE_VEC vecKeyCode;
105 TYPE_COMBINATION_KEY_VEC vecCombinationKey;
106 TYPE_WHITE_LIST_VEC vecWhiteList;
107
108 vecKeyCode.push_back(1);
109 vecCombinationKey.push_back(vecKeyCode);
110 vecKeyCode.clear();
111 vecKeyCode.push_back(2);
112 vecCombinationKey.push_back(vecKeyCode);
113 vecKeyCode.clear();
114 vecKeyCode.push_back(1);
115 vecCombinationKey.push_back(vecKeyCode);
116 vecKeyCode.clear();
117 vecKeyCode.push_back(2);
118 vecCombinationKey.push_back(vecKeyCode);
119 vecWhiteList.push_back(vecCombinationKey);
120 vecKeyCode.clear();
121 vecCombinationKey.clear();
122 int32_t ret = WhiteListUtil::GetInstance().SyncWhiteList(deviceId, vecWhiteList);
123 EXPECT_EQ(DH_SUCCESS, ret);
124 }
125
126 HWTEST_F(WhiteListTest, SyncWhiteList04, testing::ext::TestSize.Level0)
127 {
128 // 2,8|3,4,5
129 std::string deviceId = "test1";
130 TYPE_KEY_CODE_VEC vecKeyCode;
131 TYPE_COMBINATION_KEY_VEC vecCombinationKey;
132 TYPE_WHITE_LIST_VEC vecWhiteList;
133 vecKeyCode.push_back(2);
134 vecCombinationKey.push_back(vecKeyCode);
135 vecKeyCode.clear();
136 vecKeyCode.push_back(8);
137 vecKeyCode.push_back(3);
138 vecCombinationKey.push_back(vecKeyCode);
139 vecKeyCode.clear();
140 vecKeyCode.push_back(4);
141 vecCombinationKey.push_back(vecKeyCode);
142 vecKeyCode.clear();
143 vecKeyCode.push_back(5);
144 vecCombinationKey.push_back(vecKeyCode);
145 vecWhiteList.push_back(vecCombinationKey);
146 vecKeyCode.clear();
147 vecCombinationKey.clear();
148 int32_t ret = WhiteListUtil::GetInstance().SyncWhiteList(deviceId, vecWhiteList);
149 EXPECT_EQ(DH_SUCCESS, ret);
150 }
151
152 HWTEST_F(WhiteListTest, GetWhiteList01, testing::ext::TestSize.Level0)
153 {
154 std::string deviceId = "test";
155 TYPE_WHITE_LIST_VEC vecWhiteList;
156 int32_t ret = WhiteListUtil::GetInstance().GetWhiteList(deviceId, vecWhiteList);
157 EXPECT_EQ(DH_SUCCESS, ret);
158 }
159
160 HWTEST_F(WhiteListTest, GetWhiteList02, testing::ext::TestSize.Level0)
161 {
162 std::string deviceId = "test1";
163 TYPE_WHITE_LIST_VEC vecWhiteList;
164 int32_t ret = WhiteListUtil::GetInstance().GetWhiteList(deviceId, vecWhiteList);
165 EXPECT_EQ(DH_SUCCESS, ret);
166 }
167
168 HWTEST_F(WhiteListTest, GetWhiteList03, testing::ext::TestSize.Level0)
169 {
170 std::string deviceId = "xxx";
171 TYPE_WHITE_LIST_VEC vecWhiteList;
172 int32_t ret = WhiteListUtil::GetInstance().GetWhiteList(deviceId, vecWhiteList);
173 EXPECT_EQ(ERR_DH_INPUT_WHILTELIST_GET_WHILTELIST_FAIL, ret);
174 }
175
176 HWTEST_F(WhiteListTest, GetWhiteList04, testing::ext::TestSize.Level0)
177 {
178 std::string deviceId = "";
179 TYPE_WHITE_LIST_VEC vecWhiteList;
180 int32_t ret = WhiteListUtil::GetInstance().GetWhiteList(deviceId, vecWhiteList);
181 EXPECT_EQ(ERR_DH_INPUT_WHILTELIST_GET_WHILTELIST_FAIL, ret);
182 }
183
184 HWTEST_F(WhiteListTest, IsNeedFilterOut01, testing::ext::TestSize.Level0)
185 {
186 // 11,33,55,66
187 std::string deviceId = "test";
188 BusinessEvent event;
189 event.pressedKeys.push_back(11);
190 event.pressedKeys.push_back(33);
191 event.keyCode = 55;
192 event.keyAction = 66;
193 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
194 EXPECT_EQ(true, ret);
195 }
196
197 HWTEST_F(WhiteListTest, IsNeedFilterOut02, testing::ext::TestSize.Level0)
198 {
199 // 11,44,55,66
200 std::string deviceId = "test";
201 BusinessEvent event;
202 event.pressedKeys.push_back(11);
203 event.pressedKeys.push_back(44);
204 event.keyCode = 55;
205 event.keyAction = 66;
206 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
207 EXPECT_EQ(true, ret);
208 }
209
210 HWTEST_F(WhiteListTest, IsNeedFilterOut03, testing::ext::TestSize.Level0)
211 {
212 // 22,33,55,66
213 std::string deviceId = "test";
214 BusinessEvent event;
215 event.pressedKeys.push_back(22);
216 event.pressedKeys.push_back(33);
217 event.keyCode = 55;
218 event.keyAction = 66;
219 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
220 EXPECT_EQ(true, ret);
221 }
222
223 HWTEST_F(WhiteListTest, IsNeedFilterOut04, testing::ext::TestSize.Level0)
224 {
225 // 22,44,55,66
226 std::string deviceId = "test";
227 BusinessEvent event;
228 event.pressedKeys.push_back(22);
229 event.pressedKeys.push_back(44);
230 event.keyCode = 55;
231 event.keyAction = 66;
232 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
233 EXPECT_EQ(true, ret);
234 }
235
236 HWTEST_F(WhiteListTest, IsNeedFilterOut05, testing::ext::TestSize.Level0)
237 {
238 // 1,2,4,5
239 std::string deviceId = "test";
240 BusinessEvent event;
241 event.pressedKeys.push_back(1);
242 event.pressedKeys.push_back(2);
243 event.keyCode = 4;
244 event.keyAction = 5;
245 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
246 EXPECT_EQ(false, ret);
247 }
248
249 HWTEST_F(WhiteListTest, IsNeedFilterOut06, testing::ext::TestSize.Level0)
250 {
251 // 1,3,4,5
252 std::string deviceId = "test";
253 BusinessEvent event;
254 event.pressedKeys.push_back(1);
255 event.pressedKeys.push_back(3);
256 event.keyCode = 4;
257 event.keyAction = 5;
258 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
259 EXPECT_EQ(false, ret);
260 }
261
262 HWTEST_F(WhiteListTest, IsNeedFilterOut07, testing::ext::TestSize.Level0)
263 {
264 // 2,2,4,5
265 std::string deviceId = "test";
266 BusinessEvent event;
267 event.pressedKeys.push_back(2);
268 event.pressedKeys.push_back(2);
269 event.keyCode = 4;
270 event.keyAction = 5;
271 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
272 EXPECT_EQ(false, ret);
273 }
274
275 HWTEST_F(WhiteListTest, IsNeedFilterOut08, testing::ext::TestSize.Level0)
276 {
277 // 1,1,4,5
278 std::string deviceId = "test";
279 BusinessEvent event;
280 event.pressedKeys.push_back(1);
281 event.pressedKeys.push_back(1);
282 event.keyCode = 4;
283 event.keyAction = 5;
284 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
285 EXPECT_EQ(false, ret);
286 }
287
288 HWTEST_F(WhiteListTest, IsNeedFilterOut09, testing::ext::TestSize.Level0)
289 {
290 // 1,2,1,5
291 std::string deviceId = "test";
292 BusinessEvent event;
293 event.pressedKeys.push_back(1);
294 event.pressedKeys.push_back(2);
295 event.keyCode = 1;
296 event.keyAction = 5;
297 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
298 EXPECT_EQ(false, ret);
299 }
300
301 HWTEST_F(WhiteListTest, IsNeedFilterOut10, testing::ext::TestSize.Level0)
302 {
303 // 1,2,4,1
304 std::string deviceId = "test";
305 BusinessEvent event;
306 event.pressedKeys.push_back(1);
307 event.pressedKeys.push_back(2);
308 event.keyCode = 4;
309 event.keyAction = 1;
310 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
311 EXPECT_EQ(false, ret);
312 }
313
314 HWTEST_F(WhiteListTest, IsNeedFilterOut11, testing::ext::TestSize.Level0)
315 {
316 // 1,2,4,5,6
317 std::string deviceId = "test";
318 BusinessEvent event;
319 event.pressedKeys.push_back(1);
320 event.pressedKeys.push_back(2);
321 event.pressedKeys.push_back(4);
322 event.keyCode = 5;
323 event.keyAction = 6;
324 bool ret = WhiteListUtil::GetInstance().IsNeedFilterOut(deviceId, event);
325 EXPECT_EQ(false, ret);
326 }
327
328 HWTEST_F(WhiteListTest, ClearWhiteList01, testing::ext::TestSize.Level0)
329 {
330 std::string deviceId = "test";
331 int32_t ret = WhiteListUtil::GetInstance().ClearWhiteList(deviceId);
332 EXPECT_EQ(DH_SUCCESS, ret);
333 }
334
335 HWTEST_F(WhiteListTest, ClearWhiteList02, testing::ext::TestSize.Level0)
336 {
337 std::string deviceId = "test1";
338 int32_t ret = WhiteListUtil::GetInstance().ClearWhiteList(deviceId);
339 EXPECT_EQ(DH_SUCCESS, ret);
340 }
341
342 HWTEST_F(WhiteListTest, ClearWhiteList03, testing::ext::TestSize.Level0)
343 {
344 std::string deviceId;
345 int32_t ret = WhiteListUtil::GetInstance().ClearWhiteList(deviceId);
346 EXPECT_EQ(DH_SUCCESS, ret);
347 }
348 } // namespace DistributedInput
349 } // namespace DistributedHardware
350 } // namespace OHOS
351