1 /*
2 * Copyright (C) 2025 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 "ime_enabled_info_manager.h"
19
20 #include "enable_upgrade_manager.h"
21 #include "settings_data_utils.h"
22 #undef private
23
24 #include <gtest/gtest.h>
25
26 #include <algorithm>
27 #include <condition_variable>
28 #include <map>
29
30 #include "file_operator.h"
31 #include "ime_info_inquirer.h"
32 #include "parameter.h"
33 #include "tdd_util.h"
34
35 using namespace testing::ext;
36 using namespace OHOS::DataShare;
37 namespace OHOS {
38 namespace MiscServices {
39 struct ImeFixedInfo {
40 std::string bundleName;
41 std::string extensionName;
42 };
43
44 struct ImeEasyInfo {
45 std::string imeKey;
46 EnabledStatus status{ EnabledStatus::DISABLED };
47 bool isDefaultIme{ false };
48 bool isDefaultImeSet{ false };
49 bool isTmpIme{ false };
50 std::string currentSubName;
51 };
52
53 struct UserImeConfigTest : public Serializable {
54 std::map<std::string, std::vector<std::string>> cfgs;
MarshalOHOS::MiscServices::UserImeConfigTest55 bool Marshal(cJSON *node) const override
56 {
57 bool ret = true;
58 for (const auto &cfg : cfgs) {
59 ret = SetValue(node, cfg.first, cfg.second) && ret;
60 }
61 return ret;
62 }
63 };
64
65 struct EnabledImeCfgTest : public Serializable {
66 UserImeConfigTest userImeCfg;
MarshalOHOS::MiscServices::EnabledImeCfgTest67 bool Marshal(cJSON *node) const override
68 {
69 return SetValue(node, GET_NAME(enableImeList), userImeCfg);
70 }
71 };
72
73 struct SecurityModeCfgTest : public Serializable {
74 UserImeConfigTest userImeCfg;
MarshalOHOS::MiscServices::SecurityModeCfgTest75 bool Marshal(cJSON *node) const override
76 {
77 return SetValue(node, GET_NAME(fullExperienceList), userImeCfg);
78 }
79 };
80 class ImeEnabledInfoManagerTest : public testing::Test {
81 public:
82 static constexpr const char *ENABLE_IME = "settings.inputmethod.enable_ime";
83 static constexpr const char *SECURITY_MODE = "settings.inputmethod.full_experience";
84 static constexpr const char *SYS_IME_KEY = "default_ime_key";
85 static constexpr const char *SYS_IME_CUR_SUBNAME = "sysSubName";
86 static constexpr const char *IME_KEY1 = "key1";
87 static constexpr const char *IME_KEY2 = "key2";
88 static constexpr const char *IME_KEY3 = "key3";
89 static constexpr const char *BUNDLE_NAME1 = "bundleName1";
90 static constexpr const char *BUNDLE_NAME2 = "bundleName2";
91 static constexpr const char *BUNDLE_NAME3 = "com.example.newTestIme";
92 static constexpr const char *EXT_NAME1 = "extName1";
93 static constexpr const char *EXT_NAME2 = "extName2";
94 static constexpr const char *EXT_NAME3 = "InputMethodExtAbility";
95 static constexpr const char *CUR_SUBNAME1 = "subName1";
96 static constexpr const char *CUR_SUBNAME2 = "subName2";
97 static constexpr int32_t USER_ID1 = 1;
98 static constexpr int32_t WAIT_DATA_SHARE_CB_TIMEOUT = 300;
99 static constexpr const char *IME_CFG_FILE_PATH = "/data/service/el1/public/imf/ime_cfg.json";
100 static ImeNativeCfg sysImeProp_;
101 static int32_t currentUserId_;
102 static std::map<int32_t, ImeEnabledCfg> enabledCfg_;
103 static void SetUpTestCase();
104 static void TearDownTestCase();
105 static void DataShareCallback();
106 void SetUp();
107 void TearDown();
108 static bool WaitDataShareCallback(const std::map<int32_t, ImeEnabledCfg> &enabledCfg);
109 static std::map<int32_t, std::vector<FullImeInfo>> GenerateFullImeInfos(
110 const std::map<int32_t, std::vector<std::string>> &easyInfos);
111 static std::vector<FullImeInfo> GenerateFullImeInfos(const std::vector<std::string> &imeKeys);
112 static FullImeInfo GenerateFullImeInfo(const std::string &imeKey);
113 static std::map<int32_t, ImeEnabledCfg> GenerateAllEnabledCfg(
114 const std::map<int32_t, std::vector<ImeEasyInfo>> &easyEnabledInfos);
115 static ImeEnabledCfg GenerateAllEnabledCfg(const std::vector<ImeEasyInfo> &easyEnabledInfos);
116 static std::string GetImePersistCfg();
117 static void ModImePersistCfg(const std::string &content);
118 static bool IsAllSwitchOn();
119 static bool IsNoSwitchOn();
120 static void ModImePersistCfg(const ImePersistCfg &cfg);
121 static void SetGlobalEnableTable(int32_t userId, const std::vector<std::string> &bundleNames);
122 static void SetUserEnableTable(int32_t userId, const std::vector<std::string> &bundleNames);
123 static void SetNewUserEnableTable(int32_t userId, const std::vector<ImeEasyInfo> &easyEnabledInfos);
124 static void SetGlobalFullExperienceTable(int32_t userId, const std::vector<std::string> &bundleNames);
125
126 private:
127 static std::string originalGlobalEnableImeStr_;
128 static std::string originalGlobalFullExperienceStr_;
129 static std::string currentUserEnableImeStr_;
130 static std::mutex dataShareCbCvMutex_;
131 static std::condition_variable dataShareCbCv_;
132 static std::string originalImePersistCfgStr_;
133 static std::map<std::string, ImeFixedInfo> imeBasicInfoMapping_;
134 };
135
SetUpTestCase()136 void ImeEnabledInfoManagerTest::SetUpTestCase()
137 {
138 TddUtil::GrantNativePermission();
139 ImeInfoInquirer::GetInstance().InitSystemConfig();
140 IMSA_HILOGI("sys cfg:[%{public}d,%{public}d,%{public}d].",
141 ImeInfoInquirer::GetInstance().GetSystemConfig().enableInputMethodFeature,
142 ImeInfoInquirer::GetInstance().GetSystemConfig().enableFullExperienceFeature,
143 ImeInfoInquirer::GetInstance().GetSystemConfig().initEnabledState);
144 currentUserId_ = TddUtil::GetCurrentUserId();
145 std::string uriProxy = SETTINGS_USER_DATA_URI + std::to_string(currentUserId_) + "?Proxy=true";
146 auto ret = SettingsDataUtils::GetInstance().CreateAndRegisterObserver(
147 uriProxy, ENABLE_IME, []() { DataShareCallback(); });
148 IMSA_HILOGI("CreateAndRegisterObserver ret:%{public}d.", ret);
149
150 originalGlobalFullExperienceStr_ = TddUtil::GetGlobalTable(SECURITY_MODE);
151 IMSA_HILOGI("originalGlobalFullExperienceStr_:%{public}s.", originalGlobalFullExperienceStr_.c_str());
152 originalGlobalEnableImeStr_ = TddUtil::GetGlobalTable(ENABLE_IME);
153 IMSA_HILOGI("originalGlobalEnableImeStr_:%{public}s.", originalGlobalEnableImeStr_.c_str());
154 currentUserEnableImeStr_ = TddUtil::GetUserTable(currentUserId_, ENABLE_IME);
155 IMSA_HILOGI("currentUserEnableImeStr_:%{public}s.", currentUserEnableImeStr_.c_str());
156 originalImePersistCfgStr_ = GetImePersistCfg();
157
158 SettingsDataUtils::GetInstance().isDataShareReady_ = true;
159 sysImeProp_ = ImeInfoInquirer::GetInstance().GetDefaultIme();
160 imeBasicInfoMapping_ = {
161 { IME_KEY1, { BUNDLE_NAME1, EXT_NAME1 } },
162 { IME_KEY2, { BUNDLE_NAME2, EXT_NAME2 } },
163 { IME_KEY3, { BUNDLE_NAME3, EXT_NAME3 } },
164 { SYS_IME_KEY,
165 {
166 sysImeProp_.bundleName,
167 sysImeProp_.extName,
168 } },
169 };
170 }
171
TearDownTestCase()172 void ImeEnabledInfoManagerTest::TearDownTestCase()
173 {
174 if (!originalGlobalFullExperienceStr_.empty()) {
175 TddUtil::SetGlobalTable(SECURITY_MODE, originalGlobalFullExperienceStr_);
176 }
177 if (!originalGlobalEnableImeStr_.empty()) {
178 TddUtil::SetGlobalTable(ENABLE_IME, originalGlobalEnableImeStr_);
179 }
180 if (!currentUserEnableImeStr_.empty()) {
181 TddUtil::SetUserTable(currentUserId_, ENABLE_IME, currentUserEnableImeStr_);
182 }
183 if (!originalImePersistCfgStr_.empty()) {
184 ModImePersistCfg(originalImePersistCfgStr_);
185 }
186 }
187
SetUp()188 void ImeEnabledInfoManagerTest::SetUp()
189 {
190 TddUtil::DeleteGlobalTable(ENABLE_IME);
191 TddUtil::DeleteGlobalTable(SECURITY_MODE);
192 TddUtil::DeleteUserTable(currentUserId_, ENABLE_IME);
193 ModImePersistCfg("");
194 enabledCfg_.clear();
195 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
196 EnableUpgradeManager::GetInstance().upgradedUserId_.clear();
197 }
198
TearDown()199 void ImeEnabledInfoManagerTest::TearDown()
200 {
201 TddUtil::DeleteGlobalTable(ENABLE_IME);
202 TddUtil::DeleteGlobalTable(SECURITY_MODE);
203 TddUtil::DeleteUserTable(currentUserId_, ENABLE_IME);
204 ModImePersistCfg("");
205 enabledCfg_.clear();
206 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
207 EnableUpgradeManager::GetInstance().upgradedUserId_.clear();
208 }
209
DataShareCallback()210 void ImeEnabledInfoManagerTest::DataShareCallback()
211 {
212 IMSA_HILOGI("start.");
213 std::unique_lock<std::mutex> lock(dataShareCbCvMutex_);
214 std::string content;
215 ImeEnabledCfg enabledCfg;
216 content = TddUtil::GetUserTable(currentUserId_, ENABLE_IME);
217 if (!enabledCfg.Unmarshall(content)) {
218 IMSA_HILOGE("%{public}d Unmarshall failed.", currentUserId_);
219 } else {
220 enabledCfg_.insert_or_assign(currentUserId_, enabledCfg);
221 }
222 IMSA_HILOGI("notify.");
223 dataShareCbCv_.notify_one();
224 }
225
WaitDataShareCallback(const std::map<int32_t,ImeEnabledCfg> & enabledCfg)226 bool ImeEnabledInfoManagerTest::WaitDataShareCallback(const std::map<int32_t, ImeEnabledCfg> &enabledCfg)
227 {
228 std::unique_lock<std::mutex> lock(dataShareCbCvMutex_);
229 dataShareCbCv_.wait_for(lock, std::chrono::milliseconds(WAIT_DATA_SHARE_CB_TIMEOUT), [&enabledCfg]() {
230 return enabledCfg == enabledCfg_ && enabledCfg_ == ImeEnabledInfoManager::GetInstance().imeEnabledCfg_;
231 });
232 for (const auto &cfg : enabledCfg) {
233 IMSA_HILOGI("enabledCfg base info:[%{public}d, %{public}s].", cfg.first, cfg.second.version.c_str());
234 for (const auto &info : cfg.second.enabledInfos) {
235 IMSA_HILOGI("enabledCfg info:[%{public}s,%{public}s,%{public}d].", info.bundleName.c_str(),
236 info.extensionName.c_str(), info.enabledStatus);
237 }
238 }
239 for (const auto &cfg : enabledCfg_) {
240 IMSA_HILOGI("enabledCfg_ base info:[%{public}d, %{public}s].", cfg.first, cfg.second.version.c_str());
241 for (const auto &info : cfg.second.enabledInfos) {
242 IMSA_HILOGI("enabledCfg_ info:[%{public}s,%{public}s,%{public}d].", info.bundleName.c_str(),
243 info.extensionName.c_str(), info.enabledStatus);
244 }
245 }
246 for (const auto &cfg : ImeEnabledInfoManager::GetInstance().imeEnabledCfg_) {
247 IMSA_HILOGI("cache base info:[%{public}d, %{public}s].", cfg.first, cfg.second.version.c_str());
248 for (const auto &info : cfg.second.enabledInfos) {
249 IMSA_HILOGI("cache info:[%{public}s,%{public}s,%{public}d].", info.bundleName.c_str(),
250 info.extensionName.c_str(), info.enabledStatus);
251 }
252 }
253 if (enabledCfg != enabledCfg_) {
254 IMSA_HILOGI("enabledCfg not same enabledCfg_.");
255 }
256 if (ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ != enabledCfg) {
257 IMSA_HILOGI("enabledCfg not same ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.");
258 }
259 return enabledCfg == enabledCfg_ && enabledCfg_ == ImeEnabledInfoManager::GetInstance().imeEnabledCfg_;
260 }
261
GenerateFullImeInfos(const std::map<int32_t,std::vector<std::string>> & easyInfos)262 std::map<int32_t, std::vector<FullImeInfo>> ImeEnabledInfoManagerTest::GenerateFullImeInfos(
263 const std::map<int32_t, std::vector<std::string>> &easyInfos)
264 {
265 std::map<int32_t, std::vector<FullImeInfo>> fullImeInfos;
266 for (const auto &easyInfo : easyInfos) {
267 auto imeInfos = GenerateFullImeInfos(easyInfo.second);
268 fullImeInfos.insert({ easyInfo.first, imeInfos });
269 }
270 return fullImeInfos;
271 }
272
GenerateFullImeInfos(const std::vector<std::string> & imeKeys)273 std::vector<FullImeInfo> ImeEnabledInfoManagerTest::GenerateFullImeInfos(const std::vector<std::string> &imeKeys)
274 {
275 std::vector<FullImeInfo> imeInfos;
276 for (const auto &key : imeKeys) {
277 auto imeInfo = GenerateFullImeInfo(key);
278 imeInfos.push_back(imeInfo);
279 }
280 return imeInfos;
281 }
282
GenerateFullImeInfo(const std::string & imeKey)283 FullImeInfo ImeEnabledInfoManagerTest::GenerateFullImeInfo(const std::string &imeKey)
284 {
285 FullImeInfo imeInfo;
286 auto it = imeBasicInfoMapping_.find(imeKey);
287 if (it != imeBasicInfoMapping_.end()) {
288 imeInfo.prop.name = it->second.bundleName;
289 imeInfo.prop.id = it->second.extensionName;
290 }
291 return imeInfo;
292 }
293
GenerateAllEnabledCfg(const std::map<int32_t,std::vector<ImeEasyInfo>> & easyEnabledInfos)294 std::map<int32_t, ImeEnabledCfg> ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(
295 const std::map<int32_t, std::vector<ImeEasyInfo>> &easyEnabledInfos)
296 {
297 std::map<int32_t, ImeEnabledCfg> allEnabledCfg;
298 for (const auto &easyInfo : easyEnabledInfos) {
299 auto enabledCfg = GenerateAllEnabledCfg(easyInfo.second);
300 allEnabledCfg.insert({ easyInfo.first, enabledCfg });
301 }
302 return allEnabledCfg;
303 }
304
GenerateAllEnabledCfg(const std::vector<ImeEasyInfo> & easyEnabledInfos)305 ImeEnabledCfg ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(const std::vector<ImeEasyInfo> &easyEnabledInfos)
306 {
307 ImeEnabledCfg enabledCfg;
308 enabledCfg.version = GetDisplayVersion();
309 std::vector<ImeEnabledInfo> imeEnabledInfos;
310 for (const auto &info : easyEnabledInfos) {
311 ImeEnabledInfo imeEnabledInfo;
312 std::string key = info.imeKey;
313 bool hasExtName = true;
314 auto pos = info.imeKey.find('/');
315 if (pos != std::string::npos && pos + 1 < info.imeKey.size()) {
316 key = info.imeKey.substr(0, pos);
317 hasExtName = false;
318 }
319 auto it = imeBasicInfoMapping_.find(key);
320 if (it != imeBasicInfoMapping_.end()) {
321 imeEnabledInfo.bundleName = it->second.bundleName;
322 if (hasExtName) {
323 imeEnabledInfo.extensionName = it->second.extensionName;
324 }
325 }
326 imeEnabledInfo.enabledStatus = info.status;
327 imeEnabledInfo.extraInfo.isDefaultIme = info.isDefaultIme;
328 imeEnabledInfo.extraInfo.isDefaultImeSet = info.isDefaultImeSet;
329 imeEnabledInfo.extraInfo.isTmpIme = info.isTmpIme;
330 imeEnabledInfo.extraInfo.currentSubName = info.currentSubName;
331 imeEnabledInfos.push_back(imeEnabledInfo);
332 }
333 enabledCfg.enabledInfos = imeEnabledInfos;
334 return enabledCfg;
335 }
336
ModImePersistCfg(const std::string & content)337 void ImeEnabledInfoManagerTest::ModImePersistCfg(const std::string &content)
338 {
339 if (!FileOperator::Write(IME_CFG_FILE_PATH, content, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC)) {
340 IMSA_HILOGE("failed to WriteJsonFile!");
341 }
342 }
343
GetImePersistCfg()344 std::string ImeEnabledInfoManagerTest::GetImePersistCfg()
345 {
346 std::string cfg;
347 bool ret = FileOperator::Read(IME_CFG_FILE_PATH, cfg);
348 if (!ret) {
349 IMSA_HILOGE("failed to ReadJsonFile!");
350 }
351 return cfg;
352 }
353
IsAllSwitchOn()354 bool ImeEnabledInfoManagerTest::IsAllSwitchOn()
355 {
356 return ImeInfoInquirer::GetInstance().GetSystemConfig().enableInputMethodFeature
357 && ImeInfoInquirer::GetInstance().GetSystemConfig().enableFullExperienceFeature;
358 }
IsNoSwitchOn()359 bool ImeEnabledInfoManagerTest::IsNoSwitchOn()
360 {
361 return !ImeInfoInquirer::GetInstance().GetSystemConfig().enableInputMethodFeature
362 && !ImeInfoInquirer::GetInstance().GetSystemConfig().enableFullExperienceFeature;
363 }
364
SetGlobalEnableTable(int32_t userId,const std::vector<std::string> & bundleNames)365 void ImeEnabledInfoManagerTest::SetGlobalEnableTable(int32_t userId, const std::vector<std::string> &bundleNames)
366 {
367 EnabledImeCfgTest enableCfg;
368 enableCfg.userImeCfg.cfgs.insert({ std::to_string(userId), bundleNames });
369 std::string enabledStr;
370 enableCfg.Marshall(enabledStr);
371 TddUtil::SetGlobalTable(ImeEnabledInfoManagerTest::ENABLE_IME, enabledStr);
372 }
373
SetUserEnableTable(int32_t userId,const std::vector<std::string> & bundleNames)374 void ImeEnabledInfoManagerTest::SetUserEnableTable(int32_t userId, const std::vector<std::string> &bundleNames)
375 {
376 EnabledImeCfgTest enableCfg;
377 enableCfg.userImeCfg.cfgs.insert({ std::to_string(userId), bundleNames });
378 std::string userEnabledStr;
379 enableCfg.Marshall(userEnabledStr);
380 TddUtil::SetUserTable(userId, ImeEnabledInfoManagerTest::ENABLE_IME, userEnabledStr);
381 }
382
SetNewUserEnableTable(int32_t userId,const std::vector<ImeEasyInfo> & easyEnabledInfos)383 void ImeEnabledInfoManagerTest::SetNewUserEnableTable(int32_t userId, const std::vector<ImeEasyInfo> &easyEnabledInfos)
384 {
385 auto enabledCfg = ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
386 std::string userEnabledStr;
387 enabledCfg.Marshall(userEnabledStr);
388 TddUtil::SetUserTable(userId, ImeEnabledInfoManagerTest::ENABLE_IME, userEnabledStr);
389 }
390
SetGlobalFullExperienceTable(int32_t userId,const std::vector<std::string> & bundleNames)391 void ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(
392 int32_t userId, const std::vector<std::string> &bundleNames)
393 {
394 SecurityModeCfgTest secModeCfg;
395 secModeCfg.userImeCfg.cfgs.insert({ std::to_string(userId), bundleNames });
396 std::string fullExperienceStr;
397 secModeCfg.Marshall(fullExperienceStr);
398 TddUtil::SetGlobalTable(ImeEnabledInfoManagerTest::SECURITY_MODE, fullExperienceStr);
399 }
400
ModImePersistCfg(const ImePersistCfg & cfg)401 void ImeEnabledInfoManagerTest::ModImePersistCfg(const ImePersistCfg &cfg)
402 {
403 std::string content;
404 cfg.Marshall(content);
405 ModImePersistCfg(content);
406 }
407
408 std::string ImeEnabledInfoManagerTest::originalGlobalEnableImeStr_;
409 std::string ImeEnabledInfoManagerTest::originalGlobalFullExperienceStr_;
410 std::string ImeEnabledInfoManagerTest::currentUserEnableImeStr_;
411 std::map<int32_t, ImeEnabledCfg> ImeEnabledInfoManagerTest::enabledCfg_;
412 std::mutex ImeEnabledInfoManagerTest::dataShareCbCvMutex_;
413 std::condition_variable ImeEnabledInfoManagerTest::dataShareCbCv_;
414 ImeNativeCfg ImeEnabledInfoManagerTest::sysImeProp_;
415 int32_t ImeEnabledInfoManagerTest::currentUserId_;
416 std::string ImeEnabledInfoManagerTest::originalImePersistCfgStr_;
417 std::map<std::string, ImeFixedInfo> ImeEnabledInfoManagerTest::imeBasicInfoMapping_;
418
419 /**
420 * @tc.name: testInit_001
421 * @tc.desc: Init:upgrade with no table
422 * has sys ime
423 * test1:AllSwitchOn--sys ime is BASIC_MODE, sys ime is default ime
424 * test2:NoSwitchOn--sys ime is FULL_EXPERIENCE_MODE, sys ime is default ime
425 * @tc.type: FUNC
426 * @tc.require:
427 * @tc.author: chenyu
428 */
429 HWTEST_F(ImeEnabledInfoManagerTest, testInit_001, TestSize.Level0)
430 {
431 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_001 START");
432 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(
433 { { ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::SYS_IME_KEY } } }));
434 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
435 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
436 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
437 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
438 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true } } });
439 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
440 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
441 }
442 if (ImeEnabledInfoManagerTest::IsNoSwitchOn()) {
443 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
444 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
445 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::FULL_EXPERIENCE_MODE, true } } });
446 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
447 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
448 }
449 }
450
451 /**
452 * @tc.name: testInit_002
453 * @tc.desc: Init:upgrade with no table
454 * has sys ime、BUNDLE_NAME1
455 * BUNDLE_NAME1 is default ime that user set
456 * test1:NoSwitchOn--sys ime is FULL_EXPERIENCE_MODE
457 * test2:NoSwitchOn--BUNDLE_NAME1 is FULL_EXPERIENCE_MODE, default ime can retain
458 * @tc.type: FUNC
459 * @tc.require:
460 * @tc.author: chenyu
461 */
462 HWTEST_F(ImeEnabledInfoManagerTest, testInit_002, TestSize.Level0)
463 {
464 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_002 START");
465 ImePersistCfg cfg;
466 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
467 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1, "", true);
468 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
469
470 auto ret = ImeEnabledInfoManager::GetInstance().Init(
471 ImeEnabledInfoManagerTest::GenerateFullImeInfos({ { ImeEnabledInfoManagerTest::currentUserId_,
472 { ImeEnabledInfoManagerTest::SYS_IME_KEY, ImeEnabledInfoManagerTest::IME_KEY1 } } }));
473 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
474
475 if (ImeEnabledInfoManagerTest::IsNoSwitchOn()) {
476 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
477 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
478 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::FULL_EXPERIENCE_MODE },
479 { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::FULL_EXPERIENCE_MODE, true, true } } });
480 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
481 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
482 }
483 }
484
485 /**
486 * @tc.name: testInit_003
487 * @tc.desc: Init:upgrade with global enable table and full experience table
488 * has sys ime、BUNDLE_NAME1
489 * BUNDLE_NAME1 in full experience table, is default ime that user set
490 * BUNDLE_NAME2 in enable table
491 * test1:BUNDLE_NAME1 in full experience table， not in enable table, status is FULL_EXPERIENCE_MODE
492 * test2:BUNDLE_NAME2 in enable table, but not installed, status is BASIC_MODE
493 * test3:BUNDLE_NAME1 is default ime that user set, can retain
494 * test4:sys ime in no table, default BASIC_MODE
495 * @tc.type: FUNC
496 * @tc.require:
497 * @tc.author: chenyu
498 */
499 HWTEST_F(ImeEnabledInfoManagerTest, testInit_003, TestSize.Level0)
500 {
501 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_003 START");
502 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
503 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
504 ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(
505 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
506 ImePersistCfg cfg;
507 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
508 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1, "", true);
509 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
510
511 std::map<int32_t, std::vector<std::string>> easyInfos;
512 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
513 ImeEnabledInfoManagerTest::SYS_IME_KEY,
514 ImeEnabledInfoManagerTest::IME_KEY1,
515 } });
516 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
517 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
518 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
519 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
520 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
521 { { std::string(ImeEnabledInfoManagerTest::IME_KEY2) + "/" + "noExtName", EnabledStatus::BASIC_MODE },
522 { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::FULL_EXPERIENCE_MODE, true, true },
523 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE } } });
524
525 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
526 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
527 }
528 }
529
530 /**
531 * @tc.name: testInit_004
532 * @tc.desc: Init:upgrade only with global enable table
533 * has sys ime、 BUNDLE_NAME2
534 * BUNDLE_NAME1 in enable table, is default ime
535 * test1:BUNDLE_NAME1 in enable table, is default ime, but not installed, default ime mod to sys ime
536 * test2:BUNDLE_NAME2 in no table, status is DISABLED
537 * @tc.type: FUNC
538 * @tc.require:
539 * @tc.author: chenyu
540 */
541 HWTEST_F(ImeEnabledInfoManagerTest, testInit_004, TestSize.Level0)
542 {
543 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_004 START");
544 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
545 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
546 ImePersistCfg cfg;
547 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
548 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1, "", true);
549 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
550
551 std::map<int32_t, std::vector<std::string>> easyInfos;
552 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
553 ImeEnabledInfoManagerTest::SYS_IME_KEY,
554 ImeEnabledInfoManagerTest::IME_KEY2,
555 } });
556 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
557 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
558 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
559 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
560 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
561 { { std::string(ImeEnabledInfoManagerTest::IME_KEY1) + "/" + "noExtName", EnabledStatus::BASIC_MODE },
562 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
563 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::DISABLED } } });
564 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
565 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
566 }
567 }
568
569 /**
570 * @tc.name: testInit_005
571 * @tc.desc: Init:upgrade with global enable table and full experience table
572 * has sys ime、 BUNDLE_NAME1、BUNDLE_NAME2
573 * BUNDLE_NAME1 in global enable table and full experience table
574 * BUNDLE_NAME2 in no table, is default ime
575 * test1:BUNDLE_NAME1 in global enable table and full experience table, status is FULL_EXPERIENCE_MODE
576 * test2:BUNDLE_NAME2 in no table, status is DISABLED, default ime mod to sys ime
577 * @tc.type: FUNC
578 * @tc.require:
579 * @tc.author: chenyu
580 */
581 HWTEST_F(ImeEnabledInfoManagerTest, testInit_005, TestSize.Level0)
582 {
583 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_005 START");
584 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
585 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
586 ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(
587 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
588 ImePersistCfg cfg;
589 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
590 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME2) + "/" + ImeEnabledInfoManagerTest::EXT_NAME2, "", false);
591 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
592
593 std::map<int32_t, std::vector<std::string>> easyInfos;
594 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
595 ImeEnabledInfoManagerTest::SYS_IME_KEY,
596 ImeEnabledInfoManagerTest::IME_KEY1,
597 ImeEnabledInfoManagerTest::IME_KEY2,
598 } });
599 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
600 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
601 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
602 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
603 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
604 { { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::FULL_EXPERIENCE_MODE },
605 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
606 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::DISABLED } } });
607 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
608 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
609 }
610 }
611
612 /**
613 * @tc.name: testInit_006
614 * @tc.desc: Init:upgrade only with global enable table and full experience table
615 * has sys ime、 BUNDLE_NAME1
616 * BUNDLE_NAME1 in enable table and full experience table, is default ime
617 * enable table parse abnormal
618 * test:BUNDLE_NAME1 status is FULL_EXPERIENCE_MODE, default ime retain
619 * @tc.type: FUNC
620 * @tc.require:
621 * @tc.author: chenyu
622 */
623 HWTEST_F(ImeEnabledInfoManagerTest, testInit_006, TestSize.Level0)
624 {
625 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_006 START");
626 ImeEnabledInfoManagerTest::SetGlobalEnableTable(0, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
627 ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(
628 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
629 ImePersistCfg cfg;
630 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
631 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1,
632 ImeEnabledInfoManagerTest::CUR_SUBNAME1, true);
633 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
634
635 std::map<int32_t, std::vector<std::string>> easyInfos;
636 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
637 ImeEnabledInfoManagerTest::SYS_IME_KEY,
638 ImeEnabledInfoManagerTest::IME_KEY1,
639 } });
640 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
641 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
642 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
643 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
644 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
645 { { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::FULL_EXPERIENCE_MODE, true, true, false,
646 ImeEnabledInfoManagerTest::CUR_SUBNAME1 },
647 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE } } });
648 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
649 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
650 }
651 }
652
653 /**
654 * @tc.name: testInit_007
655 * @tc.desc: Init:upgrade only with global enable table and full experience table
656 * has sys ime、 BUNDLE_NAME1
657 * BUNDLE_NAME1 in enable table and full experience table, is default ime
658 * full experience table parse abnormal
659 * test:BUNDLE_NAME1 status is BASIC_MODE, default ime retain
660 * @tc.type: FUNC
661 * @tc.require:
662 * @tc.author: chenyu
663 */
664 HWTEST_F(ImeEnabledInfoManagerTest, testInit_007, TestSize.Level0)
665 {
666 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_007 START");
667 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
668 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
669 ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(0, { ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
670 ImePersistCfg cfg;
671 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
672 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1,
673 ImeEnabledInfoManagerTest::CUR_SUBNAME1, true);
674 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
675
676 std::map<int32_t, std::vector<std::string>> easyInfos;
677 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
678 ImeEnabledInfoManagerTest::SYS_IME_KEY,
679 ImeEnabledInfoManagerTest::IME_KEY1,
680 } });
681 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
682 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
683 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
684 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
685 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
686 { { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::BASIC_MODE, true, true, false,
687 ImeEnabledInfoManagerTest::CUR_SUBNAME1 },
688 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE } } });
689 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
690 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
691 }
692 }
693
694 /**
695 * @tc.name: testInit_008
696 * @tc.desc: Init:upgrade with global enable table and user enable table
697 * has sys ime、BUNDLE_NAME1 and BUNDLE_NAME2
698 * sys ime in global enable table and in user enable table,is default ime
699 * BUNDLE_NAME1 in global enable table、
700 * BUNDLE_NAME2 in global enable table and in user enable table
701 * test:has user enable table, but global enable table has normal enable info of this user,
702 * It's up to global enable table
703 * @tc.type: FUNC
704 * @tc.require:
705 * @tc.author: chenyu
706 */
707 HWTEST_F(ImeEnabledInfoManagerTest, testInit_008, TestSize.Level0)
708 {
709 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_008 START");
710 ImeEnabledInfoManagerTest::SetGlobalEnableTable(ImeEnabledInfoManagerTest::currentUserId_,
711 { ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME1,
712 ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
713 ImeEnabledInfoManagerTest::SetUserEnableTable(ImeEnabledInfoManagerTest::currentUserId_,
714 { ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
715 ImePersistCfg cfg;
716 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
717 ImeEnabledInfoManagerTest::sysImeProp_.bundleName + "/" + ImeEnabledInfoManagerTest::sysImeProp_.extName,
718 ImeEnabledInfoManagerTest::SYS_IME_CUR_SUBNAME, true);
719 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
720
721 std::map<int32_t, std::vector<std::string>> easyInfos;
722 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
723 ImeEnabledInfoManagerTest::SYS_IME_KEY,
724 ImeEnabledInfoManagerTest::IME_KEY1,
725 ImeEnabledInfoManagerTest::IME_KEY2,
726 } });
727
728 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
729 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
730 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
731 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
732 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
733 { { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::BASIC_MODE },
734 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE },
735 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true, true, false,
736 ImeEnabledInfoManagerTest::SYS_IME_CUR_SUBNAME } } });
737 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
738 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
739 }
740 }
741
742 /**
743 * @tc.name: testInit_009
744 * @tc.desc: Init:upgrade with global enable table and user enable table
745 * has sys ime and BUNDLE_NAME1
746 * sys ime in user enable table
747 * BUNDLE_NAME1 in user enable table, is default ime
748 * test:has user enable table, global enable table not has enable info of this user,
749 * It's up to user enable table
750 * @tc.type: FUNC
751 * @tc.require:
752 * @tc.author: chenyu
753 */
754 HWTEST_F(ImeEnabledInfoManagerTest, testInit_009, TestSize.Level0)
755 {
756 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_009 START");
757 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
758 0, { ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME1,
759 ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
760 ImeEnabledInfoManagerTest::SetUserEnableTable(ImeEnabledInfoManagerTest::currentUserId_,
761 { ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME1 });
762 ImePersistCfg cfg;
763 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
764 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME1) + "/" + ImeEnabledInfoManagerTest::EXT_NAME1, "", false);
765 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
766
767 std::map<int32_t, std::vector<std::string>> easyInfos;
768 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
769 ImeEnabledInfoManagerTest::SYS_IME_KEY,
770 ImeEnabledInfoManagerTest::IME_KEY1,
771 } });
772 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
773 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
774 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
775 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
776 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
777 { { ImeEnabledInfoManagerTest::IME_KEY1, EnabledStatus::BASIC_MODE, true },
778 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE } } });
779 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
780 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
781 }
782 }
783
784 /**
785 * @tc.name: testInit_010
786 * @tc.desc: Init:device reboot with new user enable table
787 * has sys ime、BUNDLE_NAME2
788 * sys ime、BUNDLE_NAME2 in global enable table
789 * sys ime、BUNDLE_NAME2 in new user enable table, all BASIC_MODE, BUNDLE_NAME2 is default ime
790 * BUNDLE_NAME2 in full experience table
791 * test:has new user table, It's up to new user enable table
792 * @tc.type: FUNC
793 * @tc.require:
794 * @tc.author: chenyu
795 */
796 HWTEST_F(ImeEnabledInfoManagerTest, testInit_010, TestSize.Level0)
797 {
798 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_010 START");
799 ImeEnabledInfoManagerTest::SetGlobalEnableTable(ImeEnabledInfoManagerTest::currentUserId_,
800 { ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
801 ImeEnabledInfoManagerTest::SetGlobalFullExperienceTable(
802 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
803 ImePersistCfg cfg;
804 cfg.imePersistInfo.emplace_back(ImeEnabledInfoManagerTest::currentUserId_,
805 ImeEnabledInfoManagerTest::sysImeProp_.bundleName + "/" + ImeEnabledInfoManagerTest::sysImeProp_.extName,
806 ImeEnabledInfoManagerTest::SYS_IME_CUR_SUBNAME, true);
807 ImeEnabledInfoManagerTest::ModImePersistCfg(cfg);
808
809 std::vector<ImeEasyInfo> easyTableInfos = { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
810 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true } };
811 ImeEnabledInfoManagerTest::SetNewUserEnableTable(ImeEnabledInfoManagerTest::currentUserId_, easyTableInfos);
812
813 std::map<int32_t, std::vector<std::string>> easyInfos;
814 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
815 ImeEnabledInfoManagerTest::SYS_IME_KEY,
816 ImeEnabledInfoManagerTest::IME_KEY2,
817 } });
818 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
819 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
820 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
821 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
822 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, easyTableInfos });
823 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
824 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
825 }
826 }
827
828 /**
829 * @tc.name: testInit_011
830 * @tc.desc: Init:imsa restart with new user enable table
831 * has sys ime、BUNDLE_NAME2
832 * BUNDLE_NAME2 install when imsa died
833 * test:bundle install when imsa died can save in imsa restart
834 *
835 * @tc.type: FUNC
836 * @tc.require:
837 * @tc.author: chenyu
838 */
839 HWTEST_F(ImeEnabledInfoManagerTest, testInit_011, TestSize.Level0)
840 {
841 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_011 START");
842 std::vector<ImeEasyInfo> easyTableInfos = { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE,
843 true } };
844 ImeEnabledInfoManagerTest::SetNewUserEnableTable(ImeEnabledInfoManagerTest::currentUserId_, easyTableInfos);
845 std::map<int32_t, std::vector<std::string>> easyInfos;
846 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, {
847 ImeEnabledInfoManagerTest::SYS_IME_KEY,
848 ImeEnabledInfoManagerTest::IME_KEY2,
849 } });
850 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
851 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
852 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
853 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
854 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
855 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
856 { ImeEnabledInfoManagerTest::IME_KEY2,
857 ImeInfoInquirer::GetInstance().GetSystemConfig().initEnabledState } } });
858 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
859 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
860 }
861 if (ImeEnabledInfoManagerTest::IsNoSwitchOn()) {
862 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
863 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
864 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
865 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::FULL_EXPERIENCE_MODE } } });
866 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
867 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
868 }
869 }
870
871 /**
872 * @tc.name: testInit_012
873 * @tc.desc: Init:imsa restart with new user enable table
874 * BUNDLE_NAME2 is default ime , and uninstall when imsa died
875 * test:default ime uninstall when imsa died, default ime will mode to sys ime in imsa restart
876 * @tc.type: FUNC
877 * @tc.require:
878 * @tc.author: chenyu
879 */
880 HWTEST_F(ImeEnabledInfoManagerTest, testInit_012, TestSize.Level0)
881 {
882 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_012 START");
883 std::vector<ImeEasyInfo> easyTableInfos = { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
884 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true } };
885 ImeEnabledInfoManagerTest::SetNewUserEnableTable(ImeEnabledInfoManagerTest::currentUserId_, easyTableInfos);
886 std::map<int32_t, std::vector<std::string>> easyInfos;
887 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::SYS_IME_KEY } });
888 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
889 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
890 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
891 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
892 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
893 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
894 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
895 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
896 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
897 }
898 if (ImeEnabledInfoManagerTest::IsNoSwitchOn()) {
899 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
900 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
901 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
902 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
903 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
904 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
905 }
906 }
907
908 /**
909 * @tc.name: testInit_013
910 * @tc.desc: Init:imsa restart with new user enable table
911 * not has default ime before upgrade
912 * BUNDLE_NAME2 uninstall before upgrade, and install again when imsa died after upgrade
913 * test1:not has default ime, sys ime set to default ime when upgrade
914 * test2:BUNDLE_NAME2 can not obtain extName when upgrade, install again when imsa died,
915 * can obtain extName after imsa restart
916 * @tc.type: FUNC
917 * @tc.require:
918 * @tc.author: chenyu
919 */
920 HWTEST_F(ImeEnabledInfoManagerTest, testInit_013, TestSize.Level0)
921 {
922 IMSA_HILOGI("ImeEnabledInfoManagerTest testInit_013 START");
923 ImeEnabledInfoManagerTest::SetGlobalEnableTable(
924 ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::BUNDLE_NAME2 });
925 std::map<int32_t, std::vector<std::string>> easyInfos;
926 easyInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_, { ImeEnabledInfoManagerTest::SYS_IME_KEY } });
927 auto ret = ImeEnabledInfoManager::GetInstance().Init(ImeEnabledInfoManagerTest::GenerateFullImeInfos(easyInfos));
928 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
929 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
930 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
931 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
932 { { std::string(ImeEnabledInfoManagerTest::IME_KEY2) + "/" + "noExtName", EnabledStatus::BASIC_MODE },
933 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true } } });
934 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
935 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
936 }
937 auto imeInfo = ImeEnabledInfoManagerTest::GenerateFullImeInfo(ImeEnabledInfoManagerTest::IME_KEY2);
938 ret = ImeEnabledInfoManager::GetInstance().Add(ImeEnabledInfoManagerTest::currentUserId_, imeInfo);
939 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
940 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
941 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
942 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
943 { { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE },
944 { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true } } });
945 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
946 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
947 }
948 }
949
950 /**
951 * @tc.name: testUserSwitch_001
952 * @tc.desc: has cache
953 * test:user enable table will not be mod if has cache
954 * @tc.type: FUNC
955 * @tc.require:
956 * @tc.author: chenyu
957 */
958 HWTEST_F(ImeEnabledInfoManagerTest, testUserAdd_001, TestSize.Level0)
959 {
960 IMSA_HILOGI("ImeEnabledInfoManagerTest testUserAdd_001 START");
961 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
962 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
963 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
964 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
965 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
966 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
967
968 std::vector<std::string> imeKeys = {
969 ImeEnabledInfoManagerTest::SYS_IME_KEY,
970 ImeEnabledInfoManagerTest::IME_KEY2,
971 };
972 auto imeInfos = ImeEnabledInfoManagerTest::GenerateFullImeInfos(imeKeys);
973 auto ret = ImeEnabledInfoManager::GetInstance().Switch(ImeEnabledInfoManagerTest::currentUserId_, imeInfos);
974 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
975 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(ImeEnabledInfoManager::GetInstance().imeEnabledCfg_));
976 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
977 }
978
979 /**
980 * @tc.name: testUserDelete_001
981 * @tc.desc: has cache
982 * test:cache will be deleted when user deleted
983 * @tc.type: FUNC
984 * @tc.require:
985 * @tc.author: chenyu
986 */
987 HWTEST_F(ImeEnabledInfoManagerTest, testUserDelete_001, TestSize.Level0)
988 {
989 IMSA_HILOGI("ImeEnabledInfoManagerTest testUserDelete_001 START");
990 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
991 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
992 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
993 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
994 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
995 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
996 EXPECT_FALSE(ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.empty());
997 auto ret = ImeEnabledInfoManager::GetInstance().Delete(ImeEnabledInfoManagerTest::currentUserId_);
998 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
999 EXPECT_TRUE(ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.empty());
1000 }
1001
1002 /**
1003 * @tc.name: testBundleAdd_001
1004 * @tc.desc: BUNDLE_NAME1 is added
1005 * has cache, BUNDLE_NAME1 not in cache
1006 * test1: bundle add first the status is decided by initEnabledState
1007 * @tc.type: FUNC
1008 * @tc.require:
1009 * @tc.author: chenyu
1010 */
1011 HWTEST_F(ImeEnabledInfoManagerTest, testBundleAdd_001, TestSize.Level0)
1012 {
1013 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleAdd_001 START");
1014 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1015 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1016 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true } } });
1017 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1018 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1019 auto imeInfo = ImeEnabledInfoManagerTest::GenerateFullImeInfo(ImeEnabledInfoManagerTest::IME_KEY2);
1020 auto ret = ImeEnabledInfoManager::GetInstance().Add(ImeEnabledInfoManagerTest::currentUserId_, imeInfo);
1021 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1022 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
1023 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1024 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1025 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1026 { ImeEnabledInfoManagerTest::IME_KEY2,
1027 ImeInfoInquirer::GetInstance().GetSystemConfig().initEnabledState } } });
1028 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1029 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1030 }
1031 if (ImeEnabledInfoManagerTest::IsNoSwitchOn()) {
1032 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos2;
1033 easyEnabledInfos2.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1034 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1035 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::FULL_EXPERIENCE_MODE } } });
1036 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1037 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos2)));
1038 }
1039 }
1040
1041 /**
1042 * @tc.name: testBundleAdd_002
1043 * @tc.desc: BUNDLE_NAME2 is added
1044 * has cache, BUNDLE_NAME2 in cache, extensionName not empty
1045 * test1: bundle not first add the status is decided by last
1046 * @tc.type: FUNC
1047 * @tc.require:
1048 * @tc.author: chenyu
1049 */
1050 HWTEST_F(ImeEnabledInfoManagerTest, testBundleAdd_002, TestSize.Level0)
1051 {
1052 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleAdd_002 START");
1053 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1054 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1055 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1056 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::FULL_EXPERIENCE_MODE } } });
1057 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1058 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1059 auto imeInfo = ImeEnabledInfoManagerTest::GenerateFullImeInfo(ImeEnabledInfoManagerTest::IME_KEY2);
1060 auto ret = ImeEnabledInfoManager::GetInstance().Add(ImeEnabledInfoManagerTest::currentUserId_, imeInfo);
1061 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1062 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1063 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
1064 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
1065 }
1066
1067 /**
1068 * @tc.name: testBundleAdd_003
1069 * @tc.desc: BUNDLE_NAME2 is added
1070 * has cache, BUNDLE_NAME2 in cache, extensionName empty
1071 * test1: bundle uninstall before upgrade, install again that the extName can be set
1072 * @tc.type: FUNC
1073 * @tc.require:
1074 * @tc.author: chenyu
1075 */
1076 HWTEST_F(ImeEnabledInfoManagerTest, testBundleAdd_003, TestSize.Level0)
1077 {
1078 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleAdd_003 START");
1079 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1080 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1081 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1082 { std::string(ImeEnabledInfoManagerTest::IME_KEY2) + "/" + "noExtName",
1083 EnabledStatus::FULL_EXPERIENCE_MODE } } });
1084 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1085 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1086 auto imeInfo = ImeEnabledInfoManagerTest::GenerateFullImeInfo(ImeEnabledInfoManagerTest::IME_KEY2);
1087 auto ret = ImeEnabledInfoManager::GetInstance().Add(ImeEnabledInfoManagerTest::currentUserId_, imeInfo);
1088 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1089 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1090 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1091 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1092 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::FULL_EXPERIENCE_MODE } } });
1093 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1094 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1095 }
1096
1097 /**
1098 * @tc.name: testBundleDelete_001
1099 * @tc.desc: current ime is deleted
1100 * test:current ime delete, current ime(default ime) mod to sys ime
1101 * @tc.type: FUNC
1102 * @tc.require:
1103 * @tc.author: chenyu
1104 */
1105 HWTEST_F(ImeEnabledInfoManagerTest, testBundleDelete_001, TestSize.Level0)
1106 {
1107 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleDelete_001 START");
1108 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1109 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1110 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1111 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true } } });
1112 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1113 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1114
1115 auto ret = ImeEnabledInfoManager::GetInstance().Delete(
1116 ImeEnabledInfoManagerTest::currentUserId_, ImeEnabledInfoManagerTest::BUNDLE_NAME2);
1117 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1118 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1119 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1120 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1121 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
1122 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1123 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1124 }
1125
1126 /**
1127 * @tc.name: testBundleDelete_002
1128 * @tc.desc: not current ime delete
1129 * test:not current ime delete, no need deal
1130 * @tc.type: FUNC
1131 * @tc.require:
1132 * @tc.author: chenyu
1133 */
1134 HWTEST_F(ImeEnabledInfoManagerTest, testBundleDelete_002, TestSize.Level0)
1135 {
1136 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleDelete_002 START");
1137 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1138 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1139 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1140 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
1141 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1142 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1143
1144 auto ret = ImeEnabledInfoManager::GetInstance().Delete(
1145 ImeEnabledInfoManagerTest::currentUserId_, ImeEnabledInfoManagerTest::BUNDLE_NAME2);
1146 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1147 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1148 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
1149 }
1150
1151 /**
1152 * @tc.name: testBundleEnabledStatusUpdate_001
1153 * @tc.desc: has cache
1154 * test:user enabled table will be mod when bundle enabledStatus changed
1155 * @tc.type: FUNC
1156 * @tc.require:
1157 * @tc.author: chenyu
1158 */
1159 HWTEST_F(ImeEnabledInfoManagerTest, testBundleEnabledStatusUpdate_001, TestSize.Level0)
1160 {
1161 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleEnabledStatusUpdate_001 START");
1162 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1163 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1164 { { ImeEnabledInfoManagerTest::IME_KEY3, EnabledStatus::BASIC_MODE } } });
1165 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1166 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1167
1168 auto ret = ImeEnabledInfoManager::GetInstance().Update(ImeEnabledInfoManagerTest::currentUserId_,
1169 BUNDLE_NAME3, EXT_NAME3, EnabledStatus::FULL_EXPERIENCE_MODE);
1170 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1171 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
1172 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1173 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1174 { { ImeEnabledInfoManagerTest::IME_KEY3, EnabledStatus::FULL_EXPERIENCE_MODE } } });
1175 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1176 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1177 }
1178 }
1179
1180 /**
1181 * @tc.name: testBundleEnabledStatusUpdate_002
1182 * @tc.desc: test:default ime not allow DISABLED
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 * @tc.author: chenyu
1186 */
1187 HWTEST_F(ImeEnabledInfoManagerTest, testBundleEnabledStatusUpdate_002, TestSize.Level0)
1188 {
1189 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleEnabledStatusUpdate_002 START");
1190 auto ret = ImeEnabledInfoManager::GetInstance().Update(ImeEnabledInfoManagerTest::currentUserId_,
1191 ImeEnabledInfoManagerTest::sysImeProp_.bundleName, ImeEnabledInfoManagerTest::sysImeProp_.extName,
1192 EnabledStatus::DISABLED);
1193 EXPECT_EQ(ret, ErrorCode::ERROR_OPERATE_SYSTEM_IME);
1194 }
1195
1196 /**
1197 * @tc.name: testBundleEnabledStatusUpdate_003
1198 * @tc.desc: test:new status same with old status. no need deal
1199 * @tc.type: FUNC
1200 * @tc.require:
1201 * @tc.author: chenyu
1202 */
1203 HWTEST_F(ImeEnabledInfoManagerTest, testBundleEnabledStatusUpdate_003, TestSize.Level0)
1204 {
1205 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleEnabledStatusUpdate_003 START");
1206 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1207 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1208 { { ImeEnabledInfoManagerTest::IME_KEY3, EnabledStatus::BASIC_MODE } } });
1209 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1210 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1211
1212 auto ret = ImeEnabledInfoManager::GetInstance().Update(ImeEnabledInfoManagerTest::currentUserId_,
1213 BUNDLE_NAME3, EXT_NAME3, EnabledStatus::BASIC_MODE);
1214 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1215 if (ImeEnabledInfoManagerTest::IsAllSwitchOn()) {
1216 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1217 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1218 { { ImeEnabledInfoManagerTest::IME_KEY3, EnabledStatus::BASIC_MODE } } });
1219 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1220 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1221 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
1222 }
1223 }
1224
1225 /**
1226 * @tc.name: testBundleEnabledStatusUpdate_004
1227 * @tc.desc: test:extensionName not find
1228 * @tc.type: FUNC
1229 * @tc.require:
1230 * @tc.author: chenyu
1231 */
1232 HWTEST_F(ImeEnabledInfoManagerTest, testBundleEnabledStatusUpdate_004, TestSize.Level0)
1233 {
1234 IMSA_HILOGI("ImeEnabledInfoManagerTest testBundleEnabledStatusUpdate_003 START");
1235 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1236 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1237 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE } } });
1238 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1239 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1240
1241 auto ret = ImeEnabledInfoManager::GetInstance().Update(ImeEnabledInfoManagerTest::currentUserId_,
1242 ImeEnabledInfoManagerTest::sysImeProp_.bundleName, "error", EnabledStatus::BASIC_MODE);
1243 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_FOUND);
1244 }
1245
1246 /**
1247 * @tc.name: testSetCurrentIme_001
1248 * @tc.desc: test:current ime changed
1249 * @tc.type: FUNC
1250 * @tc.require:
1251 * @tc.author: chenyu
1252 */
1253 HWTEST_F(ImeEnabledInfoManagerTest, testSetCurrentIme_001, TestSize.Level0)
1254 {
1255 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetCurrentIme_001 START");
1256 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1257 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1258 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, true },
1259 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE } } });
1260 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1261 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1262
1263 auto ret = ImeEnabledInfoManager::GetInstance().SetCurrentIme(ImeEnabledInfoManagerTest::currentUserId_,
1264 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME2) + "/" + ImeEnabledInfoManagerTest::EXT_NAME2,
1265 ImeEnabledInfoManagerTest::CUR_SUBNAME2, true);
1266 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1267 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1268 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1269 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1270 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1271 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1272 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1273 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1274 }
1275
1276 /**
1277 * @tc.name: testSetCurrentIme_002
1278 * @tc.desc: test:current ime changed, but has tmp ime, no need to deal
1279 * @tc.type: FUNC
1280 * @tc.require:
1281 * @tc.author: chenyu
1282 */
1283 HWTEST_F(ImeEnabledInfoManagerTest, testSetCurrentIme_002, TestSize.Level0)
1284 {
1285 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetCurrentIme_002 START");
1286 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1287 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1288 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1289 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1290 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1291 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1292 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1293
1294 auto ret = ImeEnabledInfoManager::GetInstance().SetCurrentIme(ImeEnabledInfoManagerTest::currentUserId_,
1295 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME2) + "/" + ImeEnabledInfoManagerTest::EXT_NAME2,
1296 ImeEnabledInfoManagerTest::CUR_SUBNAME1, false);
1297 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1298 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1299 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1300 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1301 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, false, false,
1302 ImeEnabledInfoManagerTest::CUR_SUBNAME1 } } });
1303 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1304 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1305 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
1306 }
1307
1308 /**
1309 * @tc.name: testSetTmpIme_001
1310 * @tc.desc: test:tmp ime changed, but same with original tmp ime, no need deal
1311 * @tc.type: FUNC
1312 * @tc.require:
1313 * @tc.author: chenyu
1314 */
1315 HWTEST_F(ImeEnabledInfoManagerTest, testSetTmpIme_001, TestSize.Level0)
1316 {
1317 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetTmpIme_001 START");
1318 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1319 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1320 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1321 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1322 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1323 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1324 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1325
1326 auto ret = ImeEnabledInfoManager::GetInstance().SetTmpIme(
1327 ImeEnabledInfoManagerTest::currentUserId_, std::string(ImeEnabledInfoManagerTest::sysImeProp_.bundleName) + "/"
1328 + ImeEnabledInfoManagerTest::sysImeProp_.extName);
1329 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1330 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1331 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
1332 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
1333 }
1334
1335 /**
1336 * @tc.name: testSetTmpIme_002
1337 * @tc.desc: test:tmp ime clear, but not has tmp ime, no need to deal
1338 * @tc.type: FUNC
1339 * @tc.require:
1340 * @tc.author: chenyu
1341 */
1342 HWTEST_F(ImeEnabledInfoManagerTest, testSetTmpIme_002, TestSize.Level0)
1343 {
1344 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetTmpIme_002 START");
1345 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1346 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1347 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1348 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1349 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1350 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1351 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1352
1353 auto ret = ImeEnabledInfoManager::GetInstance().SetTmpIme(ImeEnabledInfoManagerTest::currentUserId_, "");
1354 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1355 EXPECT_FALSE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1356 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos)));
1357 EXPECT_TRUE(ImeEnabledInfoManagerTest::enabledCfg_.empty());
1358 }
1359
1360 /**
1361 * @tc.name: testSetTmpIme_003
1362 * @tc.desc: test:tmp ime clear
1363 * @tc.require:
1364 * @tc.author: chenyu
1365 */
1366 HWTEST_F(ImeEnabledInfoManagerTest, testSetTmpIme_003, TestSize.Level0)
1367 {
1368 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetTmpIme_003 START");
1369 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1370 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1371 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1372 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1373 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1374 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1375 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1376
1377 auto ret = ImeEnabledInfoManager::GetInstance().SetTmpIme(ImeEnabledInfoManagerTest::currentUserId_, "");
1378 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1379 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1380 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1381 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1382 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1383 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1384 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1385 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1386 }
1387
1388 /**
1389 * @tc.name: testSetTmpIme_004
1390 * @tc.desc: test:tmp ime set
1391 * @tc.require:
1392 * @tc.author: chenyu
1393 */
1394 HWTEST_F(ImeEnabledInfoManagerTest, testSetTmpIme_004, TestSize.Level0)
1395 {
1396 IMSA_HILOGI("ImeEnabledInfoManagerTest testSetTmpIme_004 START");
1397 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1398 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1399 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1400 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1401 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1402 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1403 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1404
1405 auto ret = ImeEnabledInfoManager::GetInstance().SetTmpIme(
1406 ImeEnabledInfoManagerTest::currentUserId_, std::string(ImeEnabledInfoManagerTest::sysImeProp_.bundleName) + "/"
1407 + ImeEnabledInfoManagerTest::sysImeProp_.extName);
1408 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1409 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos1;
1410 easyEnabledInfos1.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1411 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1412 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1413 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1414 EXPECT_TRUE(ImeEnabledInfoManagerTest::WaitDataShareCallback(
1415 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos1)));
1416 }
1417
1418 /**
1419 * @tc.name: testGetCurrentImeCfg_001
1420 * @tc.desc: test:has tmp ime, current ime is tmp ime
1421 * @tc.require:
1422 * @tc.author: chenyu
1423 */
1424 HWTEST_F(ImeEnabledInfoManagerTest, testGetCurrentImeCfg_001, TestSize.Level0)
1425 {
1426 IMSA_HILOGI("ImeEnabledInfoManagerTest testGetCurrentImeCfg_001 START");
1427 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1428 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1429 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE, false, false, true },
1430 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1431 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1432 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1433 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1434 auto currentIme = ImeEnabledInfoManager::GetInstance().GetCurrentImeCfg(ImeEnabledInfoManagerTest::currentUserId_);
1435 ASSERT_NE(currentIme, nullptr);
1436 EXPECT_EQ(currentIme->bundleName, ImeEnabledInfoManagerTest::sysImeProp_.bundleName);
1437 EXPECT_EQ(currentIme->extName, ImeEnabledInfoManagerTest::sysImeProp_.extName);
1438 EXPECT_EQ(currentIme->imeId, ImeEnabledInfoManagerTest::sysImeProp_.imeId);
1439 }
1440
1441 /**
1442 * @tc.name: testGetCurrentImeCfg_002
1443 * @tc.desc: test:has no tmp ime, current ime is default ime
1444 * @tc.require:
1445 * @tc.author: chenyu
1446 */
1447 HWTEST_F(ImeEnabledInfoManagerTest, testGetCurrentImeCfg_002, TestSize.Level0)
1448 {
1449 IMSA_HILOGI("ImeEnabledInfoManagerTest testGetCurrentImeCfg_002 START");
1450 std::map<int32_t, std::vector<ImeEasyInfo>> easyEnabledInfos;
1451 easyEnabledInfos.insert({ ImeEnabledInfoManagerTest::currentUserId_,
1452 { { ImeEnabledInfoManagerTest::SYS_IME_KEY, EnabledStatus::BASIC_MODE },
1453 { ImeEnabledInfoManagerTest::IME_KEY2, EnabledStatus::BASIC_MODE, true, true, false,
1454 ImeEnabledInfoManagerTest::CUR_SUBNAME2 } } });
1455 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_ =
1456 ImeEnabledInfoManagerTest::GenerateAllEnabledCfg(easyEnabledInfos);
1457 auto currentIme = ImeEnabledInfoManager::GetInstance().GetCurrentImeCfg(ImeEnabledInfoManagerTest::currentUserId_);
1458 ASSERT_NE(currentIme, nullptr);
1459 EXPECT_EQ(currentIme->bundleName, ImeEnabledInfoManagerTest::BUNDLE_NAME2);
1460 EXPECT_EQ(currentIme->extName, ImeEnabledInfoManagerTest::EXT_NAME2);
1461 EXPECT_EQ(currentIme->subName, ImeEnabledInfoManagerTest::CUR_SUBNAME2);
1462 EXPECT_EQ(currentIme->imeId,
1463 std::string(ImeEnabledInfoManagerTest::BUNDLE_NAME2) + "/" + ImeEnabledInfoManagerTest::EXT_NAME2);
1464 }
1465 } // namespace MiscServices
1466 } // namespace OHOS
1467