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