1 /*
2  * Copyright (C) 2023 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 #define private public
17 #define protected public
18 #include "enable_ime_data_parser.h"
19 #include "ime_info_inquirer.h"
20 
21 #undef private
22 
23 #include <gtest/gtest.h>
24 
25 using namespace testing::ext;
26 using namespace OHOS::DataShare;
27 namespace OHOS {
28 namespace MiscServices {
29 const std::string IME_KEY = "settings.inputmethod.enable_ime";
30 class EnableImeDataParseTest : public testing::Test {
31 public:
32     static void SetUpTestCase(void);
33     static void TearDownTestCase(void);
34     void SetUp();
35     void TearDown();
36     static std::shared_ptr<DataShareHelper> helper_;
37     static std::shared_ptr<DataShareResultSet> resultSet_;
38     static constexpr int32_t USER_ID = 100;
39 };
40 std::shared_ptr<DataShareHelper> EnableImeDataParseTest::helper_;
41 std::shared_ptr<DataShareResultSet> EnableImeDataParseTest::resultSet_;
42 constexpr uint32_t USER_100_TOTAL_COUNT = 3;
43 constexpr uint32_t USER_101_TOTAL_COUNT = 1;
SetUpTestCase(void)44 void EnableImeDataParseTest::SetUpTestCase(void)
45 {
46     std::vector<std::string> columns = { "VALUE" };
47     helper_ = DataShare::DataShareHelper::Creator(nullptr, "tsetUri", "tsetUri");
48     DataSharePredicates predicates;
49     Uri uri("tsetUri");
50     resultSet_ = helper_->Query(uri, predicates, columns);
51     EnableImeDataParser::GetInstance()->Initialize(USER_ID);
52     ImeInfoInquirer::currentIme_ = std::make_shared<Property>();
53     ImeInfoInquirer::defaultImeProperty_ = std::make_shared<Property>();
54     ImeInfoInquirer::defaultIme_ = std::make_shared<ImeInfo>();
55     ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp()->name = "defaultImeName";
56     ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp()->id = "defaultImeId";
57 }
58 
TearDownTestCase(void)59 void EnableImeDataParseTest::TearDownTestCase(void)
60 {
61 }
62 
SetUp()63 void EnableImeDataParseTest::SetUp()
64 {
65     resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [ \"xiaoyiIme\", \"baiduIme\", "
66                             "\"sougouIme\"],\"101\" : [\"sougouIme\"]}}";
67 
68     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "defaultImeName";
69     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "defaultImeId";
70     EnableImeDataParser::GetInstance()->enableList_.clear();
71 }
72 
TearDown()73 void EnableImeDataParseTest::TearDown()
74 {
75 }
76 
77 /**
78  * @tc.name: testGetEnableData_001
79  * @tc.desc: Get 100 user enable ime
80  * @tc.type: FUNC
81  * @tc.require:
82  * @tc.author: mashaoyin
83  */
84 HWTEST_F(EnableImeDataParseTest, testGetEnableData_001, TestSize.Level0)
85 {
86     IMSA_HILOGI("EnableImeDataParseTest testGetEnableData_001 START");
87     std::vector<std::string> enableVec;
88     int32_t ret =
89         EnableImeDataParser::GetInstance()->GetEnableData(IME_KEY, enableVec, EnableImeDataParseTest::USER_ID);
90     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
91     EXPECT_EQ(enableVec.size(), USER_100_TOTAL_COUNT);
92     if (enableVec.size() == USER_100_TOTAL_COUNT) {
93         EXPECT_EQ(enableVec[0], "xiaoyiIme");
94         EXPECT_EQ(enableVec[1], "baiduIme");
95         EXPECT_EQ(enableVec[2], "sougouIme");
96     }
97 }
98 
99 /**
100  * @tc.name: testGetEnableData_002
101  * @tc.desc: Get 101 user enable ime
102  * @tc.type: FUNC
103  * @tc.require:
104  * @tc.author: mashaoyin
105  */
106 HWTEST_F(EnableImeDataParseTest, testGetEnableData_002, TestSize.Level0)
107 {
108     IMSA_HILOGI("EnableImeDataParseTest testGetEnableData_002 START");
109     std::vector<std::string> enableVec;
110     int32_t ret = EnableImeDataParser::GetInstance()->GetEnableData(IME_KEY, enableVec, 101);
111     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
112     EXPECT_EQ(enableVec.size(), USER_101_TOTAL_COUNT);
113     if (enableVec.size() == USER_101_TOTAL_COUNT) {
114         EXPECT_EQ(enableVec[0], "sougouIme");
115     }
116 }
117 
118 /**
119  * @tc.name: testGetEnableData_003
120  * @tc.desc: Get 100 user enable ime while enable list is empty.
121  * @tc.type: FUNC
122  * @tc.require:
123  * @tc.author: mashaoyin
124  */
125 HWTEST_F(EnableImeDataParseTest, testGetEnableData_003, TestSize.Level0)
126 {
127     IMSA_HILOGI("EnableImeDataParseTest testGetEnableData_003 START");
128     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : []}}";
129     std::vector<std::string> enableVec;
130     int32_t ret =
131         EnableImeDataParser::GetInstance()->GetEnableData(IME_KEY, enableVec, EnableImeDataParseTest::USER_ID);
132     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
133     EXPECT_TRUE(enableVec.empty());
134 }
135 
136 /**
137  * @tc.name: testCheckNeedSwitch_001
138  * @tc.desc: Check need switch for enable list change, current ime is default
139  * @tc.type: FUNC
140  * @tc.require:
141  * @tc.author: mashaoyin
142  */
143 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_001, TestSize.Level0)
144 {
145     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_001 START");
146     SwitchInfo switchInfo;
147     EnableImeDataParser::GetInstance()->enableList_.clear();
148     bool ret =
149         EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, EnableImeDataParseTest::USER_ID);
150     EXPECT_FALSE(ret);
151 }
152 
153 /**
154  * @tc.name: testCheckNeedSwitch_002
155  * @tc.desc: Check need switch for enable list change
156  * @tc.type: FUNC
157  * @tc.require:
158  * @tc.author: mashaoyin
159  */
160 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_002, TestSize.Level0)
161 {
162     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_002 START");
163     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
164     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
165     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [\"baiduIme\", "
166                                                     "\"sougouIme\"],\"101\" : [\"sougouIme\"]}}";
167     SwitchInfo switchInfo;
168     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("xiaoyiIm"
169                                                                        "e");
170     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
171     EXPECT_TRUE(ret);
172     EXPECT_EQ(switchInfo.bundleName, EnableImeDataParser::GetInstance()->defaultImeInfo_->name);
173 }
174 
175 /**
176  * @tc.name: testCheckNeedSwitch_003
177  * @tc.desc: Check need switch for enable list change
178  * @tc.type: FUNC
179  * @tc.require:
180  * @tc.author: mashaoyin
181  */
182 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_003, TestSize.Level0)
183 {
184     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_003 START");
185     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
186     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
187     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [ \"xiaoyiIme\", \"baiduIme\", "
188                                                     "\"sougouIme\"],\"101\" : "
189                                                     "[\"sougouIme\"]}}";
190     SwitchInfo switchInfo;
191     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
192     EXPECT_FALSE(ret);
193 }
194 
195 /**
196  * @tc.name: testCheckNeedSwitch_004
197  * @tc.desc: Check need switch for enable list change
198  * @tc.type: FUNC
199  * @tc.require:
200  * @tc.author: mashaoyin
201  */
202 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_004, TestSize.Level0)
203 {
204     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_004 START");
205     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
206     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
207     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [\"baiduIme\", "
208                                                     "\"sougouIme\"],\"101\" : [\"sougouIme\"]}}";
209     SwitchInfo switchInfo;
210     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("xiaoyiIme");
211     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("baiduIme");
212     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
213     EXPECT_TRUE(ret);
214     EXPECT_EQ(switchInfo.bundleName, "baiduIme");
215 }
216 
217 /**
218  * @tc.name: testCheckNeedSwitch_005
219  * @tc.desc: Check need switch for enable list change
220  * @tc.type: FUNC
221  * @tc.require:
222  * @tc.author: mashaoyin
223  */
224 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_005, TestSize.Level0)
225 {
226     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_005 START");
227     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
228     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
229     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [ \"sougouIme\"],\"101\" : "
230                                                     "[\"sougouIme\"]}}";
231     SwitchInfo switchInfo;
232     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("xiaoyiIme");
233     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("baiduIme");
234     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("sougouIme");
235     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
236     EXPECT_TRUE(ret);
237     EXPECT_EQ(switchInfo.bundleName, "sougouIme");
238 }
239 
240 /**
241  * @tc.name: testCheckNeedSwitch_006
242  * @tc.desc: Check need switch for enable list change
243  * @tc.type: FUNC
244  * @tc.require:
245  * @tc.author: mashaoyin
246  */
247 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_006, TestSize.Level0)
248 {
249     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_006 START");
250     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
251     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
252     SwitchInfo switchInfo;
253     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(
254         "settings.inputmethod.enable_keyboard", switchInfo, USER_ID);
255     EXPECT_FALSE(ret);
256 }
257 
258 /**
259  * @tc.name: testCheckNeedSwitch_007
260  * @tc.desc: Check need switch for enable list change
261  * @tc.type: FUNC
262  * @tc.require:
263  * @tc.author: mashaoyin
264  */
265 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_007, TestSize.Level0)
266 {
267     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_007 START");
268     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "defaultImeName";
269     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "defaultImeId";
270     SwitchInfo switchInfo;
271     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(
272         "settings.inputmethod.enable_keyboard", switchInfo, USER_ID);
273     EXPECT_FALSE(ret);
274 }
275 
276 /**
277  * @tc.name: testCheckNeedSwitch_008
278  * @tc.desc: Check need switch for switch target ime
279  * @tc.type: FUNC
280  * @tc.require:
281  * @tc.author: mashaoyin
282  */
283 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_008, TestSize.Level0)
284 {
285     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_008 START");
286     SwitchInfo switchInfo;
287     switchInfo.bundleName = "defaultImeName";
288     switchInfo.subName = "defaultImeId";
289     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(switchInfo, USER_ID);
290     EXPECT_TRUE(ret);
291 }
292 
293 /**
294  * @tc.name: testCheckNeedSwitch_009
295  * @tc.desc: Check need switch for switch target ime
296  * @tc.type: FUNC
297  * @tc.require:
298  * @tc.author: mashaoyin
299  */
300 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_009, TestSize.Level0)
301 {
302     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_009 START");
303     SwitchInfo switchInfo;
304     switchInfo.bundleName = "xiaoyiIme";
305     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(switchInfo, USER_ID);
306     EXPECT_TRUE(ret);
307 }
308 
309 /**
310  * @tc.name: testCheckNeedSwitch_010
311  * @tc.desc: Check need switch for switch target ime
312  * @tc.type: FUNC
313  * @tc.require:
314  * @tc.author: mashaoyin
315  */
316 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_010, TestSize.Level0)
317 {
318     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_010 START");
319     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [ \"sougouIme\"], \"101\" : "
320                                                     "[\"sougouIme\"]}}";
321     SwitchInfo switchInfo;
322     switchInfo.bundleName = "xiaoyiIme";
323     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(switchInfo, USER_ID);
324     EXPECT_FALSE(ret);
325 }
326 
327 /**
328  * @tc.name: testCheckNeedSwitch_011
329  * @tc.desc: Check need switch for enable list change
330  * @tc.type: FUNC
331  * @tc.require:
332  * @tc.author: mashaoyin
333  */
334 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_011, TestSize.Level0)
335 {
336     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_011 START");
337     EnableImeDataParseTest::resultSet_->strValue_ = "";
338     SwitchInfo switchInfo;
339     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
340     EXPECT_FALSE(ret);
341     EXPECT_EQ(switchInfo.bundleName, EnableImeDataParser::GetInstance()->defaultImeInfo_->name);
342 }
343 
344 /**
345  * @tc.name: testCheckNeedSwitch_012
346  * @tc.desc: Check need switch for enable list change
347  * @tc.type: FUNC
348  * @tc.require:
349  * @tc.author: mashaoyin
350  */
351 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_012, TestSize.Level0)
352 {
353     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_012 START");
354     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
355     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
356     EnableImeDataParseTest::resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : []}}";
357     SwitchInfo switchInfo;
358     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("xiaoyiIme");
359     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("baiduIme");
360     EnableImeDataParser::GetInstance()->enableList_[IME_KEY].push_back("sougouIme");
361     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
362     EXPECT_TRUE(ret);
363     EXPECT_EQ(switchInfo.bundleName, EnableImeDataParser::GetInstance()->defaultImeInfo_->name);
364 }
365 
366 /**
367  * @tc.name: testCheckNeedSwitch_013
368  * @tc.desc: Check need switch for enable list change
369  * @tc.type: FUNC
370  * @tc.require:
371  * @tc.author: mashaoyin
372  */
373 HWTEST_F(EnableImeDataParseTest, testCheckNeedSwitch_013, TestSize.Level0)
374 {
375     IMSA_HILOGI("EnableImeDataParseTest testCheckNeedSwitch_013 START");
376     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->name = "xiaoyiIme";
377     ImeInfoInquirer::GetInstance().GetCurrentInputMethod(USER_ID)->id = "xiaoyiImeId";
378     SwitchInfo switchInfo;
379     bool ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
380     EXPECT_FALSE(ret);
381 
382     EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size(), USER_100_TOTAL_COUNT);
383     if (EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size() == USER_100_TOTAL_COUNT) {
384         EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY][0], "xiaoyiIme");
385         EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY][1], "baiduIme");
386         EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY][2], "sougouIme");
387     }
388     resultSet_->strValue_ = "{\"enableImeList\" : {\"100\" : [ \"xiaoyiIme\"], \"101\" : [\"sougouIme\"]}}";
389 
390     ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
391 
392     EXPECT_FALSE(ret);
393     EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size(), USER_101_TOTAL_COUNT);
394     if (EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size() == USER_101_TOTAL_COUNT) {
395         EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY][0], "xiaoyiIme");
396     }
397 
398     ImeInfoInquirer::currentIme_ = nullptr;
399     EXPECT_NE(ImeInfoInquirer::defaultImeProperty_, nullptr);
400     ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
401     EXPECT_TRUE(ret);
402     EXPECT_EQ(switchInfo.bundleName, ImeInfoInquirer::GetInstance().GetDefaultImeCfgProp()->name);
403 
404     ImeInfoInquirer::currentIme_ = std::make_shared<Property>();
405     ImeInfoInquirer::defaultImeProperty_ = nullptr;
406     ret = EnableImeDataParser::GetInstance()->CheckNeedSwitch(IME_KEY, switchInfo, USER_ID);
407     EXPECT_TRUE(ret);
408 }
409 
410 /**
411  * @tc.name: testOnUserChanged_001
412  * @tc.desc: Test local enable list cache change when user changed.
413  * @tc.type: FUNC
414  * @tc.require:
415  * @tc.author: mashaoyin
416  */
417 HWTEST_F(EnableImeDataParseTest, testOnUserChanged_001, TestSize.Level0)
418 {
419     IMSA_HILOGI("EnableImeDataParseTest testOnUserChanged_001 START");
420     int32_t ret = EnableImeDataParser::GetInstance()->GetEnableData(
421         IME_KEY, EnableImeDataParser::GetInstance()->enableList_[IME_KEY], USER_ID);
422     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
423     EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size(), USER_100_TOTAL_COUNT);
424     // 101 means new user id
425     EnableImeDataParser::GetInstance()->OnUserChanged(101);
426     EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size(), USER_101_TOTAL_COUNT);
427     if (EnableImeDataParser::GetInstance()->enableList_[IME_KEY].size() == USER_101_TOTAL_COUNT) {
428         EXPECT_EQ(EnableImeDataParser::GetInstance()->enableList_[IME_KEY][0], "sougouIme");
429     }
430 }
431 } // namespace MiscServices
432 } // namespace OHOS
433