1/*
2 * Copyright (c) 2021-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
16#include <gtest/gtest.h>
17
18#define private public
19#define protected public
20#include "bool_wrapper.h"
21#include "int_wrapper.h"
22#include "long_wrapper.h"
23#include "refbase.h"
24#include "skills.h"
25#include "string_wrapper.h"
26#undef private
27#undef protected
28#include "patterns_matcher.h"
29
30using namespace testing::ext;
31using namespace OHOS::AAFwk;
32using OHOS::Parcel;
33
34namespace OHOS {
35namespace AAFwk {
36static const int LARGE_STR_LEN = 65534;
37static const int SET_COUNT = 20;
38static const int DISMATCH_TYPE = 67584;
39static const int DISMATCH_DATA = -102;
40class SkillsBaseTest : public testing::Test {
41public:
42    SkillsBaseTest()
43    {}
44    ~SkillsBaseTest()
45    {}
46    static void SetUpTestCase(void);
47    static void TearDownTestCase(void);
48    void SetUp();
49    void TearDown();
50
51    std::shared_ptr<Skills> base_ = nullptr;
52    std::shared_ptr<PatternsMatcher> PatternsMatcherIn_ = nullptr;
53    void CompareSkills(const std::shared_ptr<Skills> &skills1, const std::shared_ptr<Skills> &skills2) const;
54};
55
56void SkillsBaseTest::SetUpTestCase(void)
57{}
58
59void SkillsBaseTest::TearDownTestCase(void)
60{}
61
62void SkillsBaseTest::SetUp(void)
63{
64    base_ = std::make_shared<Skills>();
65    PatternsMatcherIn_ = std::make_shared<PatternsMatcher>();
66}
67
68void SkillsBaseTest::TearDown(void)
69{}
70
71/**
72 * @tc.number: AaFwk_Skills_Parcelable_0100
73 * @tc.name: Marshalling/Unmarshalling
74 * @tc.desc: marshalling Skills, and then check result.
75 */
76HWTEST_F(SkillsBaseTest, AaFwk_Skills_Parcelable_0100, Function | MediumTest | Level1)
77{
78    std::shared_ptr<Skills> SkillsIn_ = std::make_shared<Skills>();
79    if (SkillsIn_ == nullptr) {
80        return;
81    }
82    SkillsIn_->AddEntity("12345");
83    SkillsIn_->AddAction("12345");
84    SkillsIn_->AddAuthority("12345");
85    SkillsIn_->AddScheme("12345");
86    SkillsIn_->AddPath("12345");
87    SkillsIn_->AddSchemeSpecificPart("12345");
88    SkillsIn_->AddType("12345");
89    WantParams wantParams;
90    std::string keyStr = "12345667";
91    bool valueBool = true;
92    wantParams.SetParam(keyStr, Boolean::Box(valueBool));
93    SkillsIn_->SetWantParams(wantParams);
94
95    Parcel in;
96    std::shared_ptr<Skills> SkillsOut_(Skills::Unmarshalling(in));
97    SkillsIn_->Marshalling(in);
98    if (SkillsOut_ != nullptr) {
99        CompareSkills(SkillsIn_, SkillsOut_);
100        EXPECT_EQ(valueBool, Boolean::Unbox(IBoolean::Query(SkillsOut_->GetWantParams().GetParam(keyStr))));
101    }
102}
103
104/**
105 * @tc.number: AaFwk_Skills_Parcelable_0200
106 * @tc.name: Marshalling/Unmarshalling
107 * @tc.desc: marshalling Skills, and then check result.
108 */
109HWTEST_F(SkillsBaseTest, AaFwk_Skills_Parcelable_0200, Function | MediumTest | Level1)
110{
111    std::shared_ptr<Skills> SkillsIn_ = std::make_shared<Skills>();
112    if (SkillsIn_ == nullptr) {
113        return;
114    }
115
116    SkillsIn_->AddEntity("@#￥#3243adsafdf_中文");
117    SkillsIn_->AddAction("@#￥#3243adsafdf_中文");
118    SkillsIn_->AddAuthority("@#￥#3243adsafdf_中文");
119    SkillsIn_->AddScheme("@#￥#3243adsafdf_中文");
120    SkillsIn_->AddPath("@#￥#3243adsafdf_中文");
121    SkillsIn_->AddSchemeSpecificPart("@#￥#3243adsafdf_中文");
122    SkillsIn_->AddType("@#￥#3243adsafdf_中文");
123    WantParams wantParams;
124    std::string keyStr = "@#￥#3243adsafdf_中文";
125    long valueLong = 12345L;
126    wantParams.SetParam(keyStr, Long::Box(valueLong));
127    EXPECT_EQ(valueLong, Long::Unbox(ILong::Query(wantParams.GetParam(keyStr))));
128
129    SkillsIn_->SetWantParams(wantParams);
130
131    Parcel in;
132    SkillsIn_->Marshalling(in);
133    std::shared_ptr<Skills> SkillsOut_(Skills::Unmarshalling(in));
134
135    if (SkillsOut_ != nullptr) {
136        CompareSkills(SkillsIn_, SkillsOut_);
137        long result = Long::Unbox(ILong::Query(SkillsOut_->GetWantParams().GetParam(keyStr)));
138        EXPECT_EQ(valueLong, result);
139    }
140}
141
142/**
143 * @tc.number: AaFwk_Skills_Parcelable_0300
144 * @tc.name: Marshalling/Unmarshalling
145 * @tc.desc: marshalling Skills, and then check result.
146 */
147HWTEST_F(SkillsBaseTest, AaFwk_Skills_Parcelable_0300, Function | MediumTest | Level1)
148{
149    std::shared_ptr<Skills> SkillsIn_ = std::make_shared<Skills>();
150    if (SkillsIn_ == nullptr) {
151        return;
152    }
153
154    SkillsIn_->AddEntity("");
155    SkillsIn_->AddAction("");
156    SkillsIn_->AddAuthority("");
157    SkillsIn_->AddScheme("");
158    SkillsIn_->AddPath("");
159    SkillsIn_->AddSchemeSpecificPart("");
160    SkillsIn_->AddType("");
161    WantParams wantParams;
162    std::string keyStr = "";
163    int valueInt = 123;
164    wantParams.SetParam(keyStr, Integer::Box(valueInt));
165
166    SkillsIn_->SetWantParams(wantParams);
167    EXPECT_EQ(valueInt, Integer::Unbox(IInteger::Query(wantParams.GetParam(keyStr))));
168
169    Parcel in;
170    SkillsIn_->Marshalling(in);
171    std::shared_ptr<Skills> SkillsOut_(Skills::Unmarshalling(in));
172
173    if (SkillsOut_ != nullptr) {
174        CompareSkills(SkillsIn_, SkillsOut_);
175        EXPECT_EQ(valueInt, Integer::Unbox(IInteger::Query(SkillsOut_->GetWantParams().GetParam(keyStr))));
176    }
177}
178
179/**
180 * @tc.number: AaFwk_Skills_Parcelable_0400
181 * @tc.name: Marshalling/Unmarshalling
182 * @tc.desc: marshalling Skills, and then check result.
183 */
184HWTEST_F(SkillsBaseTest, AaFwk_Skills_Parcelable_0400, Function | MediumTest | Level1)
185{
186    std::shared_ptr<Skills> SkillsIn_ = std::make_shared<Skills>();
187    if (SkillsIn_ == nullptr) {
188        return;
189    }
190    SkillsIn_->AddEntity("12345");
191    SkillsIn_->AddAction("12345");
192    SkillsIn_->AddAuthority("12345");
193    SkillsIn_->AddScheme("12345");
194    SkillsIn_->AddPath("12345");
195    SkillsIn_->AddSchemeSpecificPart("12345");
196    SkillsIn_->AddType("12345");
197    SkillsIn_->AddEntity("@#￥#3243adsafdf_中文");
198    SkillsIn_->AddAction("@#￥#3243adsafdf_中文");
199    SkillsIn_->AddAuthority("@#￥#3243adsafdf_中文");
200    SkillsIn_->AddScheme("@#￥#3243adsafdf_中文");
201    SkillsIn_->AddPath("@#￥#3243adsafdf_中文");
202    SkillsIn_->AddSchemeSpecificPart("@#￥#3243adsafdf_中文");
203    SkillsIn_->AddType("@#￥#3243adsafdf_中文");
204    SkillsIn_->AddEntity("");
205    SkillsIn_->AddAction("");
206    SkillsIn_->AddAuthority("");
207    SkillsIn_->AddScheme("");
208    SkillsIn_->AddPath("");
209    SkillsIn_->AddSchemeSpecificPart("");
210    SkillsIn_->AddType("");
211    WantParams wantParams;
212    std::string keyStr = "12345667";
213    std::string valueString = "123";
214    wantParams.SetParam(keyStr, String::Box(valueString));
215    SkillsIn_->SetWantParams(wantParams);
216
217    Parcel in;
218    SkillsIn_->Marshalling(in);
219    std::shared_ptr<Skills> SkillsOut_(Skills::Unmarshalling(in));
220
221    if (SkillsOut_ != nullptr) {
222        CompareSkills(SkillsIn_, SkillsOut_);
223        EXPECT_EQ(valueString, String::Unbox(IString::Query(SkillsOut_->GetWantParams().GetParam(keyStr))));
224    }
225}
226
227void SkillsBaseTest::CompareSkills(const std::shared_ptr<Skills> &skills1, const std::shared_ptr<Skills> &skills2) const
228{
229    EXPECT_EQ(skills1->CountEntities(), skills2->CountEntities());
230    EXPECT_EQ(skills1->CountActions(), skills2->CountActions());
231    EXPECT_EQ(skills1->CountAuthorities(), skills2->CountAuthorities());
232    EXPECT_EQ(skills1->CountSchemes(), skills2->CountSchemes());
233    EXPECT_EQ(skills1->CountPaths(), skills2->CountPaths());
234    EXPECT_EQ(skills1->CountSchemeSpecificParts(), skills2->CountSchemeSpecificParts());
235    EXPECT_EQ(skills1->CountTypes(), skills2->CountTypes());
236
237    int count = skills1->CountEntities();
238    for (int i = 0; i < count; i++) {
239        EXPECT_EQ(skills1->GetEntity(i), skills1->GetEntity(i));
240    }
241    count = skills1->CountActions();
242    for (int i = 0; i < count; i++) {
243        EXPECT_EQ(skills1->GetAction(i), skills1->GetAction(i));
244    }
245    count = skills1->CountAuthorities();
246    for (int i = 0; i < count; i++) {
247        EXPECT_EQ(skills1->GetAuthority(i), skills1->GetAuthority(i));
248    }
249    count = skills1->CountSchemes();
250    for (int i = 0; i < count; i++) {
251        EXPECT_EQ(skills1->GetScheme(i), skills1->GetScheme(i));
252    }
253    count = skills1->CountPaths();
254    for (int i = 0; i < count; i++) {
255        EXPECT_EQ(skills1->GetPath(i), skills1->GetPath(i));
256    }
257    count = skills1->CountSchemeSpecificParts();
258    for (int i = 0; i < count; i++) {
259        EXPECT_EQ(skills1->GetSchemeSpecificPart(i), skills1->GetSchemeSpecificPart(i));
260    }
261    count = skills1->CountTypes();
262    for (int i = 0; i < count; i++) {
263        EXPECT_EQ(skills1->GetType(i), skills1->GetType(i));
264    }
265
266    std::set<std::string> key1;
267    std::set<std::string> key2;
268    key1 = skills1->GetWantParams().KeySet();
269    key2 = skills2->GetWantParams().KeySet();
270    EXPECT_EQ(key1.size(), key2.size());
271
272    if (key1.size() > 0 && key2.size() > 0) {
273        std::set<std::string>::iterator iter1 = key1.begin();
274        std::set<std::string>::iterator iter2 = key2.begin();
275        for (; (iter1 != key1.end() && iter2 != key2.end()); iter1++, iter2++) {
276            EXPECT_EQ(*iter1, *iter2);
277        }
278    }
279}
280
281/**
282 * @tc.number: AaFwk_Skills_Entities_0100
283 * @tc.name: CountEntitie/HasEntity/GetEntity
284 * @tc.desc: Verify the function when the input string contains special characters.
285 */
286HWTEST_F(SkillsBaseTest, AaFwk_Skills_Entities_0100, Function | MediumTest | Level1)
287{
288    std::string empty;
289    std::string entities = "entities.system.test";
290    EXPECT_EQ(0, base_->CountEntities());
291    EXPECT_EQ(false, base_->HasEntity(entities));
292    EXPECT_EQ(empty, base_->GetEntity(0));
293
294    base_->RemoveEntity(entities);
295    EXPECT_EQ(0, base_->CountEntities());
296    EXPECT_EQ(false, base_->HasEntity(entities));
297}
298/**
299 * @tc.number: AaFwk_Skills_GetEntities_0100
300 * @tc.name: AddEntity and GetEntities
301 * @tc.desc: Verify AddEntity and GetEntities.
302 */
303HWTEST_F(SkillsBaseTest, AaFwk_Skills_GetEntities_0100, Function | MediumTest | Level1)
304{
305    std::string entity = "12345667";
306    base_->AddEntity(entity);
307
308    size_t length = base_->GetEntities().size();
309
310    EXPECT_EQ((size_t)1, length);
311    EXPECT_EQ(entity, base_->GetEntities().at(0));
312}
313
314/**
315 * @tc.number: AaFwk_Skills_Authorities_0100
316 * @tc.name: CountEntitie/HasEntity/GetEntity
317 * @tc.desc: Verify the function when the input string has a long size.
318 */
319HWTEST_F(SkillsBaseTest, AaFwk_Skills_Authorities_0100, Function | MediumTest | Level1)
320{
321    std::string empty;
322    std::string authorities = "authorities.system.test";
323    EXPECT_EQ(0, base_->CountAuthorities());
324    EXPECT_EQ(false, base_->HasAuthority(authorities));
325    EXPECT_EQ(empty, base_->GetAuthority(0));
326
327    base_->RemoveAuthority(authorities);
328    EXPECT_EQ(0, base_->CountAuthorities());
329    EXPECT_EQ(false, base_->HasAuthority(authorities));
330}
331
332/**
333 * @tc.number: AaFwk_Skills_Path_0300
334 * @tc.name: CountPaths/HasPath/GetPath
335 * @tc.desc: Verify the function when the input string is overrided.
336 */
337HWTEST_F(SkillsBaseTest, AaFwk_Skills_Path_0300, Function | MediumTest | Level1)
338{
339    std::string empty;
340    std::string path = "paths.system.test";
341    PatternsMatcher pm(path, MatchType::DEFAULT);
342    base_->AddPath(pm);
343
344    EXPECT_EQ(1, base_->CountPaths());
345    EXPECT_EQ(true, base_->HasPath(path));
346    EXPECT_EQ(path, base_->GetPath(0));
347
348    base_->RemovePath(pm);
349    EXPECT_EQ(0, base_->CountPaths());
350    EXPECT_EQ(false, base_->HasPath(path));
351
352    Parcel parcel;
353    EXPECT_EQ(true, base_->Marshalling(parcel));
354}
355
356/**
357 * @tc.number: AaFwk_Skills_Action_0100
358 * @tc.name: AddAction/CountActions/HasAction/GetAction
359 * @tc.desc: Verify the function when the input string is set 20 times.
360 */
361HWTEST_F(SkillsBaseTest, AaFwk_Skills_Action_0100, Function | MediumTest | Level1)
362{
363    std::string empty;
364    std::string action = "action.system.test";
365    int actionCount = 1;
366
367    for (int i = 0; i < SET_COUNT; i++) {
368        base_->AddAction(action);
369    }
370
371    EXPECT_EQ(actionCount, base_->CountActions());
372    EXPECT_EQ(true, base_->HasAction(action));
373    EXPECT_EQ(action, base_->GetAction(0));
374
375    base_->RemoveAction(action);
376    EXPECT_EQ(0, base_->CountActions());
377    EXPECT_EQ(false, base_->HasAction(action));
378}
379
380/**
381 * @tc.number: AaFwk_Skills_ActionsIterator_0100
382 * @tc.name: ActionsIterator
383 * @tc.desc: Test the function of ActionsIterator.
384 */
385HWTEST_F(SkillsBaseTest, AaFwk_Skills_ActionsIterator_0100, Function | MediumTest | Level1)
386{
387    base_->actions_.push_back("a");
388    base_->actions_.push_back("b");
389    auto iter = base_->ActionsIterator();
390    EXPECT_EQ(*iter, "a");
391}
392
393/**
394 * @tc.number: AaFwk_Skills_Entity_0100
395 * @tc.name: CountEntities/HasEntity/CountEntities/GetEntity
396 * @tc.desc: Verify the function when the input string is default.
397 */
398HWTEST_F(SkillsBaseTest, AaFwk_Skills_Entity_0100, Function | MediumTest | Level1)
399{
400    std::string empty;
401    std::string entity = "entity.system.test";
402    int entityCount = 1;
403
404    for (int i = 0; i < SET_COUNT; i++) {
405        base_->AddEntity(entity);
406    }
407
408    EXPECT_EQ(entityCount, base_->CountEntities());
409    EXPECT_EQ(true, base_->HasEntity(entity));
410    EXPECT_EQ(entity, base_->GetEntity(0));
411
412    base_->RemoveEntity(entity);
413    EXPECT_EQ(0, base_->CountEntities());
414    EXPECT_EQ(false, base_->HasEntity(entity));
415}
416
417/**
418 * @tc.number: AaFwk_Skills_Authority_0100
419 * @tc.name: CountAuthorities/HasAuthority/GetAuthority
420 * @tc.desc: Verify the function when the input string contains special characters.
421 */
422HWTEST_F(SkillsBaseTest, AaFwk_Skills_Authority_0100, Function | MediumTest | Level1)
423{
424    std::string empty;
425    std::string authority = "Authority.system.test";
426    int authorityCount = 1;
427
428    for (int i = 0; i < SET_COUNT; i++) {
429        base_->AddAuthority(authority);
430    }
431
432    EXPECT_EQ(authorityCount, base_->CountAuthorities());
433    EXPECT_EQ(true, base_->HasAuthority(authority));
434    EXPECT_EQ(authority, base_->GetAuthority(0));
435
436    base_->RemoveAuthority(authority);
437    EXPECT_EQ(0, base_->CountAuthorities());
438    EXPECT_EQ(false, base_->HasAuthority(authority));
439}
440
441/**
442 * @tc.number: AaFwk_Skills_Path_0100
443 * @tc.name: CountPaths/HasPath/GetPath
444 * @tc.desc: Verify the function when the input string contains special characters.
445 */
446HWTEST_F(SkillsBaseTest, AaFwk_Skills_Path_0100, Function | MediumTest | Level1)
447{
448    std::string empty;
449    std::string path = "Path.system.test";
450    int pathCount = 1;
451
452    for (int i = 0; i < SET_COUNT; i++) {
453        base_->AddPath(path);
454    }
455
456    EXPECT_EQ(pathCount, base_->CountPaths());
457    EXPECT_EQ(true, base_->HasPath(path));
458    EXPECT_EQ(path, base_->GetPath(0));
459
460    base_->RemovePath(path);
461    EXPECT_EQ(0, base_->CountPaths());
462    EXPECT_EQ(false, base_->HasPath(path));
463}
464
465/**
466 * @tc.number: AaFwk_Skills_Scheme_0100
467 * @tc.name: CountSchemes/HasScheme/GetScheme
468 * @tc.desc: Verify the function when the input string contains special characters.
469 */
470HWTEST_F(SkillsBaseTest, AaFwk_Skills_Scheme_0100, Function | MediumTest | Level1)
471{
472    std::string empty;
473    std::string scheme = "scheme.system.test";
474    int schemeCount = 1;
475
476    for (int i = 0; i < SET_COUNT; i++) {
477        base_->AddScheme(scheme);
478    }
479
480    EXPECT_EQ(schemeCount, base_->CountSchemes());
481    EXPECT_EQ(true, base_->HasScheme(scheme));
482    EXPECT_EQ(scheme, base_->GetScheme(0));
483
484    base_->RemoveScheme(scheme);
485    EXPECT_EQ(0, base_->CountSchemes());
486    EXPECT_EQ(false, base_->HasScheme(scheme));
487}
488
489/**
490 * @tc.number: AaFwk_Skills_SchemeSpecificPart_0100
491 * @tc.name: CountSchemeSpecificParts/HasSchemeSpecificPart/GetSchemeSpecificPart
492 * @tc.desc: Verify the function when the input string contains special characters.
493 */
494HWTEST_F(SkillsBaseTest, AaFwk_Skills_SchemeSpecificPart_0100, Function | MediumTest | Level1)
495{
496    std::string empty;
497    std::string schemespecificpart = "schemespecificpart.system.test";
498    int schemespecificpartCount = 1;
499
500    for (int i = 0; i < SET_COUNT; i++) {
501        base_->AddSchemeSpecificPart(schemespecificpart);
502    }
503
504    EXPECT_EQ(schemespecificpartCount, base_->CountSchemeSpecificParts());
505    EXPECT_EQ(true, base_->HasSchemeSpecificPart(schemespecificpart));
506    EXPECT_EQ(schemespecificpart, base_->GetSchemeSpecificPart(0));
507
508    base_->RemoveSchemeSpecificPart(schemespecificpart);
509    EXPECT_EQ(0, base_->CountSchemeSpecificParts());
510    EXPECT_EQ(false, base_->HasSchemeSpecificPart(schemespecificpart));
511}
512
513/**
514 * @tc.number: AaFwk_Skills_Type_0100
515 * @tc.name: CountTypes/HasType/GetType
516 * @tc.desc: Verify the function when the input string contains special characters.
517 */
518HWTEST_F(SkillsBaseTest, AaFwk_Skills_Type_0100, Function | MediumTest | Level1)
519{
520    std::string empty;
521    std::string type = "type/system.test";
522    int typeCount = 1;
523
524    for (int i = 0; i < SET_COUNT; i++) {
525        base_->AddType(type);
526    }
527
528    EXPECT_EQ(typeCount, base_->CountTypes());
529    EXPECT_EQ(true, base_->HasType(type));
530    EXPECT_EQ(type, base_->GetType(0));
531
532    base_->RemoveType(type);
533    EXPECT_EQ(0, base_->CountTypes());
534    EXPECT_EQ(false, base_->HasType(type));
535}
536
537/**
538 * @tc.number: AaFwk_Skills_Actions_0100
539 * @tc.name: CountActions/HasAuthority/GetAuthority
540 * @tc.desc: Verify the function when the input string contains special characters.
541 */
542HWTEST_F(SkillsBaseTest, AaFwk_Skills_Actions_0100, Function | MediumTest | Level1)
543{
544    std::string empty;
545    std::string actions = "actions.system.test";
546    EXPECT_EQ(0, base_->CountActions());
547    EXPECT_EQ(false, base_->HasAuthority(actions));
548    EXPECT_EQ(empty, base_->GetAuthority(0));
549
550    base_->RemoveAuthority(actions);
551    EXPECT_EQ(0, base_->CountActions());
552    EXPECT_EQ(false, base_->HasAuthority(actions));
553}
554
555/**
556 * @tc.number: AaFwk_Skills_Schemes_0100
557 * @tc.name: CountSchemes/HasAuthority/GetAuthority
558 * @tc.desc: Verify the function when the input string contains special characters.
559 */
560HWTEST_F(SkillsBaseTest, AaFwk_Skills_Schemes_0100, Function | MediumTest | Level1)
561{
562    std::string empty;
563    std::string schemes = "schemes.system.test";
564    EXPECT_EQ(0, base_->CountSchemes());
565    EXPECT_EQ(false, base_->HasAuthority(schemes));
566    EXPECT_EQ(empty, base_->GetAuthority(0));
567
568    base_->RemoveAuthority(schemes);
569    EXPECT_EQ(0, base_->CountSchemes());
570    EXPECT_EQ(false, base_->HasAuthority(schemes));
571}
572
573/**
574 * @tc.number: AaFwk_Skills_SchemeSpecificParts_0100
575 * @tc.name: CountSchemeSpecificParts/HasAuthority/GetAuthority
576 * @tc.desc: Verify the function when the input string contains special characters.
577 */
578HWTEST_F(SkillsBaseTest, AaFwk_Skills_SchemeSpecificParts_0100, Function | MediumTest | Level1)
579{
580    std::string empty;
581    std::string schemespecificparts = "schemespecificparts.system.test";
582    EXPECT_EQ(0, base_->CountSchemeSpecificParts());
583    EXPECT_EQ(false, base_->HasAuthority(schemespecificparts));
584    EXPECT_EQ(empty, base_->GetAuthority(0));
585
586    base_->RemoveAuthority(schemespecificparts);
587    EXPECT_EQ(0, base_->CountSchemeSpecificParts());
588    EXPECT_EQ(false, base_->HasAuthority(schemespecificparts));
589}
590
591/**
592 * @tc.number: AaFwk_Skills_Types_0100
593 * @tc.name: CountTypes/HasAuthority/GetAuthority
594 * @tc.desc: Verify the function when the input string contains special characters.
595 */
596HWTEST_F(SkillsBaseTest, AaFwk_Skills_Types_0100, Function | MediumTest | Level1)
597{
598    std::string empty;
599    std::string types = "types.system.test";
600    GTEST_LOG_(INFO) << "---------------a ";
601    EXPECT_EQ(0, base_->CountTypes());
602    GTEST_LOG_(INFO) << "---------------b ";
603    EXPECT_EQ(false, base_->HasAuthority(types));
604    GTEST_LOG_(INFO) << "---------------1 ";
605    EXPECT_EQ(empty, base_->GetAuthority(0));
606    GTEST_LOG_(INFO) << "---------------2 ";
607
608    base_->RemoveAuthority(types);
609    EXPECT_EQ(0, base_->CountTypes());
610    EXPECT_EQ(false, base_->HasAuthority(types));
611}
612
613/**
614 * @tc.number: AaFwk_Skills_Action_0200
615 * @tc.name: CountActions/HasAction/GetAction
616 * @tc.desc: Verify the function when action is not exist.
617 */
618HWTEST_F(SkillsBaseTest, AaFwk_Skills_Action_0200, Function | MediumTest | Level1)
619{
620    std::string empty;
621    std::string action = "action.system.test";
622    EXPECT_EQ(0, base_->CountActions());
623    EXPECT_EQ(false, base_->HasAction(action));
624    EXPECT_EQ(empty, base_->GetAction(0));
625
626    base_->RemoveAction(action);
627    EXPECT_EQ(0, base_->CountActions());
628    EXPECT_EQ(false, base_->HasAction(action));
629}
630
631/**
632 * @tc.number: AaFwk_Skills_Authority_0200
633 * @tc.name: CountAuthorities/HasAuthority/GetAuthority
634 * @tc.desc: Verify the function when action is not exist.
635 */
636HWTEST_F(SkillsBaseTest, AaFwk_Skills_Authority_0200, Function | MediumTest | Level1)
637{
638    std::string empty;
639    std::string authority = "authority.system.test";
640    EXPECT_EQ(0, base_->CountAuthorities());
641    EXPECT_EQ(false, base_->HasAuthority(authority));
642    EXPECT_EQ(empty, base_->GetAuthority(0));
643
644    base_->RemoveAuthority(authority);
645    EXPECT_EQ(0, base_->CountAuthorities());
646    EXPECT_EQ(false, base_->HasAuthority(authority));
647}
648
649/**
650 * @tc.number: AaFwk_Skills_Path_0200
651 * @tc.name: CountPaths/HasPath/GetPath
652 * @tc.desc: Verify the function when action is not exist.
653 */
654HWTEST_F(SkillsBaseTest, AaFwk_Skills_Path_0200, Function | MediumTest | Level1)
655{
656    std::string empty;
657    std::string path = "path.system.test";
658    base_->AddPath(path, MatchType::DEFAULT);
659
660    EXPECT_EQ(1, base_->CountPaths());
661    EXPECT_EQ(true, base_->HasPath(path));
662    EXPECT_EQ(path, base_->GetPath(0));
663
664    base_->RemovePath(path, MatchType::DEFAULT);
665    EXPECT_EQ(0, base_->CountPaths());
666    EXPECT_EQ(false, base_->HasPath(path));
667}
668
669/**
670 * @tc.number: AaFwk_Skills_Scheme_0200
671 * @tc.name: CountSchemes/HasScheme/GetScheme
672 * @tc.desc: Verify the function when action is not exist.
673 */
674HWTEST_F(SkillsBaseTest, AaFwk_Skills_Scheme_0200, Function | MediumTest | Level1)
675{
676    std::string empty;
677    std::string scheme = "scheme.system.test";
678    EXPECT_EQ(0, base_->CountSchemes());
679    EXPECT_EQ(false, base_->HasScheme(scheme));
680    EXPECT_EQ(empty, base_->GetScheme(0));
681
682    base_->RemoveScheme(scheme);
683    EXPECT_EQ(0, base_->CountSchemes());
684    EXPECT_EQ(false, base_->HasScheme(scheme));
685}
686
687/**
688 * @tc.number: AaFwk_Skills_SchemeSpecificPart_0200
689 * @tc.name: CountSchemeSpecificParts/HasSchemeSpecificPart/GetSchemeSpecificPart
690 * @tc.desc: Verify the function when action is not exist.
691 */
692HWTEST_F(SkillsBaseTest, AaFwk_Skills_SchemeSpecificPart_0200, Function | MediumTest | Level1)
693{
694    std::string empty;
695    std::string schemespecificpart = "schemespecificpart.system.test";
696    EXPECT_EQ(0, base_->CountSchemeSpecificParts());
697    EXPECT_EQ(false, base_->HasSchemeSpecificPart(schemespecificpart));
698    EXPECT_EQ(empty, base_->GetSchemeSpecificPart(0));
699
700    base_->RemoveSchemeSpecificPart(schemespecificpart);
701    EXPECT_EQ(0, base_->CountSchemeSpecificParts());
702    EXPECT_EQ(false, base_->HasSchemeSpecificPart(schemespecificpart));
703}
704
705/**
706 * @tc.number: AaFwk_Skills_Type_0300
707 * @tc.name: CountTypes/HasType/GetType
708 * @tc.desc: Verify the function when action is not exist.
709 */
710HWTEST_F(SkillsBaseTest, AaFwk_Skills_Type_0300, Function | MediumTest | Level1)
711{
712    std::string empty;
713    std::string type = "type.system.test";
714    EXPECT_EQ(0, base_->CountTypes());
715
716    EXPECT_EQ(false, base_->HasType(type));
717    EXPECT_EQ(empty, base_->GetType(0));
718
719    base_->RemoveType(type);
720    EXPECT_EQ(0, base_->CountTypes());
721    EXPECT_EQ(false, base_->HasType(type));
722}
723
724using SkillsMatchType = std::tuple<std::string, std::string, bool>;
725class SkillsMatchTest : public testing::TestWithParam<SkillsMatchType> {
726public:
727    SkillsMatchTest()
728    {}
729    ~SkillsMatchTest()
730    {}
731    static void SetUpTestCase(void);
732    static void TearDownTestCase(void);
733    void SetUp();
734    void TearDown();
735    std::shared_ptr<Skills> skills_ = nullptr;
736};
737
738void SkillsMatchTest::SetUpTestCase(void)
739{}
740
741void SkillsMatchTest::TearDownTestCase(void)
742{}
743
744void SkillsMatchTest::SetUp(void)
745{
746    skills_ = std::make_shared<Skills>();
747}
748
749void SkillsMatchTest::TearDown(void)
750{}
751
752/**
753 * @tc.number: AaFwk_Skills_match_0100
754 * @tc.name: CountTypes/HasType/GetType
755 * @tc.desc: Verify whether parameter change.
756 */
757HWTEST_P(SkillsMatchTest, AaFwk_Skills_match_0100, Function | MediumTest | Level1)
758{
759    std::string filterEntity = "entity.system.entity1";
760    std::string filterAction1 = "action.system.action1";
761    std::string filterAction2 = "action.system.action2";
762    std::string wantEntity = std::get<0>(GetParam());
763    std::string wantAction = std::get<1>(GetParam());
764    bool result = std::get<2>(GetParam());
765
766    skills_->AddEntity(filterEntity);
767    skills_->AddAction(filterAction1);
768    skills_->AddAction(filterAction2);
769
770    Want want;
771    want.AddEntity(wantEntity);
772    want.SetAction(wantAction);
773
774    EXPECT_EQ(result, skills_->Match(want));
775}
776
777INSTANTIATE_TEST_SUITE_P(SkillsMatchTestP, SkillsMatchTest,
778    testing::Values(SkillsMatchType("entity.system.entityA", "action.system.actionA", false),
779        SkillsMatchType("entity.system.entity1", "action.system.actionA", false),
780        SkillsMatchType("entity.system.entityA", "action.system.action2", false),
781        SkillsMatchType("entity.system.entity1", "action.system.action1", true)));
782
783/**
784 * @tc.name: AaFwk_Skills_match_0200
785 * @tc.desc: Verify Matching rules action segment
786 * @tc.type: FUNC
787 * @tc.require: I5PZK2
788 */
789HWTEST_F(SkillsBaseTest, AaFwk_Skills_match_0200, Function | MediumTest | Level1)
790{
791    Skills skills;
792    std::string filterEntity = "entity.system.entity1";
793    skills.AddEntity(filterEntity);
794    Want want;
795    want.AddEntity(filterEntity);
796    // Both actions are empty.
797    EXPECT_EQ(true, skills.Match(want));
798}
799
800/**
801 * @tc.name: AaFwk_Skills_match_0300
802 * @tc.desc: Verify Matching rules action segment
803 * @tc.type: FUNC
804 * @tc.require: I5PZK2
805 */
806HWTEST_F(SkillsBaseTest, AaFwk_Skills_match_0300, Function | MediumTest | Level1)
807{
808    Skills skills;
809    std::string filterEntity = "entity.system.entity1";
810    skills.AddEntity(filterEntity);
811    Want want;
812    want.AddEntity(filterEntity);
813    want.SetAction("action.system.action1");
814    // empty actions in skill vs non-empty actions in want
815    EXPECT_EQ(false, skills.Match(want));
816}
817
818/**
819 * @tc.name: AaFwk_Skills_match_0400
820 * @tc.desc: Verify Matching rules action segment
821 * @tc.type: FUNC
822 * @tc.require: I5PZK2
823 */
824HWTEST_F(SkillsBaseTest, AaFwk_Skills_match_0400, Function | MediumTest | Level1)
825{
826    Skills skills;
827    std::string filterEntity = "entity.system.entity1";
828    std::string filterAction1 = "action.system.action1";
829    std::string filterAction2 = "action.system.action2";
830    skills.AddEntity(filterEntity);
831    skills.AddAction(filterAction1);
832    skills.AddAction(filterAction2);
833    Want want;
834    want.AddEntity(filterEntity);
835    want.SetAction(filterAction1);
836    // actions that in skill contains non-empty actions in want
837    EXPECT_EQ(true, skills.Match(want));
838}
839
840/**
841 * @tc.name: AaFwk_Skills_match_0500
842 * @tc.desc: Verify Matching rules action segment
843 * @tc.type: FUNC
844 * @tc.require: I5PZK2
845 */
846HWTEST_F(SkillsBaseTest, AaFwk_Skills_match_0600, Function | MediumTest | Level1)
847{
848    Skills skills;
849    std::string filterEntity = "entity.system.entity1";
850    std::string filterAction1 = "action.system.action1";
851    std::string filterAction2 = "action.system.action2";
852    skills.AddEntity(filterEntity);
853    skills.AddAction(filterAction2);
854    Want want;
855    want.AddEntity(filterEntity);
856    // non-empty actions that in skill vs empty actions in want
857    EXPECT_EQ(false, skills.Match(want));
858}
859
860/**
861 * @tc.name: AaFwk_Skills_match_0600
862 * @tc.desc: Verify Matching rules action segment
863 * @tc.type: FUNC
864 * @tc.require: I5PZK2
865 */
866HWTEST_F(SkillsBaseTest, AaFwk_Skills_match_0500, Function | MediumTest | Level1)
867{
868    Skills skills;
869    std::string filterEntity = "entity.system.entity1";
870    std::string filterAction1 = "action.system.action1";
871    std::string filterAction2 = "action.system.action2";
872    skills.AddEntity(filterEntity);
873    skills.AddAction(filterAction2);
874    Want want;
875    want.AddEntity(filterEntity);
876    want.SetAction(filterAction1);
877    // actions that in skill doesn't contain non-empty actions in want
878    EXPECT_EQ(false, skills.Match(want));
879}
880
881/**
882 * @tc.number: AaFwk_Skills_Skills_0100
883 * @tc.name: Skills() and Skills(Skills)
884 * @tc.desc:  Verify Skills().
885 */
886HWTEST_F(SkillsBaseTest, AaFwk_Skills_Skills_0100, Function | MediumTest | Level1)
887{
888    Skills skills;
889
890    EXPECT_EQ(0, skills.CountEntities());
891    EXPECT_EQ(0, skills.CountActions());
892    EXPECT_EQ(0, skills.CountAuthorities());
893    EXPECT_EQ(0, skills.CountSchemes());
894
895    EXPECT_EQ(0, skills.CountPaths());
896    EXPECT_EQ(0, skills.CountSchemeSpecificParts());
897    EXPECT_EQ(0, skills.CountTypes());
898    EXPECT_EQ(0, skills.GetWantParams().Size());
899}
900
901/**
902 * @tc.number: AaFwk_Skills_Skills_0200
903 * @tc.name: Skills() and Skills(Skills)
904 * @tc.desc:  Verify Skills().
905 */
906HWTEST_F(SkillsBaseTest, AaFwk_Skills_Skills_0200, Function | MediumTest | Level1)
907{
908    Skills skillsBase;
909    std::string entityString = "entity";
910    skillsBase.AddEntity(entityString);
911    std::string actionString = "action";
912    skillsBase.AddAction(actionString);
913    std::string authorityString = "authority";
914    skillsBase.AddAuthority(authorityString);
915    std::string schemeString = "scheme";
916    skillsBase.AddScheme(schemeString);
917    std::string pathString = "path";
918    skillsBase.AddPath(pathString);
919    std::string schemeSpecificPartsString = "schemeSpecificParts";
920    skillsBase.AddSchemeSpecificPart(schemeSpecificPartsString);
921    std::string typeString = "/type";
922    skillsBase.AddType(typeString);
923    Skills skills(skillsBase);
924
925    EXPECT_EQ(entityString, skills.GetEntity(0));
926    int index = -5;
927    std::string entityString1 = "";
928    EXPECT_EQ(entityString1, skills.GetEntity(index));
929    EXPECT_EQ(actionString, skills.GetAction(0));
930    EXPECT_EQ(entityString1, skills.GetAction(index));
931    EXPECT_EQ(authorityString, skills.GetAuthority(0));
932    EXPECT_EQ(entityString1, skills.GetAuthority(index));
933    EXPECT_EQ(schemeString, skills.GetScheme(0));
934    EXPECT_EQ(entityString1, skills.GetScheme(index));
935    EXPECT_EQ(pathString, skills.GetPath(0));
936    EXPECT_EQ(entityString1, skills.GetPath(index));
937    EXPECT_EQ(schemeSpecificPartsString, skills.GetSchemeSpecificPart(0));
938    EXPECT_EQ(entityString1, skills.GetSchemeSpecificPart(index));
939    EXPECT_EQ(typeString, skills.GetType(0));
940}
941
942/**
943 * @tc.number: AaFwk_Skills_addremoveType_0100
944 * @tc.name: addType(PatternsMatcher)/ removeType(PatternsMatcher)
945 * @tc.desc: Verify addType/removeType result.
946 */
947HWTEST_F(SkillsBaseTest, AaFwk_Skills_addremoveType_0100, Function | MediumTest | Level1)
948{
949    std::string patternStr = std::string("systems/*t");
950
951    PatternsMatcher pattern(patternStr, MatchType::DEFAULT);
952
953    base_->AddType(pattern);
954    std::string type1 = base_->GetType(0);
955    EXPECT_EQ(patternStr, type1);
956
957    base_->RemoveType(patternStr);
958
959    EXPECT_EQ(0, base_->CountEntities());
960
961    base_->AddType(pattern);
962
963    std::string patternStr2 = std::string("systems/*test");
964    PatternsMatcher pattern2(patternStr2, MatchType::PREFIX);
965    base_->AddType(pattern2);
966    std::string type2 = base_->GetType(1);
967    EXPECT_EQ(patternStr2, type2);
968
969    base_->RemoveType(pattern2);
970    EXPECT_EQ(0, base_->CountEntities());
971
972    std::string patternStr3 = std::string("systems/*test3");
973    base_->AddType(patternStr3, MatchType::GLOBAL);
974
975    std::string type3 = base_->GetType(1);
976    EXPECT_EQ(patternStr3, type3);
977
978    std::string patternStr4 = std::string("");
979    std::string type4 = base_->GetType(-5);
980    EXPECT_EQ(patternStr4, type4);
981
982    base_->RemoveType(patternStr3, MatchType::GLOBAL);
983
984    EXPECT_EQ(0, base_->CountEntities());
985}
986
987/**
988 * @tc.number: AaFwk_Skills_MatchData_0100
989 * @tc.name: MatchData
990 * @tc.desc: Test MatchData.
991 * @tc.require: issueI648W6
992 */
993HWTEST_F(SkillsBaseTest, AaFwk_Skills_MatchData_0100, Function | MediumTest | Level1)
994{
995    std::string type = "this is type";
996    std::string scheme = "this is scheme";
997    std::string value = "this is value";
998    OHOS::Uri data(value);
999    int result = base_->MatchData(type, scheme, data);
1000    EXPECT_EQ(result, DISMATCH_DATA);
1001}
1002
1003/**
1004 * @tc.number: AaFwk_Skills_MatchData_0200
1005 * @tc.name: MatchData
1006 * @tc.desc: Test MatchData.
1007 * @tc.require: issueI648W6
1008 */
1009HWTEST_F(SkillsBaseTest, AaFwk_Skills_MatchData_0200, Function | MediumTest | Level1)
1010{
1011    std::string type = "";
1012    std::string scheme = "";
1013    std::string value = "this is value";
1014    OHOS::Uri data(value);
1015    int result = base_->MatchData(type, scheme, data);
1016    EXPECT_EQ(result, DISMATCH_TYPE);
1017}
1018
1019/**
1020 * @tc.number: AaFwk_Skills_MatchData_0300
1021 * @tc.name: MatchData
1022 * @tc.desc: Test MatchData.
1023 * @tc.require: issueI648W6
1024 */
1025HWTEST_F(SkillsBaseTest, AaFwk_Skills_MatchData_0300, Function | MediumTest | Level1)
1026{
1027    std::string type = "this is type";
1028    std::string scheme = "this is scheme";
1029    std::string value = "this is value";
1030    OHOS::Uri data(value);
1031    std::string pattern = "this is pattern";
1032    PatternsMatcherIn_ = std::make_shared<PatternsMatcher>(pattern, MatchType::DEFAULT);
1033    std::string ret = PatternsMatcherIn_->GetPattern();
1034    EXPECT_EQ(ret, pattern);
1035    base_->AddScheme("12345");
1036    int result = base_->MatchData(type, scheme, data);
1037    EXPECT_EQ(result, DISMATCH_DATA);
1038}
1039
1040/**
1041 * @tc.number: AaFwk_Skills_FindMimeType_0100
1042 * @tc.name: FindMimeType
1043 * @tc.desc: Test FindMimeType.
1044 * @tc.require: issueI653GZ
1045 */
1046HWTEST_F(SkillsBaseTest, AaFwk_Skills_FindMimeType_0100, Function | MediumTest | Level1)
1047{
1048    std::string type = "";
1049    bool result = base_->FindMimeType(type);
1050    EXPECT_EQ(result, false);
1051
1052    std::string type1 = "this is type";
1053    bool result1 = base_->FindMimeType(type1);
1054    EXPECT_EQ(result1, false);
1055}
1056
1057/**
1058 * @tc.number: AaFwk_Skills_FindMimeType_0200
1059 * @tc.name: FindMimeType
1060 * @tc.desc: Test FindMimeType.
1061 * @tc.require: issue
1062 */
1063HWTEST_F(SkillsBaseTest, AaFwk_Skills_FindMimeType_0200, Function | MediumTest | Level1)
1064{
1065    std::string empty;
1066    std::string type = "*/*";
1067    int typeCount = 1;
1068
1069    for (int i = 0; i < SET_COUNT; i++) {
1070        base_->AddType(type);
1071    }
1072    EXPECT_EQ(typeCount, base_->CountTypes());
1073
1074    PatternsMatcherIn_ = std::make_shared<PatternsMatcher>(type, MatchType::DEFAULT);
1075    std::string ret = PatternsMatcherIn_->GetPattern();
1076    EXPECT_EQ(ret, type);
1077    bool result = base_->FindMimeType(type);
1078    EXPECT_EQ(result, true);
1079}
1080
1081/**
1082 * @tc.number: AaFwk_Skills_FindMimeType_0300
1083 * @tc.name: FindMimeType
1084 * @tc.desc: Test FindMimeType.
1085 * @tc.require: issue
1086 */
1087HWTEST_F(SkillsBaseTest, AaFwk_Skills_FindMimeType_0300, Function | MediumTest | Level1)
1088{
1089    std::string empty;
1090    std::string type = "type/system.test";
1091    int typeCount = 1;
1092
1093    for (int i = 0; i < SET_COUNT; i++) {
1094        base_->AddType(type);
1095    }
1096    EXPECT_EQ(typeCount, base_->CountTypes());
1097
1098    PatternsMatcherIn_ = std::make_shared<PatternsMatcher>(type, MatchType::DEFAULT);
1099    std::string ret = PatternsMatcherIn_->GetPattern();
1100    EXPECT_EQ(ret, type);
1101    bool result = base_->FindMimeType(type);
1102    EXPECT_EQ(result, true);
1103    EXPECT_EQ(true, base_->HasType(type));
1104    EXPECT_EQ(type, base_->GetType(0));
1105
1106    base_->RemoveType(type);
1107    EXPECT_EQ(0, base_->CountTypes());
1108    EXPECT_EQ(false, base_->FindMimeType(type));
1109}
1110
1111/**
1112 * @tc.number: AaFwk_Skills_RegionMatches_0100
1113 * @tc.name: RegionMatches
1114 * @tc.desc: Test RegionMatches.
1115 * @tc.require: issueI653GZ
1116 */
1117HWTEST_F(SkillsBaseTest, AaFwk_Skills_RegionMatches_0100, Function | MediumTest | Level1)
1118{
1119    std::string type = "this is type";
1120    int toffset = -1;
1121    std::string other = "this is other";
1122    int ooffset = -2;
1123    int len = 1;
1124    bool result = base_->RegionMatches(type, toffset, other, ooffset, len);
1125    EXPECT_EQ(result, false);
1126}
1127
1128/**
1129 * @tc.number: AaFwk_Skills_RegionMatches_0200
1130 * @tc.name: RegionMatches
1131 * @tc.desc: Test RegionMatches.
1132 * @tc.require: issueI653GZ
1133 */
1134HWTEST_F(SkillsBaseTest, AaFwk_Skills_RegionMatches_0200, Function | MediumTest | Level1)
1135{
1136    std::string type = "this is type";
1137    int toffset = 1;
1138    std::string other = "this is other";
1139    int ooffset = 2;
1140    int len = 2;
1141    bool result = base_->RegionMatches(type, toffset, other, ooffset, len);
1142    EXPECT_EQ(result, false);
1143
1144    int len1 = 0;
1145    bool result1 = base_->RegionMatches(type, toffset, other, ooffset, len1);
1146    EXPECT_EQ(result1, true);
1147}
1148
1149/**
1150 * @tc.number: AaFwk_Skills_RegionMatches_0300
1151 * @tc.name: RegionMatches
1152 * @tc.desc: Test RegionMatches.
1153 * @tc.require: issueI653GZ
1154 */
1155HWTEST_F(SkillsBaseTest, AaFwk_Skills_RegionMatches_0300, Function | MediumTest | Level1)
1156{
1157    std::string type = "this is type";
1158    int toffset = 1;
1159    std::string other = "this is other";
1160    int ooffset = -2;
1161    int len = 20;
1162    bool result = base_->RegionMatches(type, toffset, other, ooffset, len);
1163    EXPECT_EQ(result, false);
1164}
1165
1166/**
1167 * @tc.number: AaFwk_Skills_MatchEntities_0200
1168 * @tc.name: MatchEntities
1169 * @tc.desc: Test MatchEntities.
1170 * @tc.require: issue
1171 */
1172HWTEST_F(SkillsBaseTest, AaFwk_Skills_MatchEntities_0200, Function | MediumTest | Level1)
1173{
1174    std::vector<std::string> entities;
1175    std::string ret = "";
1176    std::string result = base_->MatchEntities(entities);
1177    EXPECT_EQ(result, ret);
1178}
1179
1180using testParamsType = std::tuple<std::string, std::string>;
1181class SkillsParamsTest : public testing::TestWithParam<testParamsType> {
1182public:
1183    SkillsParamsTest()
1184    {}
1185    ~SkillsParamsTest()
1186    {}
1187    static void SetUpTestCase(void);
1188    static void TearDownTestCase(void);
1189    void SetUp();
1190    void TearDown();
1191    std::shared_ptr<Skills> skills_ = nullptr;
1192};
1193
1194void SkillsParamsTest::SetUpTestCase(void)
1195{}
1196
1197void SkillsParamsTest::TearDownTestCase(void)
1198{}
1199
1200void SkillsParamsTest::SetUp(void)
1201{
1202    skills_ = std::make_shared<Skills>();
1203}
1204
1205void SkillsParamsTest::TearDown(void)
1206{}
1207
1208/**
1209 * @tc.number: AaFwk_Skills_Params_0100
1210 * @tc.name: SetWantParams/GetWantParams
1211 * @tc.desc: Verify addType/removeType result.
1212 */
1213HWTEST_P(SkillsParamsTest, AaFwk_Skills_Params_0100, Function | MediumTest | Level1)
1214{
1215    std::string keyStr = std::get<0>(GetParam());
1216    std::string valueStr = std::get<1>(GetParam());
1217    WantParams wantParams;
1218    wantParams.SetParam(keyStr, String::Box(valueStr));
1219    skills_->SetWantParams(wantParams);
1220    EXPECT_EQ(valueStr, String::Unbox(IString::Query(skills_->GetWantParams().GetParam(keyStr))));
1221}
1222
1223INSTANTIATE_TEST_SUITE_P(SkillsParamsTestCaseP, SkillsParamsTest,
1224    testing::Values(testParamsType("", "asdsdsdasa"), testParamsType(std::string(LARGE_STR_LEN + 1, 's'), "sadsdsdads"),
1225        testParamsType("#$%^&*(!@\":<>{}", "asdsdsdasa"), testParamsType("3456677", ""),
1226        testParamsType("1234", std::string(LARGE_STR_LEN + 1, 's')),
1227        testParamsType("2323sdasdZ", "#$%^&*(!@\":<>{}sadsdasdsaf"), testParamsType("12345667", "sdasdfdsffdgfdg"),
1228        testParamsType("", ""),
1229        testParamsType(std::string(LARGE_STR_LEN + 1, 'k'), std::string(LARGE_STR_LEN + 1, 'k')),
1230        testParamsType("#$%^&*(!@\":<>{},/", "#$%^&*(!@\":<>{},/")));
1231}  // namespace AAFwk
1232}  // namespace OHOS