1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15#include "gtest/gtest.h"
16#include "string_ex.h"
17#include "system_ability_definition.h"
18#include "test_log.h"
19#include "tools.h"
20
21#define private public
22#include "parse_util.h"
23using namespace std;
24using namespace testing;
25using namespace testing::ext;
26
27namespace OHOS {
28namespace SAMGR {
29namespace {
30    const std::string TEST_RESOURCE_PATH = "/data/test/resource/samgr/profile/";
31    const std::u16string TEST_PROCESS_NAME = u"sa_test";
32    const std::string EVENT_STRING;
33    const std::string EVENT_TYPE ;
34    const std::string EVENT_NAME ;
35    const std::string EVENT_VALUE ;
36    const int32_t TEST_NUM = 123;
37    const int32_t MOCK_SAID = 1492;
38    const int32_t TEST_PROFILE_SAID = 9999;
39    const int32_t TEST_PROFILE_SAID_INVAILD = 9990;
40    constexpr const char* SA_TAG_DEVICE_ON_LINE = "deviceonline";
41    constexpr const char* SA_TAG_SETTING_SWITCH = "settingswitch";
42    constexpr const char* SA_TAG_COMMON_EVENT = "commonevent";
43    constexpr const char* SA_TAG_PARAM = "param";
44    constexpr const char* SA_TAG_TIEMD_EVENT = "timedevent";
45    const string EXTENSIOON_BACKUP = "backup";
46    const string EXTENSIOON_RESTORE = "restore";
47    constexpr int32_t MAX_JSON_STRING_LENGTH = 128;
48    constexpr int32_t MAX_EXTENSIONO_NUM = 100;
49}
50
51class ParseUtilTest : public testing::Test {
52public:
53    static void SetUpTestCase();
54    static void TearDownTestCase();
55    void SetUp();
56    void TearDown();
57protected:
58    std::shared_ptr<ParseUtil> parser_;
59};
60
61void ParseUtilTest::SetUpTestCase()
62{
63    DTEST_LOG << "SetUpTestCase" << std::endl;
64}
65
66void ParseUtilTest::TearDownTestCase()
67{
68    DTEST_LOG << "TearDownTestCase" << std::endl;
69}
70
71void ParseUtilTest::SetUp()
72{
73    DTEST_LOG << "SetUp" << std::endl;
74    if (parser_ == nullptr) {
75        parser_ = std::make_shared<ParseUtil>();
76    }
77}
78
79void ParseUtilTest::TearDown()
80{
81    DTEST_LOG << "TearDown" << std::endl;
82    if (parser_ != nullptr) {
83        parser_->ClearResource();
84    }
85}
86
87/**
88 * @tc.name: ParseSaProfile001
89 * @tc.desc: Verify if can load not exist file
90 * @tc.type: FUNC
91 */
92HWTEST_F(ParseUtilTest, ParseSaProfile001, TestSize.Level2)
93{
94    DTEST_LOG << " ParseSaProfile001 start " << std::endl;
95    /**
96     * @tc.steps: step1. parse not exsit config file
97     * @tc.expected: step1. return false when load not exist file
98     */
99    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "notExist");
100    EXPECT_FALSE(ret);
101}
102
103/**
104 * @tc.name: GetSaProfiles001
105 * @tc.desc:  Verify if not load sa file return empty list
106 * @tc.type: FUNC
107 */
108HWTEST_F(ParseUtilTest, GetSaProfiles001, TestSize.Level3)
109{
110    DTEST_LOG << " GetSaProfiles001 start " << std::endl;
111    /**
112     * @tc.steps: step1. Get empty config when not parse sa file.
113     * @tc.expected: step1. return empty list when not load sa file
114     */
115    list<SaProfile> profiles = parser_->GetAllSaProfiles();
116    EXPECT_TRUE(profiles.empty());
117}
118
119/**
120 * @tc.name: GetSaProfiles002
121 * @tc.desc:  Verify if can load normal sa profile
122 * @tc.type: FUNC
123 */
124HWTEST_F(ParseUtilTest, GetSaProfiles002, TestSize.Level3)
125{
126    DTEST_LOG << " GetSaProfiles002 start " << std::endl;
127    /**
128     * @tc.steps: step1. Get correct profile when parse sa file.
129     * @tc.expected: step1. return correct profile object when load correct config file
130     */
131    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "profile.json");
132    ASSERT_TRUE(ret);
133    SaProfile saRunOnCreateTrue;
134    saRunOnCreateTrue.runOnCreate = true;
135    SaProfile saRunOnCreateFalse;
136    parser_->saProfiles_.emplace_back(saRunOnCreateTrue);
137    parser_->saProfiles_.emplace_back(saRunOnCreateFalse);
138    list<SaProfile> profiles = parser_->GetAllSaProfiles();
139    if (!profiles.empty()) {
140        SaProfile& profile = *(profiles.begin());
141        EXPECT_EQ(profile.process, TEST_PROCESS_NAME);
142        EXPECT_EQ(profile.saId, TEST_PROFILE_SAID);
143    }
144}
145
146/**
147 * @tc.name: ParseTrustConfig001
148 * @tc.desc:  Verify if can load file with one sa
149 * @tc.type: FUNC
150 */
151HWTEST_F(ParseUtilTest, ParseTrustConfig001, TestSize.Level1)
152{
153    DTEST_LOG << " ParseTrustConfig001 start " << std::endl;
154    /**
155     * @tc.steps: step1. Get correct map when parse config file.
156     * @tc.expected: step1. return correct profile object when load correct config file
157     */
158    std::map<std::u16string, std::set<int32_t>> values;
159    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "test_trust_one_sa.json", values);
160    ASSERT_TRUE(ret);
161    /**
162     * @tc.steps: step2. Check map values
163     * @tc.expected: step2. return expect values
164     */
165    for (const auto& [process, saIds] : values) {
166        EXPECT_EQ(Str16ToStr8(process), "test");
167        EXPECT_EQ(saIds.size(), 1);
168        EXPECT_EQ(saIds.count(1401), 1);
169    }
170}
171
172/**
173 * @tc.name: ParseTrustConfig002
174 * @tc.desc:  Verify if can load file with muti sa
175 * @tc.type: FUNC
176 */
177HWTEST_F(ParseUtilTest, ParseTrustConfig002, TestSize.Level1)
178{
179    DTEST_LOG << " ParseTrustConfig002 start " << std::endl;
180    /**
181     * @tc.steps: step1. Get correct map when parse config file.
182     * @tc.expected: step1. return correct profile object when load correct config file
183     */
184    std::map<std::u16string, std::set<int32_t>> values;
185    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "test_trust_muti_sa.json", values);
186    ASSERT_TRUE(ret);
187    /**
188     * @tc.steps: step2. Check map values
189     * @tc.expected: step2. return expect values
190     */
191    for (const auto& [process, saIds] : values) {
192        EXPECT_EQ(Str16ToStr8(process), "test");
193        EXPECT_EQ(saIds.size(), 5);
194        EXPECT_EQ(saIds.count(1401), 1);
195    }
196}
197
198/**
199 * @tc.name: ParseTrustConfig003
200 * @tc.desc:  Verify if can load not invalid root file
201 * @tc.type: FUNC
202 */
203HWTEST_F(ParseUtilTest, ParseTrustConfig003, TestSize.Level1)
204{
205    DTEST_LOG << " ParseTrustConfig003 start " << std::endl;
206    /**
207     * @tc.steps: step1. Get correct map when parse config file.
208     * @tc.expected: step1. return false when load invalid root file
209     */
210    std::map<std::u16string, std::set<int32_t>> values;
211    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "invalid_root_trust.json", values);
212    ASSERT_FALSE(ret);
213}
214
215/**
216 * @tc.name: ParseTrustConfig004
217 * @tc.desc:  Verify if can load not exist file
218 * @tc.type: FUNC
219 */
220HWTEST_F(ParseUtilTest, ParseTrustConfig004, TestSize.Level1)
221{
222    DTEST_LOG << " ParseTrustConfig004 start " << std::endl;
223    /**
224     * @tc.steps: step1. Get correct profile when parse sa file.
225     * @tc.expected: step1. return false when not exist file
226     */
227    std::map<std::u16string, std::set<int32_t>> values;
228    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "notExist", values);
229    ASSERT_FALSE(ret);
230}
231
232/**
233 * @tc.name: ParseTrustConfig005
234 * @tc.desc:  Verify if can load invalid element config
235 * @tc.type: FUNC
236 */
237HWTEST_F(ParseUtilTest, ParseTrustConfig005, TestSize.Level1)
238{
239    DTEST_LOG << " ParseTrustConfig005 start " << std::endl;
240    /**
241     * @tc.steps: step1. Get correct profile when parse invalid element config.
242     * @tc.expected: step1. return correct profile object when load correct config file
243     */
244    std::map<std::u16string, std::set<int32_t>> values;
245    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "invalid_element_trust.json", values);
246    ASSERT_TRUE(ret);
247    for (const auto& [process, saIds] : values) {
248        EXPECT_EQ(Str16ToStr8(process), "test");
249        EXPECT_EQ(saIds.size(), 3);
250        EXPECT_EQ(saIds.count(1401), 1);
251    }
252}
253
254/**
255 * @tc.name: ParseTrustConfig006
256 * @tc.desc:  Verify if can load invalid muti root file
257 * @tc.type: FUNC
258 */
259HWTEST_F(ParseUtilTest, ParseTrustConfig006, TestSize.Level1)
260{
261    DTEST_LOG << " ParseTrustConfig006 start " << std::endl;
262    /**
263     * @tc.steps: step1. Get correct profile when parse sa file.
264     * @tc.expected: step1. return correct profile object when load correct config file
265     */
266    std::map<std::u16string, std::set<int32_t>> values;
267    bool ret = parser_->ParseTrustConfig(TEST_RESOURCE_PATH + "invalid_muti_root_trust.json", values);
268    ASSERT_FALSE(ret);
269}
270
271/**
272 * @tc.name: RemoveSaProfile001
273 * @tc.desc:  Verify if can remove not-existed id
274 * @tc.type: FUNC
275 */
276HWTEST_F(ParseUtilTest, RemoveSaProfile001, TestSize.Level3)
277{
278    DTEST_LOG << " RemoveSaProfile001 start " << std::endl;
279    /**
280     * @tc.steps: step1. parse not exsit config file
281     * @tc.expected: step1. return false when load not exist file
282     */
283    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "notExist");
284    EXPECT_FALSE(ret);
285    /**
286     * @tc.steps: step2. remove not-existed id
287     * @tc.expected: step2. not crash
288     */
289    parser_->RemoveSaProfile(111);
290    auto profiles = parser_->GetAllSaProfiles();
291    EXPECT_EQ(profiles.size(), 0);
292}
293
294/**
295 * @tc.name: RemoveSaProfile002
296 * @tc.desc:  Verify if can can remove not-existed id
297 * @tc.type: FUNC
298 */
299HWTEST_F(ParseUtilTest, RemoveSaProfile002, TestSize.Level3)
300{
301    DTEST_LOG << " RemoveSaProfile002 start " << std::endl;
302    /**
303     * @tc.steps: step1. parse multi-sa profile
304     * @tc.expected: step1. return true when load multi-sa profile
305     */
306    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
307    EXPECT_TRUE(ret);
308    auto profiles = parser_->GetAllSaProfiles();
309    EXPECT_EQ(profiles.size(), 4);
310    /**
311     * @tc.steps: step2. remove not-existed id
312     * @tc.expected: step2. not crash
313     */
314    parser_->RemoveSaProfile(111);
315    profiles = parser_->GetAllSaProfiles();
316    EXPECT_EQ(profiles.size(), 4);
317}
318
319/**
320 * @tc.name: RemoveSaProfile003
321 * @tc.desc:  Verify if can remove one existed id
322 * @tc.type: FUNC
323 */
324HWTEST_F(ParseUtilTest, RemoveSaProfile003, TestSize.Level3)
325{
326    DTEST_LOG << " RemoveSaProfile003 start " << std::endl;
327    /**
328     * @tc.steps: step1. parse multi-sa profile
329     * @tc.expected: step1. return true when load multi-sa profile
330     */
331    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
332    EXPECT_TRUE(ret);
333    auto profiles = parser_->GetAllSaProfiles();
334    EXPECT_EQ(profiles.size(), 4);
335    /**
336     * @tc.steps: step2. remove one existed id
337     * @tc.expected: step2. remove successfully
338     */
339    parser_->RemoveSaProfile(9999);
340    profiles = parser_->GetAllSaProfiles();
341    EXPECT_EQ(profiles.size(), 3);
342}
343
344/**
345 * @tc.name: RemoveSaProfile004
346 * @tc.desc:  Verify if can remove one existed id
347 * @tc.type: FUNC
348 */
349HWTEST_F(ParseUtilTest, RemoveSaProfile004, TestSize.Level3)
350{
351    DTEST_LOG << " RemoveSaProfile004 start " << std::endl;
352    /**
353     * @tc.steps: step1. parse multi-sa profile
354     * @tc.expected: step1. return true when load multi-sa profile
355     */
356    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
357    EXPECT_TRUE(ret);
358    auto profiles = parser_->GetAllSaProfiles();
359    EXPECT_EQ(profiles.size(), 4);
360    /**
361     * @tc.steps: step2. remove one existed id
362     * @tc.expected: step2. remove successfully
363     */
364    parser_->RemoveSaProfile(9997);
365    profiles = parser_->GetAllSaProfiles();
366    EXPECT_EQ(profiles.size(), 2);
367}
368
369/**
370 * @tc.name: RemoveSaProfile005
371 * @tc.desc:  Verify if can remove more existed id
372 * @tc.type: FUNC
373 */
374HWTEST_F(ParseUtilTest, RemoveSaProfile005, TestSize.Level3)
375{
376    DTEST_LOG << " RemoveSaProfile004 start " << std::endl;
377    /**
378     * @tc.steps: step1. parse multi-sa profile
379     * @tc.expected: step1. return true when load multi-sa profile
380     */
381    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
382    EXPECT_TRUE(ret);
383    auto profiles = parser_->GetAllSaProfiles();
384    EXPECT_EQ(profiles.size(), 4);
385    /**
386     * @tc.steps: step2. remove more existed id
387     * @tc.expected: step2. remove successfully
388     */
389    parser_->RemoveSaProfile(9997);
390    parser_->RemoveSaProfile(9998);
391    parser_->RemoveSaProfile(9998);
392    profiles = parser_->GetAllSaProfiles();
393    EXPECT_EQ(profiles.size(), 1);
394}
395
396/**
397 * @tc.name: CheckPathExist001
398 * @tc.desc:  Verify if can check not exist file
399 * @tc.type: FUNC
400 */
401HWTEST_F(ParseUtilTest, CheckPathExist001, TestSize.Level2)
402{
403    DTEST_LOG << " CheckPathExist001 start " << std::endl;
404    /**
405     * @tc.steps: step1. check not exsit config file
406     * @tc.expected: step1. return false when check not exist file
407     */
408    bool ret = parser_->CheckPathExist(TEST_RESOURCE_PATH + "not_exist.json");
409    EXPECT_FALSE(ret);
410}
411
412/**
413 * @tc.name: CheckPathExist002
414 * @tc.desc:  Verify if can check exist file
415 * @tc.type: FUNC
416 */
417HWTEST_F(ParseUtilTest, CheckPathExist002, TestSize.Level2)
418{
419    DTEST_LOG << " CheckPathExist002 start " << std::endl;
420    /**
421     * @tc.steps: step1. check exsit config file
422     * @tc.expected: step1. return true when load not exist file
423     */
424    bool ret = parser_->CheckPathExist(TEST_RESOURCE_PATH + "multi_sa_profile.json");
425    EXPECT_TRUE(ret);
426}
427
428/**
429 * @tc.name: GetProfile001
430 * @tc.desc: Verify if can get not-exist profile
431 * @tc.type: FUNC
432 * @tc.require: I5KMF7
433 */
434HWTEST_F(ParseUtilTest, GetProfile001, TestSize.Level2)
435{
436    DTEST_LOG << " GetProfile001 start " << std::endl;
437    /**
438     * @tc.steps: step1. check exsit config file
439     * @tc.expected: step1. return true when load not exist file
440     */
441    SaProfile saProfile;
442    bool ret = parser_->GetProfile(TEST_PROFILE_SAID, saProfile);
443    EXPECT_EQ(ret, false);
444}
445
446/**
447 * @tc.name: GetProfile002
448 * @tc.desc: Verify if can get exist profile
449 * @tc.type: FUNC
450 * @tc.require: I5KMF7
451 */
452HWTEST_F(ParseUtilTest, GetProfile002, TestSize.Level2)
453{
454    DTEST_LOG << " GetProfile002 start " << std::endl;
455    /**
456     * @tc.steps: step1. check exsit config file
457     * @tc.expected: step1. return true when load not exist file
458     */
459    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
460    EXPECT_EQ(ret, true);
461    SaProfile saProfile;
462    ret = parser_->GetProfile(TEST_PROFILE_SAID, saProfile);
463    EXPECT_EQ(ret, true);
464    EXPECT_EQ(saProfile.saId, TEST_PROFILE_SAID);
465    EXPECT_EQ(saProfile.runOnCreate, true);
466}
467
468/**
469 * @tc.name: LoadSaLib001
470 * @tc.desc: Verify if can load salib
471 * @tc.type: FUNC
472 * @tc.require: I5KMF7
473 */
474HWTEST_F(ParseUtilTest, LoadSaLib001, TestSize.Level2)
475{
476    DTEST_LOG << " LoadSaLib001 start " << std::endl;
477    /**
478     * @tc.steps: step1. check exsit salib
479     * @tc.expected: step1. return true when load exist salib
480     */
481    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
482    EXPECT_EQ(ret, true);
483    ret = parser_->LoadSaLib(TEST_PROFILE_SAID);
484    EXPECT_EQ(ret, true);
485}
486
487/**
488 * @tc.name: LoadSaLib002
489 * @tc.desc: Verify if can load salib
490 * @tc.type: FUNC
491 * @tc.require: I5KMF7
492 */
493HWTEST_F(ParseUtilTest, LoadSaLib002, TestSize.Level2)
494{
495    DTEST_LOG << " LoadSaLib002 start " << std::endl;
496    /**
497     * @tc.steps: step1. check exsit salib
498     * @tc.expected: step1. return false when load not exist salib
499     */
500    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
501    EXPECT_EQ(ret, true);
502    ret = parser_->LoadSaLib(TEST_PROFILE_SAID_INVAILD);
503    parser_->CloseSo(MOCK_SAID);
504    EXPECT_NE(ret, true);
505}
506
507/**
508 * @tc.name: LoadSaLib003
509 * @tc.desc: Verify if can load salib
510 * @tc.type: FUNC
511 * @tc.require: I5KMF7
512 */
513HWTEST_F(ParseUtilTest, LoadSaLib003, TestSize.Level2)
514{
515    DTEST_LOG << " LoadSaLib003 start " << std::endl;
516    /**
517     * @tc.steps: step1. check exsit salib
518     * @tc.expected: step1. return false when load not exist salib
519     */
520    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "mock.json");
521    EXPECT_EQ(ret, true);
522    ret = parser_->LoadSaLib(MOCK_SAID);
523    parser_->CloseSo(MOCK_SAID);
524    EXPECT_EQ(ret, true);
525}
526
527/**
528 * @tc.name: LoadSaLib004
529 * @tc.desc: Verify if can load salib
530 * @tc.type: FUNC
531 * @tc.require: I5KMF7
532 */
533HWTEST_F(ParseUtilTest, LoadSaLib004, TestSize.Level2)
534{
535    DTEST_LOG << " LoadSaLib004 start " << std::endl;
536    /**
537     * @tc.steps: step1. check exsit salib
538     * @tc.expected: step1. return false when load not exist salib
539     */
540    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "mock.json");
541    EXPECT_EQ(ret, true);
542    ret = parser_->LoadSaLib(MOCK_SAID);
543    EXPECT_EQ(ret, true);
544    parser_->LoadSaLib(MOCK_SAID);
545}
546
547/**
548 * @tc.name: LoadSaLib005
549 * @tc.desc: Verify if can load salib
550 * @tc.type: FUNC
551 * @tc.require: I5KMF7
552 */
553HWTEST_F(ParseUtilTest, LoadSaLib005, TestSize.Level2)
554{
555    DTEST_LOG << " LoadSaLib005 start " << std::endl;
556    /**
557     * @tc.steps: step1. check exsit salib
558     * @tc.expected: step1. return false when load not exist salib
559     */
560    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "empty_libpath.json");
561    EXPECT_EQ(ret, true);
562    ret = parser_->LoadSaLib(MOCK_SAID);
563    EXPECT_EQ(ret, true);
564}
565/**
566 * @tc.name: GetProcessName001
567 * @tc.desc: Verify if can get procesname
568 * @tc.type: FUNC
569 * @tc.require: I5KMF7
570 */
571HWTEST_F(ParseUtilTest, GetProcessName001, TestSize.Level3)
572{
573    DTEST_LOG << " GetProcessName001 " << std::endl;
574    /**
575     * @tc.steps: step1. get SaProfiles
576     * @tc.expected: step1. return true when SaProfiles
577     */
578    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
579    EXPECT_EQ(ret, true);
580    std::u16string Name = parser_->GetProcessName();
581    EXPECT_EQ(Str16ToStr8(Name), "test");
582}
583
584/**
585 * @tc.name: GetProcessName002
586 * @tc.desc: Verify if can get procesname
587 * @tc.type: FUNC
588 * @tc.require: I5KMF7
589 */
590HWTEST_F(ParseUtilTest, GetProcessName002, TestSize.Level3)
591{
592    DTEST_LOG << " GetProcessName002 " << std::endl;
593    /**
594    * @tc.steps: step1. get SaProfiles
595    * @tc.expected: step1. return true when SaProfiles
596    */
597    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "multi_sa_profile.json");
598    EXPECT_EQ(ret, true);
599    std::u16string Name = parser_->GetProcessName();
600    EXPECT_NE(Str16ToStr8(Name), "test_1");
601}
602
603
604/**
605 * @tc.name: DeleteAllMark001
606 * @tc.desc: Verify if can DeleteAllMark
607 * @tc.type: FUNC
608 * @tc.require: I5KMF7
609 */
610HWTEST_F(ParseUtilTest, DeleteAllMark001, TestSize.Level3)
611{
612    DTEST_LOG << " DeleteAllMark001 " << std::endl;
613    u16string temp = u"stests";
614    u16string mask = u"s";
615    u16string res = DeleteAllMark(temp, mask);
616    EXPECT_EQ(res, u"tet");
617}
618
619/**
620 * @tc.name: GetOnDemandConditionsFromJson001
621 * @tc.desc: parse OnDemandConditions, conditions is empty.
622 * @tc.type: FUNC
623 * @tc.require: I6JE38
624 */
625HWTEST_F(ParseUtilTest, GetOnDemandConditionsFromJson001, TestSize.Level3)
626{
627    DTEST_LOG << " GetOnDemandConditionsFromJson001 BEGIN" << std::endl;
628    nlohmann::json obj;
629    std::string key;
630    std::vector<OnDemandCondition> out;
631    SaProfile saProfile;
632    parser_->GetOnDemandConditionsFromJson(obj, key, out);
633    EXPECT_TRUE(out.empty());
634    DTEST_LOG << " GetOnDemandConditionsFromJson001 END" << std::endl;
635}
636
637/**
638 * @tc.name: GetOnDemandConditionsFromJson002
639 * @tc.desc: parse OnDemandConditions, one condition.
640 * @tc.type: FUNC
641 * @tc.require: I6JE38
642 */
643HWTEST_F(ParseUtilTest, GetOnDemandConditionsFromJson002, TestSize.Level3)
644{
645    DTEST_LOG << " GetOnDemandConditionsFromJson002 BEGIN" << std::endl;
646    nlohmann::json obj;
647    nlohmann::json conditions;
648    nlohmann::json condition;
649    condition["eventId"] = SA_TAG_DEVICE_ON_LINE;
650    condition["name"] = "mockName";
651    condition["value"] = "mockValue";
652    conditions[0] = condition;
653    obj["conditions"] = conditions;
654
655    std::string key = "conditions";
656    std::vector<OnDemandCondition> out;
657    SaProfile saProfile;
658    parser_->GetOnDemandConditionsFromJson(obj, key, out);
659    EXPECT_EQ(out.size(), 1);
660    DTEST_LOG << " GetOnDemandConditionsFromJson002 END" << std::endl;
661}
662
663/**
664 * @tc.name: GetOnDemandConditionsFromJson003
665 * @tc.desc: parse OnDemandConditions, five condition.
666 * @tc.type: FUNC
667 * @tc.require: I6JE38
668 */
669HWTEST_F(ParseUtilTest, GetOnDemandConditionsFromJson003, TestSize.Level3)
670{
671    DTEST_LOG << " GetOnDemandConditionsFromJson003 BEGIN" << std::endl;
672    nlohmann::json obj;
673    nlohmann::json conditions;
674    nlohmann::json condition;
675    condition["eventId"] = SA_TAG_DEVICE_ON_LINE;
676    condition["name"] = "mockName";
677    condition["value"] = "mockValue";
678    nlohmann::json condition2;
679    condition2["eventId"] = SA_TAG_SETTING_SWITCH;
680    condition2["name"] = "mockName";
681    condition2["value"] = "mockValue";
682    nlohmann::json condition3;
683    condition3["eventId"] = SA_TAG_COMMON_EVENT;
684    condition3["name"] = "mockName";
685    condition3["value"] = "mockValue";
686    nlohmann::json condition4;
687    condition4["eventId"] = SA_TAG_PARAM;
688    condition4["name"] = "mockName";
689    condition4["value"] = "mockValue";
690    nlohmann::json condition5;
691    condition5["eventId"] = SA_TAG_TIEMD_EVENT;
692    condition5["name"] = "mockName";
693    condition5["value"] = "mockValue";
694    conditions[0] = condition;
695    conditions[1] = condition2;
696    conditions[2] = condition3;
697    conditions[3] = condition4;
698    conditions[4] = condition5;
699    obj["conditions"] = conditions;
700
701    std::string key = "conditions";
702    std::vector<OnDemandCondition> out;
703    SaProfile saProfile;
704    parser_->GetOnDemandConditionsFromJson(obj, key, out);
705    EXPECT_EQ(out.size(), 5);
706    DTEST_LOG << " GetOnDemandConditionsFromJson003 END" << std::endl;
707}
708
709/**
710 * @tc.name: GetOnDemandConditionsFromJson004
711 * @tc.desc: parse OnDemandConditions, invalid condition.
712 * @tc.type: FUNC
713 * @tc.require: I6JE38
714 */
715HWTEST_F(ParseUtilTest, GetOnDemandConditionsFromJson004, TestSize.Level3)
716{
717    DTEST_LOG << " GetOnDemandConditionsFromJson004 BEGIN" << std::endl;
718    nlohmann::json obj;
719    nlohmann::json conditions;
720    nlohmann::json condition;
721    condition["eventId"] = "mockeventId";
722    condition["name"] = "mockName";
723    condition["value"] = "mockValue";
724    conditions[0] = condition;
725    obj["conditions"] = conditions;
726
727    std::string key = "conditions";
728    std::vector<OnDemandCondition> out;
729    SaProfile saProfile;
730    parser_->GetOnDemandConditionsFromJson(obj, key, out);
731    EXPECT_EQ(out.size(), 0);
732    DTEST_LOG << " GetOnDemandConditionsFromJson004 END" << std::endl;
733}
734
735
736/**
737 * @tc.name: GetOnDemandExtraMessagesFromJson001
738 * @tc.desc: parse OnDemandExtraMessages, ExtraMessages is empty.
739 * @tc.type: FUNC
740 */
741HWTEST_F(ParseUtilTest, GetOnDemandExtraMessagesFromJson001, TestSize.Level3)
742{
743    DTEST_LOG << " GetOnDemandExtraMessagesFromJson001 BEGIN" << std::endl;
744    nlohmann::json obj;
745    std::string key;
746    std::map<std::string, std::string> out;
747    parser_->GetOnDemandExtraMessagesFromJson(obj, key, out);
748    EXPECT_TRUE(out.empty());
749    DTEST_LOG << " GetOnDemandExtraMessagesFromJson001 END" << std::endl;
750}
751
752/**
753 * @tc.name: GetOnDemandExtraMessagesFromJson002
754 * @tc.desc: parse OnDemandExtraMessages, five ExtraMessages.
755 * @tc.type: FUNC
756 */
757HWTEST_F(ParseUtilTest, GetOnDemandExtraMessagesFromJson002, TestSize.Level3)
758{
759    DTEST_LOG << " GetOnDemandExtraMessagesFromJson002 BEGIN" << std::endl;
760    nlohmann::json obj;
761    nlohmann::json extraMessages;
762    extraMessages["eventId"] = SA_TAG_DEVICE_ON_LINE;
763    extraMessages["name"] = "mockName";
764    extraMessages["value"] = "mockValue";
765    extraMessages["123"] = "123";
766    extraMessages["abc"] = "";
767    obj["extra-messages"] = extraMessages;
768    std::string key = "extra-messages";
769    std::map<std::string, std::string> out;
770    parser_->GetOnDemandExtraMessagesFromJson(obj, key, out);
771    EXPECT_EQ(out.size(), 5);
772    DTEST_LOG << " GetOnDemandExtraMessagesFromJson002 END" << std::endl;
773}
774
775/**
776 * @tc.name: GetOnDemandExtraMessagesFromJson003
777 * @tc.desc: parse OnDemandExtraMessages, invalid ExtraMessage.
778 * @tc.type: FUNC
779 */
780HWTEST_F(ParseUtilTest, GetOnDemandExtraMessagesFromJson003, TestSize.Level3)
781{
782    DTEST_LOG << " GetOnDemandExtraMessagesFromJson003 BEGIN" << std::endl;
783    nlohmann::json obj;
784    nlohmann::json extraMessages;
785    extraMessages["123"] = 123;
786    extraMessages["abc"] = 456.7;
787    obj["extra-messages"] = extraMessages;
788    std::string key = "extra-messages";
789    std::map<std::string, std::string> out;
790    parser_->GetOnDemandExtraMessagesFromJson(obj, key, out);
791    EXPECT_EQ(out.size(), 0);
792    DTEST_LOG << " GetOnDemandExtraMessagesFromJson003 END" << std::endl;
793}
794
795
796/**
797 * @tc.name: ParseJsonFile001
798 * @tc.desc: parse json file using big json file
799 * @tc.type: FUNC
800 */
801HWTEST_F(ParseUtilTest, ParseJsonFile001, TestSize.Level3)
802{
803    DTEST_LOG << " ParseJsonFile001 BEGIN" << std::endl;
804    parser_->saProfiles_.clear();
805    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_large.json");
806    EXPECT_EQ(ret, false);
807    DTEST_LOG << " ParseJsonFile001 END" << std::endl;
808}
809
810/**
811 * @tc.name: ParseJsonFile002
812 * @tc.desc: parse json file using too long proces.
813 * @tc.type: FUNC
814 */
815HWTEST_F(ParseUtilTest, ParseJsonFile002, TestSize.Level3)
816{
817    DTEST_LOG << " ParseJsonFile002 BEGIN" << std::endl;
818    parser_->saProfiles_.clear();
819    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_long_process.json");
820    EXPECT_EQ(ret, false);
821    DTEST_LOG << " ParseJsonFile002 END" << std::endl;
822}
823
824/**
825 * @tc.name: ParseJsonFile003
826 * @tc.desc: parse json file using error said.
827 * @tc.type: FUNC
828 */
829HWTEST_F(ParseUtilTest, ParseJsonFile003, TestSize.Level3)
830{
831    DTEST_LOG << " ParseJsonFile003 BEGIN" << std::endl;
832    parser_->saProfiles_.clear();
833    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_error_said.json");
834    EXPECT_EQ(ret, false);
835    DTEST_LOG << " ParseJsonFile003 END" << std::endl;
836}
837
838/**
839 * @tc.name: ParseJsonFile004
840 * @tc.desc: parse json file using too long libpath.
841 * @tc.type: FUNC
842 */
843HWTEST_F(ParseUtilTest, ParseJsonFile004, TestSize.Level3)
844{
845    DTEST_LOG << " ParseJsonFile004 BEGIN" << std::endl;
846    parser_->saProfiles_.clear();
847    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_long_libpath.json");
848    EXPECT_EQ(ret, false);
849    DTEST_LOG << " ParseJsonFile004 END" << std::endl;
850}
851
852/**
853 * @tc.name: ParseJsonFile005
854 * @tc.desc: parse json file using error bootPhase
855 * @tc.type: FUNC
856 */
857HWTEST_F(ParseUtilTest, ParseJsonFile005, TestSize.Level3)
858{
859    DTEST_LOG << " ParseJsonFile005 BEGIN" << std::endl;
860    parser_->saProfiles_.clear();
861    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_error_bootphase.json");
862    EXPECT_EQ(ret, true);
863    DTEST_LOG << " ParseJsonFile005 END" << std::endl;
864}
865
866/**
867 * @tc.name: ParseJsonFile006
868 * @tc.desc: parse json file using error ondemand tag
869 * @tc.type: FUNC
870 */
871HWTEST_F(ParseUtilTest, ParseJsonFile006, TestSize.Level3)
872{
873    DTEST_LOG << " ParseJsonFile006 BEGIN" << std::endl;
874    parser_->saProfiles_.clear();
875    // name or vale is more than 128 bytes
876    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_error_ondemanad_tag.json");
877    EXPECT_EQ(ret, true);
878    SaProfile saProfile;
879    parser_->GetProfile(1401, saProfile);
880    EXPECT_EQ(true, saProfile.startOnDemand.onDemandEvents.empty());
881    EXPECT_EQ(true, saProfile.stopOnDemand.onDemandEvents.empty());
882    DTEST_LOG << " ParseJsonFile006 END" << std::endl;
883}
884
885/**
886 * @tc.name: ParseJsonFile007
887 * @tc.desc: parse json file using correct profile
888 * @tc.type: FUNC
889 */
890HWTEST_F(ParseUtilTest, ParseJsonFile007, TestSize.Level3)
891{
892    DTEST_LOG << " ParseJsonFile007 BEGIN" << std::endl;
893    parser_->saProfiles_.clear();
894    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile.json");
895    EXPECT_EQ(ret, true);
896    EXPECT_EQ(parser_->saProfiles_.empty(), false);
897    SaProfile saProfile1;
898    parser_->GetProfile(1401, saProfile1);
899    EXPECT_EQ(1401, saProfile1.saId);
900    EXPECT_EQ(true, !saProfile1.startOnDemand.onDemandEvents.empty());
901    EXPECT_EQ(1, saProfile1.startOnDemand.onDemandEvents[0].eventId);
902    EXPECT_EQ("deviceonline", saProfile1.startOnDemand.onDemandEvents[0].name);
903    EXPECT_EQ("on", saProfile1.startOnDemand.onDemandEvents[0].value);
904    EXPECT_EQ(true, !saProfile1.stopOnDemand.onDemandEvents.empty());
905    EXPECT_EQ(1, saProfile1.stopOnDemand.onDemandEvents[0].eventId);
906    EXPECT_EQ("deviceonline", saProfile1.stopOnDemand.onDemandEvents[0].name);
907    EXPECT_EQ("off", saProfile1.stopOnDemand.onDemandEvents[0].value);
908    SaProfile saProfile2;
909    parser_->GetProfile(6001, saProfile2);
910    EXPECT_EQ(6001, saProfile2.saId);
911    DTEST_LOG << " ParseJsonFile007 END" << std::endl;
912}
913
914/**
915 * @tc.name: ParseJsonFile008
916 * @tc.desc: parse json file using extension profile
917 * @tc.type: FUNC
918 */
919HWTEST_F(ParseUtilTest, ParseJsonFile008, TestSize.Level3)
920{
921    DTEST_LOG << " ParseJsonFile008 BEGIN" << std::endl;
922    parser_->saProfiles_.clear();
923    bool ret = parser_->ParseSaProfiles(TEST_RESOURCE_PATH + "sa_profile_extension.json");
924    EXPECT_EQ(ret, true);
925    EXPECT_EQ(parser_->saProfiles_.empty(), false);
926    SaProfile saProfile;
927    parser_->GetProfile(9999, saProfile);
928    EXPECT_EQ(9999, saProfile.saId);
929    EXPECT_EQ(saProfile.extension.size(), 2);
930    auto iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), EXTENSIOON_BACKUP);
931    EXPECT_NE(iter, saProfile.extension.end());
932    iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), EXTENSIOON_RESTORE);
933    EXPECT_NE(iter, saProfile.extension.end());
934
935    DTEST_LOG << " ParseJsonFile008 END" << std::endl;
936}
937
938/**
939 * @tc.name: ParseSystemAbility001
940 * @tc.desc: parse sytemability tag with error param.
941 * @tc.type: FUNC
942 */
943HWTEST_F(ParseUtilTest, ParseSystemAbility001, TestSize.Level3)
944{
945    DTEST_LOG << " ParseSystemAbility001 BEGIN" << std::endl;
946    nlohmann::json systemAbilityJson;
947    SaProfile saProfile;
948    bool ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
949    EXPECT_EQ(ret, false);
950    systemAbilityJson["name"] = -1; // invalid said
951    ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
952    EXPECT_EQ(ret, false);
953    systemAbilityJson["name"] = DISTRIBUTED_DEVICE_PROFILE_SA_ID;
954    ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
955    EXPECT_EQ(ret, false);
956    systemAbilityJson["libpath"] = "/system/lib/test.so";
957    ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
958    EXPECT_EQ(ret, true);
959    systemAbilityJson["bootphase"] = "aaa";
960    ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
961    EXPECT_EQ(ret, true);
962
963    int32_t testTime = 9999;
964    systemAbilityJson["stop-on-demand"] = {{"longtimeunused-unload", testTime}, {"unreferenced-unload", true}};
965    ret = parser_->ParseSystemAbility(saProfile, systemAbilityJson);
966    EXPECT_EQ(ret, true);
967    EXPECT_EQ(saProfile.stopOnDemand.unusedTimeout, testTime);
968
969    EXPECT_EQ(saProfile.stopOnDemand.unrefUnload, true);
970
971    DTEST_LOG << " ParseSystemAbility001 END" << std::endl;
972}
973
974/**
975 * @tc.name: JsonObjToMap
976 * @tc.desc: eventJson.contains is nullptr
977 * @tc.type: FUNC
978 * @tc.require: I6MNUA
979 */
980HWTEST_F(ParseUtilTest, JsonObjToMap001, TestSize.Level3)
981{
982    DTEST_LOG << " JsonObjToMap001 BEGIN" << std::endl;
983    nlohmann::json systemAbilityJson;
984    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
985    EXPECT_EQ(res.size(), 3);
986    DTEST_LOG << " JsonObjToMap001 END" << std::endl;
987}
988/**
989 * @tc.name: JsonObjToMap
990 * @tc.desc: eventJson.contains is event_type,evnt_name and event_value
991 * @tc.type: FUNC
992 * @tc.require: I6MNUA
993 */
994HWTEST_F(ParseUtilTest, JsonObjToMap002, TestSize.Level3)
995{
996    DTEST_LOG << " JsonObjToMap002 BEGIN" << std::endl;
997    std::unordered_map<std::string, std::string> strMap;
998    strMap[EVENT_TYPE] = "test";
999    strMap[EVENT_NAME] = "test";
1000    strMap[EVENT_VALUE] = "test";
1001    nlohmann::json systemAbilityJson;
1002    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1003        systemAbilityJson[it->first] = it->second;
1004    }
1005    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1006    EXPECT_EQ(res.size(), 3);
1007    DTEST_LOG << " JsonObjToMap002 END" << std::endl;
1008}
1009/**
1010 * @tc.name: JsonObjToMap
1011 * @tc.desc: eventJson.contains is evnt_name and event_value
1012 * @tc.type: FUNC
1013 * @tc.require: I6MNUA
1014 */
1015HWTEST_F(ParseUtilTest, JsonObjToMap003, TestSize.Level3)
1016{
1017    DTEST_LOG << " JsonObjToMap003 BEGIN" << std::endl;
1018    std::unordered_map<std::string, std::string> strMap;
1019    strMap[EVENT_NAME] = "test";
1020    strMap[EVENT_VALUE] = "test";
1021    nlohmann::json systemAbilityJson;
1022    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1023        systemAbilityJson[it->first] = it->second;
1024    }
1025    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1026    EXPECT_EQ(res.size(), 3);
1027    DTEST_LOG << " JsonObjToMap003 END" << std::endl;
1028}
1029/**
1030 * @tc.name: JsonObjToMap
1031 * @tc.desc: eventJson.contains is event_type and event_value
1032 * @tc.type: FUNC
1033 * @tc.require: I6MNUA
1034 */
1035HWTEST_F(ParseUtilTest, JsonObjToMap004, TestSize.Level3)
1036{
1037    DTEST_LOG << " JsonObjToMap004 BEGIN" << std::endl;
1038    std::unordered_map<std::string, std::string> strMap;
1039    strMap[EVENT_TYPE] = "test";
1040    strMap[EVENT_VALUE] = "test";
1041    nlohmann::json systemAbilityJson;
1042    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1043        systemAbilityJson[it->first] = it->second;
1044    }
1045    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1046    EXPECT_EQ(res.size(), 3);
1047    DTEST_LOG << " JsonObjToMap004 END" << std::endl;
1048}
1049/**
1050 * @tc.name: JsonObjToMap
1051 * @tc.desc: eventJson.contains is event_type and evnt_name
1052 * @tc.type: FUNC
1053 * @tc.require: I6MNUA
1054 */
1055HWTEST_F(ParseUtilTest, JsonObjToMap005, TestSize.Level3)
1056{
1057    DTEST_LOG << " JsonObjToMap005 BEGIN" << std::endl;
1058    std::unordered_map<std::string, std::string> strMap;
1059    strMap[EVENT_TYPE] = "test";
1060    strMap[EVENT_NAME] = "test";
1061    nlohmann::json systemAbilityJson;
1062    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1063        systemAbilityJson[it->first] = it->second;
1064    }
1065    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1066    EXPECT_EQ(res.size(), 3);
1067    DTEST_LOG << " JsonObjToMap005 END" << std::endl;
1068}
1069/**
1070 * @tc.name: JsonObjToMap
1071 * @tc.desc: eventJson.contains is event_type
1072 * @tc.type: FUNC
1073 * @tc.require: I6MNUA
1074 */
1075HWTEST_F(ParseUtilTest, JsonObjToMap006, TestSize.Level3)
1076{
1077    DTEST_LOG << " JsonObjToMap006 BEGIN" << std::endl;
1078    std::unordered_map<std::string, std::string> strMap;
1079    strMap[EVENT_TYPE] = "test";
1080    nlohmann::json systemAbilityJson;
1081    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1082        systemAbilityJson[it->first] = it->second;
1083    }
1084    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1085    EXPECT_EQ(res.size(), 3);
1086    DTEST_LOG << " JsonObjToMap006 END" << std::endl;
1087}
1088/**
1089 * @tc.name: JsonObjToMap
1090 * @tc.desc: eventJson.contains is event_name
1091 * @tc.type: FUNC
1092 * @tc.require: I6MNUA
1093 */
1094HWTEST_F(ParseUtilTest, JsonObjToMap007, TestSize.Level3)
1095{
1096    DTEST_LOG << " JsonObjToMap007 BEGIN" << std::endl;
1097    std::unordered_map<std::string, std::string> strMap;
1098    strMap[EVENT_NAME] = "test";
1099    nlohmann::json systemAbilityJson;
1100    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1101        systemAbilityJson[it->first] = it->second;
1102    }
1103    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1104    EXPECT_EQ(res.size(), 3);
1105    DTEST_LOG << " JsonObjToMap007 END" << std::endl;
1106}
1107/**
1108 * @tc.name: JsonObjToMap
1109 * @tc.desc: eventJson.contains is event_value
1110 * @tc.type: FUNC
1111 * @tc.require: I6MNUA
1112 */
1113HWTEST_F(ParseUtilTest, JsonObjToMap008, TestSize.Level3)
1114{
1115    DTEST_LOG << " JsonObjToMap008 BEGIN" << std::endl;
1116    std::unordered_map<std::string, std::string> strMap;
1117    strMap[EVENT_VALUE] = "test";
1118    nlohmann::json systemAbilityJson;
1119    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1120        systemAbilityJson[it->first] = it->second;
1121    }
1122    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1123    EXPECT_EQ(res.size(), 3);
1124    DTEST_LOG << " JsonObjToMap008 END" << std::endl;
1125}
1126/**
1127 * @tc.name: JsonObjToMap
1128 * @tc.desc: eventJson.contains is event_type,evnt_name and event_value;eventJson.is_string is false
1129 * @tc.type: FUNC
1130 * @tc.require: I6MNUA
1131 */
1132HWTEST_F(ParseUtilTest, JsonObjToMap009, TestSize.Level3)
1133{
1134    DTEST_LOG << " JsonObjToMap009 BEGIN" << std::endl;
1135    std::unordered_map<std::string, int> strMap;
1136    strMap[EVENT_TYPE] = TEST_NUM;
1137    strMap[EVENT_NAME] = TEST_NUM;
1138    strMap[EVENT_VALUE] = TEST_NUM;
1139    nlohmann::json systemAbilityJson;
1140    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1141        systemAbilityJson[it->first] = it->second;
1142    }
1143    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1144    EXPECT_EQ(res.size(), 3);
1145    DTEST_LOG << " JsonObjToMap009 END" << std::endl;
1146}
1147/**
1148 * @tc.name: JsonObjToMap
1149 * @tc.desc: eventJson.contains is evnt_name and event_value;eventJson.is_string is false
1150 * @tc.type: FUNC
1151 * @tc.require: I6MNUA
1152 */
1153HWTEST_F(ParseUtilTest, JsonObjToMap010, TestSize.Level3)
1154{
1155    DTEST_LOG << " JsonObjToMap010 BEGIN" << std::endl;
1156    std::unordered_map<std::string, int> strMap;
1157    strMap[EVENT_NAME] = TEST_NUM;
1158    strMap[EVENT_VALUE] = TEST_NUM;
1159    nlohmann::json systemAbilityJson;
1160    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1161        systemAbilityJson[it->first] = it->second;
1162    }
1163    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1164    EXPECT_EQ(res.size(), 3);
1165    DTEST_LOG << " JsonObjToMap010 END" << std::endl;
1166}
1167/**
1168 * @tc.name: JsonObjToMap
1169 * @tc.desc: eventJson.contains is event_value;eventJson.is_string is false
1170 * @tc.type: FUNC
1171 * @tc.require: I6MNUA
1172 */
1173HWTEST_F(ParseUtilTest, JsonObjToMap011, TestSize.Level3)
1174{
1175    DTEST_LOG << " JsonObjToMap011 BEGIN" << std::endl;
1176    std::unordered_map<std::string, int> strMap;
1177    strMap[EVENT_VALUE] = TEST_NUM;
1178    nlohmann::json systemAbilityJson;
1179    for (auto it = strMap.begin(); it != strMap.end(); it++) {
1180        systemAbilityJson[it->first] = it->second;
1181    }
1182    std::unordered_map<std::string, std::string> res = parser_->JsonObjToMap(systemAbilityJson);
1183    EXPECT_EQ(res.size(), 3);
1184    DTEST_LOG << " JsonObjToMap011 END" << std::endl;
1185}
1186
1187/**
1188 * @tc.name: StringToMap001
1189 * @tc.desc: test StringToMap with empty string
1190 * @tc.type: FUNC
1191 * @tc.require: I6YJH6
1192 */
1193HWTEST_F(ParseUtilTest, StringtoMap001, TestSize.Level3)
1194{
1195    unordered_map<std::string, std::string> ret = parser_->StringToMap(EVENT_STRING);
1196    EXPECT_FALSE(ret.empty());
1197}
1198
1199/**
1200 * @tc.name: CloseHandle001
1201 * @tc.desc: test CloseHandle with nullptr
1202 * @tc.type: FUNC
1203 * @tc.require: I7G775
1204 */
1205HWTEST_F(ParseUtilTest, CloseHandle001, TestSize.Level3)
1206{
1207    SaProfile saProfile;
1208    parser_->CloseHandle(saProfile);
1209    EXPECT_EQ(saProfile.handle, nullptr);
1210}
1211
1212/**
1213 * @tc.name: CheckLogicRelationship001
1214 * @tc.desc: test CheckLogicRelationship
1215 * @tc.type: FUNC
1216 */
1217HWTEST_F(ParseUtilTest, CheckLogicRelationship001, TestSize.Level3)
1218{
1219    bool ret;
1220    ret = parser_->CheckLogicRelationship("1", "");
1221    EXPECT_EQ(ret, true);
1222    ret = parser_->CheckLogicRelationship("1", "1");
1223    EXPECT_EQ(ret, true);
1224    ret = parser_->CheckLogicRelationship("", "1");
1225    EXPECT_EQ(ret, false);
1226    ret = parser_->CheckLogicRelationship("1", ">1");
1227    EXPECT_EQ(ret, false);
1228    ret = parser_->CheckLogicRelationship("2", ">1");
1229    EXPECT_EQ(ret, true);
1230    ret = parser_->CheckLogicRelationship("1", ">=1");
1231    EXPECT_EQ(ret, true);
1232    ret = parser_->CheckLogicRelationship("1", "<1");
1233    EXPECT_EQ(ret, false);
1234    ret = parser_->CheckLogicRelationship("0", "<1");
1235    EXPECT_EQ(ret, true);
1236    ret = parser_->CheckLogicRelationship("1", "<=1");
1237    EXPECT_EQ(ret, true);
1238    ret = parser_->CheckLogicRelationship("1", ">=abc");
1239    EXPECT_EQ(ret, false);
1240    ret = parser_->CheckLogicRelationship("abc", ">=1");
1241    EXPECT_EQ(ret, false);
1242}
1243
1244/**
1245 * @tc.name: ParseSystemAbilityGetExtension001
1246 * @tc.desc: parse sytemability extension tag
1247 * @tc.type: FUNC
1248 */
1249HWTEST_F(ParseUtilTest, ParseSystemAbilityGetExtension001, TestSize.Level3)
1250{
1251    DTEST_LOG << " ParseSystemAbilityGetExtension001 BEGIN" << std::endl;
1252    nlohmann::json systemAbilityJson;
1253    SaProfile saProfile;
1254    bool ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1255    EXPECT_EQ(ret, true);
1256    systemAbilityJson["extension"] = nlohmann::json::array();
1257    systemAbilityJson["extension"].push_back(EXTENSIOON_BACKUP);
1258    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1259    EXPECT_EQ(ret, true);
1260    EXPECT_EQ(saProfile.extension.size(), 1);
1261    auto iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), EXTENSIOON_BACKUP);
1262    EXPECT_NE(iter, saProfile.extension.end());
1263
1264    systemAbilityJson["extension"].push_back(EXTENSIOON_RESTORE);
1265    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1266    EXPECT_EQ(ret, true);
1267    EXPECT_EQ(saProfile.extension.size(), 2);
1268    iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), EXTENSIOON_RESTORE);
1269    EXPECT_NE(iter, saProfile.extension.end());
1270
1271    systemAbilityJson["extension"].push_back(EXTENSIOON_BACKUP);
1272    systemAbilityJson["extension"].push_back(EXTENSIOON_RESTORE);
1273
1274    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1275    EXPECT_EQ(ret, true);
1276    EXPECT_EQ(saProfile.extension.size(), 2);
1277
1278    DTEST_LOG << " ParseSystemAbilityGetExtension001 END" << std::endl;
1279}
1280
1281/**
1282 * @tc.name: ParseSystemAbilityGetExtension002
1283 * @tc.desc: parse sytemability extension string length test
1284 * @tc.type: FUNC
1285 */
1286HWTEST_F(ParseUtilTest, ParseSystemAbilityGetExtension002, TestSize.Level3)
1287{
1288    DTEST_LOG << " ParseSystemAbilityGetExtension002 BEGIN" << std::endl;
1289    nlohmann::json systemAbilityJson;
1290    SaProfile saProfile;
1291    systemAbilityJson["extension"] = nlohmann::json::array();
1292
1293    char ch = 'a';
1294    std::string aExceedstr(MAX_JSON_STRING_LENGTH + 1, ch);
1295    systemAbilityJson["extension"].push_back(aExceedstr);
1296    bool ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1297    EXPECT_EQ(ret, false);
1298    EXPECT_EQ(saProfile.extension.size(), 0);
1299
1300    systemAbilityJson["extension"].clear();
1301
1302    ch = 'a';
1303    std::string astr(MAX_JSON_STRING_LENGTH, ch);
1304    systemAbilityJson["extension"].push_back(astr);
1305    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1306    EXPECT_EQ(ret, true);
1307    EXPECT_EQ(saProfile.extension.size(), 1);
1308    auto iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), astr);
1309    EXPECT_NE(iter, saProfile.extension.end());
1310
1311    ch = 'b';
1312    std::string bstr(MAX_JSON_STRING_LENGTH - 1, ch);
1313    systemAbilityJson["extension"].push_back(bstr);
1314    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1315    EXPECT_EQ(ret, true);
1316    EXPECT_EQ(saProfile.extension.size(), 2);
1317    iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), bstr);
1318    EXPECT_NE(iter, saProfile.extension.end());
1319
1320    DTEST_LOG << " ParseSystemAbilityGetExtension002 END" << std::endl;
1321}
1322
1323/**
1324 * @tc.name: ParseSystemAbilityGetExtension002
1325 * @tc.desc: parse sytemability extension string num test
1326 * @tc.type: FUNC
1327 */
1328HWTEST_F(ParseUtilTest, ParseSystemAbilityGetExtension003, TestSize.Level3)
1329{
1330    DTEST_LOG << " ParseSystemAbilityGetExtension003 BEGIN" << std::endl;
1331    nlohmann::json systemAbilityJson;
1332    SaProfile saProfile;
1333    systemAbilityJson["extension"] = nlohmann::json::array();
1334
1335    bool ret;
1336    char ch = 0;
1337    for (int32_t loop = 0; loop < MAX_EXTENSIONO_NUM; ++loop) {
1338        std::string str(MAX_JSON_STRING_LENGTH, ch + loop);
1339        systemAbilityJson["extension"].push_back(str);
1340        ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1341        EXPECT_EQ(ret, true);
1342        EXPECT_EQ(saProfile.extension.size(), loop + 1);
1343        auto iter = std::find(saProfile.extension.begin(), saProfile.extension.end(), str);
1344        EXPECT_NE(iter, saProfile.extension.end());
1345    }
1346
1347    std::string str(MAX_JSON_STRING_LENGTH, ch + MAX_EXTENSIONO_NUM);
1348    systemAbilityJson["extension"].push_back(str);
1349    ret = parser_->ParseSystemAbilityGetExtension(saProfile, systemAbilityJson);
1350    EXPECT_EQ(ret, false);
1351    EXPECT_EQ(saProfile.extension.size(), MAX_EXTENSIONO_NUM);
1352
1353    DTEST_LOG << " ParseSystemAbilityGetExtension003 END" << std::endl;
1354}
1355
1356/**
1357 * @tc.name: GetOndemandPriorityPara001
1358 * @tc.desc: GetOndemandPriorityPara
1359 * @tc.type: FUNC
1360 */
1361HWTEST_F(ParseUtilTest, GetOndemandPriorityPara001, TestSize.Level3)
1362{
1363    DTEST_LOG << " GetOndemandPriorityPara001 BEGIN" << std::endl;
1364    std::string loadPriority = "HighPriority";
1365    uint32_t ret = parser_->GetOndemandPriorityPara(loadPriority);
1366    EXPECT_EQ(ret, static_cast<uint32_t>(HIGH_PRIORITY));
1367
1368    loadPriority = "MediumPriority";
1369    ret = parser_->GetOndemandPriorityPara(loadPriority);
1370    EXPECT_EQ(ret, static_cast<uint32_t>(MEDIUM_PRIORITY));
1371
1372    loadPriority = "NEW_TEST";
1373    ret = parser_->GetOndemandPriorityPara(loadPriority);
1374    EXPECT_EQ(ret, static_cast<uint32_t>(LOW_PRIORITY));
1375}
1376
1377} // namespace SAMGR
1378} // namespace OHOS
1379