1 /* 2 * Copyright (c) 2024 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_cfg_manager.h" 20 #include "ime_info_inquirer.h" 21 #include "security_mode_parser.h" 22 #include "sys_cfg_parser.h" 23 #undef private 24 25 #include <gtest/gtest.h> 26 #include <unistd.h> 27 28 using namespace testing; 29 using namespace testing::ext; 30 namespace OHOS { 31 namespace MiscServices { 32 class JsonOperateTest : public testing::Test { 33 public: 34 static constexpr const char *IME_PERSIST_CFG = "{\"imeCfgList\":[{\"userId\":100,\"currentIme\":\"bundleName/" 35 "extName\",\"currentSubName\":\"subName\"},{\"userId\":" 36 "104,\"currentIme\":\"bundleName1/" 37 "extName1\",\"currentSubName\":\"subName1\"}]}"; 38 static constexpr const char *IME_PERSIST_CFG_NULL = "{\"imeCfgList\":[]}"; 39 static constexpr const char *IME_PERSIST_CFG_VALUE_TYPE_ERROR = "{\"imeCfgList\":[{\"userId\":100,\"currentIme\":" 40 "\"bundleName/" 41 "extName\",\"currentSubName\":\"subName\"},{" 42 "\"userId\":" 43 "\"104\",\"currentIme\":\"bundleName1/" 44 "extName1\",\"currentSubName\":\"subName1\"}]}"; 45 static constexpr const char *IME_PERSIST_CFG_NAME_LACK = "{\"imeCfgList\":[{\"userId\":100,\"currentSubName\":" 46 "\"subName\"}]}"; 47 static constexpr const char *IME_PERSIST_CFG_NAME_ERROR = "{\"imeCfgList\":[{\"userId\":100, \"bundle\": " 48 "\"bundleName/extNme\",\"currentSubName\":" 49 "\"subName\"}]}"; 50 51 static constexpr const char *ENABLE_IME = "{\"enableImeList\" : {\"100\" : [ \"testIme\", \"testIme1\", " 52 "\"testIme2\"],\"101\" : [\"testIme3\"], \"102\" : []}}"; 53 static constexpr const char *ENABLE_KEYBOARD = "{\"enableKeyboardList\" : {\"100\" : [ \"testKeyboard\", " 54 "\"testKeyboard1\"],\"101\" : " 55 "[\"testKeyboard2\"], \"105\" : []}}"; 56 static constexpr const char *SECURITY_MODE = "{\"fullExperienceList\" : {\"100\" : [\"testIme\", " 57 "\"testIme3\"], \"102\" : []}}"; 58 static constexpr const char *SUBTYPE = "{\"subtypes\": [{\"icon\": \"$media:icon\",\"id\": " 59 "\"subtypeId\",\"label\": \"$string:chinese\",\"locale\": " 60 "\"zh-CN\",\"mode\": \"lower\"},{\"icon\": \"$media:icon1\",\"id\": " 61 "\"subtypeId1\",\"label\": \"$string:english\",\"locale\": " 62 "\"en-US\",\"mode\": \"upper\"}]} "; 63 static constexpr const char *INPUT_SYS_CGF = "{\"systemConfig\":{\"enableInputMethodFeature\":true," 64 "\"enableFullExperienceFeature\":true," 65 "\"systemInputMethodConfigAbility\":\"setAbility\"," 66 "\"defaultInputMethod\":\"bundleName/extName\"}, " 67 "\"supportedInputTypeList\":[{\"inputType\":0,\"bundleName\":" 68 "\"testBundleName\", " 69 "\"subtypeId\":\"testSubtypeId\"},{\"inputType\":1,\"bundleName\":" 70 "\"\", \"subtypeId\":\"\"}]}"; 71 static constexpr const char *SYS_PANEL_ADJUST = "{\"sysPanelAdjust\":" 72 "[{\"style\": [\"fix\",\"default\",\"landscape\"]," 73 "\"top\": 1,\"left\": 2,\"right\": 3,\"bottom\": 4}]}"; 74 SetUpTestCase()75 static void SetUpTestCase() 76 { 77 } TearDownTestCase()78 static void TearDownTestCase() 79 { 80 } SetUp()81 void SetUp() 82 { 83 } TearDown()84 void TearDown() 85 { 86 } 87 }; 88 89 /** 90 * @tc.name: testParseEnableIme001 91 * @tc.desc: parse enableIme 92 * @tc.type: FUNC 93 * @tc.require: 94 * @tc.author: chenyu 95 */ 96 HWTEST_F(JsonOperateTest, testParseEnableIme001, TestSize.Level0) 97 { 98 IMSA_HILOGI("JsonOperateTest testParseEnableIme001 START"); 99 std::vector<std::string> enableVec; 100 auto ret = EnableImeDataParser::GetInstance()->ParseEnableIme(ENABLE_IME, 100, enableVec); 101 ASSERT_TRUE(ret); 102 ASSERT_EQ(enableVec.size(), 3); 103 EXPECT_EQ(enableVec[0], "testIme"); 104 EXPECT_EQ(enableVec[1], "testIme1"); 105 EXPECT_EQ(enableVec[2], "testIme2"); 106 107 std::vector<std::string> enableVec1; 108 ret = EnableImeDataParser::GetInstance()->ParseEnableIme(ENABLE_IME, 101, enableVec1); 109 ASSERT_TRUE(ret); 110 ASSERT_EQ(enableVec1.size(), 1); 111 EXPECT_EQ(enableVec1[0], "testIme3"); 112 113 std::vector<std::string> enableVec2; 114 ret = EnableImeDataParser::GetInstance()->ParseEnableIme(ENABLE_IME, 102, enableVec2); 115 EXPECT_TRUE(ret); 116 EXPECT_TRUE(enableVec2.empty()); 117 118 std::vector<std::string> enableVec3; 119 ret = EnableImeDataParser::GetInstance()->ParseEnableIme(ENABLE_IME, 104, enableVec3); 120 EXPECT_TRUE(ret); 121 EXPECT_TRUE(enableVec3.empty()); 122 } 123 /** 124 * @tc.name: testParseEnableKeyboard001 125 * @tc.desc: parse enableKeyboard 126 * @tc.type: FUNC 127 * @tc.require: 128 * @tc.author: chenyu 129 */ 130 HWTEST_F(JsonOperateTest, testParseEnableKeyboard001, TestSize.Level0) 131 { 132 IMSA_HILOGI("JsonOperateTest testParseEnableKeyboard001 START"); 133 std::vector<std::string> enableVec; 134 auto ret = EnableImeDataParser::GetInstance()->ParseEnableKeyboard(ENABLE_KEYBOARD, 100, enableVec); 135 ASSERT_TRUE(ret); 136 ASSERT_EQ(enableVec.size(), 2); 137 EXPECT_EQ(enableVec[0], "testKeyboard"); 138 EXPECT_EQ(enableVec[1], "testKeyboard1"); 139 140 std::vector<std::string> enableVec1; 141 ret = EnableImeDataParser::GetInstance()->ParseEnableKeyboard(ENABLE_KEYBOARD, 101, enableVec1); 142 ASSERT_TRUE(ret); 143 ASSERT_EQ(enableVec1.size(), 1); 144 EXPECT_EQ(enableVec1[0], "testKeyboard2"); 145 146 std::vector<std::string> enableVec2; 147 ret = EnableImeDataParser::GetInstance()->ParseEnableKeyboard(ENABLE_KEYBOARD, 105, enableVec2); 148 EXPECT_TRUE(ret); 149 EXPECT_TRUE(enableVec2.empty()); 150 151 std::vector<std::string> enableVec3; 152 ret = EnableImeDataParser::GetInstance()->ParseEnableKeyboard(ENABLE_KEYBOARD, 104, enableVec3); 153 EXPECT_TRUE(ret); 154 EXPECT_TRUE(enableVec3.empty()); 155 } 156 157 /** 158 * @tc.name: testParseSecurityMode001 159 * @tc.desc: parse securityMode 160 * @tc.type: FUNC 161 * @tc.require: 162 * @tc.author: chenyu 163 */ 164 HWTEST_F(JsonOperateTest, testParseSecurityMode001, TestSize.Level0) 165 { 166 IMSA_HILOGI("JsonOperateTest testParseSecurityMode001 START"); 167 SecurityModeParser::GetInstance()->fullModeList_.clear(); 168 auto ret = SecurityModeParser::GetInstance()->ParseSecurityMode(JsonOperateTest::SECURITY_MODE, 100); 169 ASSERT_TRUE(ret); 170 auto secMode = SecurityModeParser::GetInstance()->fullModeList_; 171 ASSERT_EQ(secMode.size(), 2); 172 EXPECT_EQ(secMode[0], "testIme"); 173 EXPECT_EQ(secMode[1], "testIme3"); 174 175 SecurityModeParser::GetInstance()->fullModeList_.clear(); 176 ret = SecurityModeParser::GetInstance()->ParseSecurityMode(JsonOperateTest::SECURITY_MODE, 102); 177 EXPECT_TRUE(ret); 178 EXPECT_TRUE(SecurityModeParser::GetInstance()->fullModeList_.empty()); 179 180 SecurityModeParser::GetInstance()->fullModeList_.clear(); 181 ret = SecurityModeParser::GetInstance()->ParseSecurityMode(JsonOperateTest::SECURITY_MODE, 105); 182 EXPECT_TRUE(ret); 183 EXPECT_TRUE(SecurityModeParser::GetInstance()->fullModeList_.empty()); 184 } 185 186 /** 187 * @tc.name: testParseImePersistCfg001 188 * @tc.desc: parse imePersistCfg 189 * @tc.type: FUNC 190 * @tc.require: 191 * @tc.author: chenyu 192 */ 193 HWTEST_F(JsonOperateTest, testParseImePersistCfg001, TestSize.Level0) 194 { 195 IMSA_HILOGI("JsonOperateTest testParseImePersistCfg001 START"); 196 ImeCfgManager::GetInstance().imeConfigs_.clear(); 197 auto ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::IME_PERSIST_CFG); 198 ASSERT_TRUE(ret); 199 ASSERT_EQ(ImeCfgManager::GetInstance().imeConfigs_.size(), 2); 200 auto cfg = ImeCfgManager::GetInstance().imeConfigs_; 201 EXPECT_EQ(cfg[0].userId, 100); 202 EXPECT_EQ(cfg[0].currentIme, "bundleName/extName"); 203 EXPECT_EQ(cfg[0].currentSubName, "subName"); 204 EXPECT_EQ(cfg[1].userId, 104); 205 EXPECT_EQ(cfg[1].currentIme, "bundleName1/extName1"); 206 EXPECT_EQ(cfg[1].currentSubName, "subName1"); 207 208 ImeCfgManager::GetInstance().imeConfigs_.clear(); 209 ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::IME_PERSIST_CFG_NULL); 210 EXPECT_TRUE(ret); 211 EXPECT_TRUE(ImeCfgManager::GetInstance().imeConfigs_.empty()); 212 213 ImeCfgManager::GetInstance().imeConfigs_.clear(); 214 ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::IME_PERSIST_CFG_VALUE_TYPE_ERROR); 215 EXPECT_FALSE(ret); 216 EXPECT_TRUE(ImeCfgManager::GetInstance().imeConfigs_.empty()); 217 218 ImeCfgManager::GetInstance().imeConfigs_.clear(); 219 ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::IME_PERSIST_CFG_NAME_LACK); 220 EXPECT_FALSE(ret); 221 EXPECT_TRUE(ImeCfgManager::GetInstance().imeConfigs_.empty()); 222 223 ImeCfgManager::GetInstance().imeConfigs_.clear(); 224 ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::IME_PERSIST_CFG_NAME_ERROR); 225 EXPECT_FALSE(ret); 226 EXPECT_TRUE(ImeCfgManager::GetInstance().imeConfigs_.empty()); 227 228 ret = ImeCfgManager::GetInstance().ParseImeCfg(JsonOperateTest::ENABLE_KEYBOARD); 229 EXPECT_FALSE(ret); 230 } 231 232 /** 233 * @tc.name: testPackageImePersistCfg001 234 * @tc.desc: package imePersistCfg 235 * @tc.type: FUNC 236 * @tc.require: 237 * @tc.author: chenyu 238 */ 239 HWTEST_F(JsonOperateTest, testPackageImePersistCfg001, TestSize.Level0) 240 { 241 IMSA_HILOGI("JsonOperateTest testPackageImePersistCfg001 START"); 242 ImeCfgManager::GetInstance().imeConfigs_.clear(); 243 ImeCfgManager::GetInstance().imeConfigs_.emplace_back(100, "bundleName/extName", "subName"); 244 ImeCfgManager::GetInstance().imeConfigs_.emplace_back(104, "bundleName1/extName1", "subName1"); 245 auto str = ImeCfgManager::GetInstance().PackageImeCfg(); 246 EXPECT_EQ(str, JsonOperateTest::IME_PERSIST_CFG); 247 } 248 249 /** 250 * @tc.name: testParseSystemConfig001 251 * @tc.desc: parse systemConfig 252 * @tc.type: FUNC 253 * @tc.require: 254 * @tc.author: chenyu 255 */ 256 HWTEST_F(JsonOperateTest, testParseSystemConfig001, TestSize.Level0) 257 { 258 IMSA_HILOGI("JsonOperateTest testParseSystemConfig001 START"); 259 ImeSystemConfig imeSystemConfig; 260 auto ret = imeSystemConfig.Unmarshall(INPUT_SYS_CGF); 261 ASSERT_TRUE(ret); 262 auto systemConfig = imeSystemConfig.systemConfig; 263 EXPECT_EQ(systemConfig.systemInputMethodConfigAbility, "setAbility"); 264 EXPECT_EQ(systemConfig.defaultInputMethod, "bundleName/extName"); 265 EXPECT_TRUE(systemConfig.enableInputMethodFeature); 266 EXPECT_TRUE(systemConfig.enableFullExperienceFeature); 267 } 268 269 /** 270 * @tc.name: testParseInputType001 271 * @tc.desc: parse inputType 272 * @tc.type: FUNC 273 * @tc.require: 274 * @tc.author: chenyu 275 */ 276 HWTEST_F(JsonOperateTest, testParseInputType001, TestSize.Level0) 277 { 278 IMSA_HILOGI("JsonOperateTest testParseInputType001 START"); 279 InputTypeCfg inputTypeCfg; 280 auto ret = inputTypeCfg.Unmarshall(INPUT_SYS_CGF); 281 ASSERT_TRUE(ret); 282 auto inputType = inputTypeCfg.inputType; 283 ASSERT_EQ(inputType.size(), 2); 284 EXPECT_EQ(inputType[0].type, InputType::CAMERA_INPUT); 285 EXPECT_EQ(inputType[0].subName, "testSubtypeId"); 286 EXPECT_EQ(inputType[0].bundleName, "testBundleName"); 287 EXPECT_EQ(inputType[1].type, InputType::SECURITY_INPUT); 288 EXPECT_EQ(inputType[1].subName, ""); 289 EXPECT_EQ(inputType[1].bundleName, ""); 290 } 291 292 /** 293 * @tc.name: testParseSubtype001 294 * @tc.desc: parse subtype 295 * @tc.type: FUNC 296 * @tc.require: 297 * @tc.author: chenyu 298 */ 299 HWTEST_F(JsonOperateTest, testParseSubtype001, TestSize.Level0) 300 { 301 IMSA_HILOGI("JsonOperateTest testParseSubtype001 START"); 302 std::vector<std::string> profiles{ { JsonOperateTest::SUBTYPE } }; 303 SubtypeCfg subtype; 304 auto ret = ImeInfoInquirer::GetInstance().ParseSubtypeProfile(profiles, subtype); 305 ASSERT_TRUE(ret); 306 ASSERT_EQ(subtype.subtypes.size(), 2); 307 auto subtypes = subtype.subtypes; 308 EXPECT_EQ(subtypes[0].icon, "$media:icon"); 309 EXPECT_EQ(subtypes[0].id, "subtypeId"); 310 EXPECT_EQ(subtypes[0].label, "$string:chinese"); 311 EXPECT_EQ(subtypes[0].locale, "zh-CN"); 312 EXPECT_EQ(subtypes[0].mode, "lower"); 313 EXPECT_EQ(subtypes[1].icon, "$media:icon1"); 314 EXPECT_EQ(subtypes[1].id, "subtypeId1"); 315 EXPECT_EQ(subtypes[1].label, "$string:english"); 316 EXPECT_EQ(subtypes[1].locale, "en-US"); 317 EXPECT_EQ(subtypes[1].mode, "upper"); 318 319 std::vector<std::string> profiles1{ { JsonOperateTest::SECURITY_MODE } }; 320 SubtypeCfg subtype1; 321 ret = ImeInfoInquirer::GetInstance().ParseSubtypeProfile(profiles1, subtype1); 322 EXPECT_FALSE(ret); 323 EXPECT_TRUE(subtype1.subtypes.empty()); 324 } 325 326 /** 327 * @tc.name: testParseSysPanelAdjust001 328 * @tc.desc: parse SysPanelAdjust 329 * @tc.type: FUNC 330 * @tc.require: 331 */ 332 HWTEST_F(JsonOperateTest, testParseSysPanelAdjust001, TestSize.Level0) 333 { 334 IMSA_HILOGI("JsonOperateTest testParseSysPanelAdjust001 START"); 335 SysPanelAdjustCfg sysPanelAdjustCfg; 336 auto ret = sysPanelAdjustCfg.Unmarshall(SYS_PANEL_ADJUST); 337 ASSERT_TRUE(ret); 338 auto panelAdjust = sysPanelAdjustCfg.panelAdjust; 339 EXPECT_EQ(panelAdjust[0].style[0], "fix"); 340 EXPECT_EQ(panelAdjust[0].style[1], "default"); 341 EXPECT_EQ(panelAdjust[0].style[2], "landscape"); 342 EXPECT_EQ(panelAdjust[0].top, 1); 343 EXPECT_EQ(panelAdjust[0].left, 2); 344 EXPECT_EQ(panelAdjust[0].right, 3); 345 EXPECT_EQ(panelAdjust[0].bottom, 4); 346 } 347 } // namespace MiscServices 348 } // namespace OHOS