1 /*
2 * Copyright (c) 2021 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 #include "ohos/aafwk/content/want.h"
19 #include "ohos/aafwk/base/string_wrapper.h"
20 #include "ohos/aafwk/base/bool_wrapper.h"
21 #include "ohos/aafwk/base/int_wrapper.h"
22 #include "ohos/aafwk/base/float_wrapper.h"
23 #include "ohos/aafwk/base/array_wrapper.h"
24 #include "ohos/aafwk/base/long_wrapper.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AAFwk;
28 using namespace OHOS;
29 using OHOS::Parcel;
30 using OHOS::AppExecFwk::ElementName;
31
32 namespace OHOS {
33 namespace AAFwk {
34 class WantBaseTest : public testing::Test {
35 public:
WantBaseTest()36 WantBaseTest()
37 {}
~WantBaseTest()38 ~WantBaseTest()
39 {}
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44
45 std::shared_ptr<Want> want_ = nullptr;
46
47 void CompareWant(const std::shared_ptr<Want> &want1, const std::shared_ptr<Want> &want2) const;
48 bool CompareWant(const std::shared_ptr<Want> &want1, const std::shared_ptr<Want> &want2,
49 std::map<std::string, std::string> &keys) const;
50 void SendParcelTest(const std::shared_ptr<Want> &want, std::map<std::string, std::string> &keys) const;
51 void AddBoolParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
52 void AddByteParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
53 void AddCharParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
54 void AddShortParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
55 void AddIntParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
56 void AddLongParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
57 void AddFloatParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
58 void AddDoubleParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
59 void AddStringParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
60
61 std::string boolType = "bool";
62 std::string boolArrayType = "boolArray";
63 std::string byteType = "byte";
64 std::string byteArrayType = "byteArray";
65 std::string charType = "char";
66 std::string charArrayType = "charArray";
67 std::string shortType = "short";
68 std::string shortArrayType = "shortArray";
69 std::string intType = "int";
70 std::string intArrayType = "intArray";
71 std::string longType = "long";
72 std::string longArrayType = "longArray";
73 std::string floatType = "float";
74 std::string floatArrayType = "floatArray";
75 std::string doubleType = "double";
76 std::string doubleArrayType = "doubleArray";
77 std::string stringType = "string";
78 std::string stringArrayType = "stringArray";
79
80 static const std::string URI_STRING_HEAD;
81 static const std::string URI_STRING_END;
82 };
83
84 template<typename T>
CompareArrayData(const std::vector<T> & arr1,const std::vector<T> & arr2)85 bool CompareArrayData(const std::vector<T> &arr1, const std::vector<T> &arr2)
86 {
87 if (arr1.size() != arr2.size()) {
88 return false;
89 }
90
91 for (std::uint32_t i = 0; i < arr1.size(); i++) {
92 if (arr1[i] != arr2[i]) {
93 return false;
94 }
95 }
96
97 return true;
98 };
99
100 enum type { FLAG_TEST_SINGLE = 0x01, FLAG_TEST_ARRAY, FLAG_TEST_BOTH };
101
SetUpTestCase(void)102 void WantBaseTest::SetUpTestCase(void)
103 {}
104
TearDownTestCase(void)105 void WantBaseTest::TearDownTestCase(void)
106 {}
107
SetUp(void)108 void WantBaseTest::SetUp(void)
109 {
110 want_ = std::make_shared<Want>();
111 }
112
TearDown(void)113 void WantBaseTest::TearDown(void)
114 {}
115
116 const std::string WantBaseTest::URI_STRING_HEAD("#Intent;");
117 const std::string WantBaseTest::URI_STRING_END(";end");
118
119 /**
120 * @tc.number: AaExecFwk_Want_Type_0100
121 * @tc.name: SetType/GetType
122 * @tc.desc: Validate when normally entering a string
123 */
124 HWTEST_F(WantBaseTest, AaExecFwk_Want_Type_0100, Function | MediumTest | Level1)
125 {
126 if (want_ != nullptr) {
127 std::string description = "liuuy";
128 want_->SetType(description);
129 EXPECT_STREQ(description.c_str(), want_->GetType().c_str());
130 }
131 }
132
133 /**
134 * @tc.number: AaFwk_Want_Action_0100
135 * @tc.name: SetAction/GetAction
136 * @tc.desc: Validate when normally entering a string
137 */
138 HWTEST_F(WantBaseTest, AaFwk_Want_Action_0100, Function | MediumTest | Level1)
139 {
140 if (want_ != nullptr) {
141 std::string actiondescription = "liuuy";
142 want_->SetAction(actiondescription);
143 EXPECT_STREQ(actiondescription.c_str(), want_->GetAction().c_str());
144 }
145 }
146
147 /**
148 * @tc.number: AaFwk_Want_Bundle_0100
149 * @tc.name: SetBundle/GetBundle
150 * @tc.desc: Validate when normally entering a string
151 */
152 HWTEST_F(WantBaseTest, AaFwk_Want_Bundle_0100, Function | MediumTest | Level1)
153 {
154 if (want_ != nullptr) {
155 std::string bundleName = "liuuy";
156 want_->SetBundle(bundleName);
157 EXPECT_STREQ(bundleName.c_str(), want_->GetBundle().c_str());
158 }
159 }
160
161 /**
162 * @tc.number: AaFwk_Want_Parcelable_0100
163 * @tc.name: Marshalling/Unmarshalling
164 * @tc.desc: marshalling Want, and then check result.
165 */
166 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0100, Function | MediumTest | Level1)
167 {
168 std::shared_ptr<Want> WantIn_ = std::make_shared<Want>();
169 if (WantIn_ == nullptr) {
170 return;
171 }
172
173 WantIn_->SetAction("12345");
174 WantIn_->SetFlags(123);
175
176 WantIn_->SetAction("12345");
177 WantIn_->SetFlags(123);
178 WantIn_->AddEntity("12345");
179 WantParams wantParams;
180 std::string keyStr = "12345667";
181 bool valueBool = true;
182 wantParams.SetParam(keyStr, Boolean::Box(valueBool));
183 WantIn_->SetParams(wantParams);
184 OHOS::AppExecFwk::ElementName element;
185 element.SetAbilityName("12345");
186 element.SetBundleName("12345");
187 element.SetDeviceID("12345");
188 WantIn_->SetElement(element);
189 WantIn_->SetType("12345");
190 size_t pos1;
191 size_t pos2;
192 bool result = false;
193
194 Parcel in;
195 pos1 = in.GetWritePosition();
196 result = WantIn_->Marshalling(in);
197 pos2 = in.GetWritePosition();
198 EXPECT_EQ(result, true);
199 GTEST_LOG_(INFO) << " Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
200
201 pos1 = in.GetWritePosition();
202 result = WantIn_->Marshalling(in);
203 pos2 = in.GetWritePosition();
204 EXPECT_EQ(result, true);
205 GTEST_LOG_(INFO) << " Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
206
207 pos1 = in.GetReadPosition();
208 std::shared_ptr<Want> WantOut_(Want::Unmarshalling(in));
209 if (WantOut_ != nullptr) {
210 pos2 = in.GetReadPosition();
211 CompareWant(WantIn_, WantOut_);
212 EXPECT_EQ(valueBool, Boolean::Unbox(IBoolean::Query(WantOut_->GetParams().GetParam(keyStr))));
213 GTEST_LOG_(INFO) << " Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
214 }
215
216 pos1 = in.GetReadPosition();
217 std::shared_ptr<Want> WantOut2_(Want::Unmarshalling(in));
218 if (WantOut2_ != nullptr) {
219 pos2 = in.GetReadPosition();
220 CompareWant(WantIn_, WantOut2_);
221 EXPECT_EQ(valueBool, Boolean::Unbox(IBoolean::Query(WantOut2_->GetParams().GetParam(keyStr))));
222 GTEST_LOG_(INFO) << " Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
223 }
224 }
225 /**
226 * @tc.number: AaFwk_Want_Parcelable_0200
227 * @tc.name: Marshalling/Unmarshalling
228 * @tc.desc: marshalling Want, and then check result.
229 */
230 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0200, Function | MediumTest | Level1)
231 {
232 std::shared_ptr<Want> WantIn_ = std::make_shared<Want>();
233 if (WantIn_ == nullptr) {
234 return;
235 }
236 WantIn_->SetAction("@#￥#3243adsafdf_中文");
237 WantIn_->SetFlags(123);
238 WantIn_->AddEntity("@#￥#3243adsafdf_中文");
239 WantParams wantParams;
240 std::string keyStr = "@#￥#3243adsafdf_中文";
241 long valueLong = 123;
242 wantParams.SetParam(keyStr, Long::Box(valueLong));
243 WantIn_->SetParams(wantParams);
244 OHOS::AppExecFwk::ElementName element;
245 element.SetAbilityName("@#￥#3243adsafdf_中文");
246 element.SetBundleName("@#￥#3243adsafdf_中文");
247 element.SetDeviceID("@#￥#3243adsafdf_中文");
248 WantIn_->SetElement(element);
249 WantIn_->SetType("@#￥#3243adsafdf_中文");
250 size_t pos1;
251 size_t pos2;
252 bool result = false;
253 Parcel in;
254 pos1 = in.GetWritePosition();
255 result = WantIn_->Marshalling(in);
256 pos2 = in.GetWritePosition();
257 EXPECT_EQ(result, true);
258 GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
259 pos1 = in.GetWritePosition();
260 result = WantIn_->Marshalling(in);
261 pos2 = in.GetWritePosition();
262 EXPECT_EQ(result, true);
263 pos1 = in.GetReadPosition();
264 std::shared_ptr<Want> WantOut_(Want::Unmarshalling(in));
265 if (WantOut_ != nullptr) {
266 pos2 = in.GetReadPosition();
267 CompareWant(WantIn_, WantOut_);
268 std::string outString(String::Unbox(IString::Query(WantOut_->GetParams().GetParam(keyStr))));
269 EXPECT_STREQ(std::to_string(valueLong).c_str(), outString.c_str());
270 GTEST_LOG_(INFO) << "Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
271 }
272 pos1 = in.GetReadPosition();
273 std::shared_ptr<Want> WantOut2_(Want::Unmarshalling(in));
274 if (WantOut2_ != nullptr) {
275 pos2 = in.GetReadPosition();
276 CompareWant(WantIn_, WantOut2_);
277 std::string outString2(String::Unbox(IString::Query(WantOut2_->GetParams().GetParam(keyStr))));
278 EXPECT_STREQ(std::to_string(valueLong).c_str(), outString2.c_str());
279 }
280 }
281
282 /**
283 * @tc.number: AaFwk_Want_Parcelable_0300
284 * @tc.name: Marshalling/Unmarshalling
285 * @tc.desc: marshalling Want, and then check result.
286 */
287 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0300, Function | MediumTest | Level1)
288 {
289 std::shared_ptr<Want> WantIn_ = std::make_shared<Want>();
290 if (WantIn_ == nullptr) {
291 return;
292 }
293
294 WantIn_->SetAction("");
295 WantIn_->SetFlags(123);
296 WantIn_->AddEntity("");
297 WantParams wantParams;
298 std::string keyStr = "";
299 int valueInt = 123;
300 wantParams.SetParam(keyStr, Integer::Box(valueInt));
301 WantIn_->SetParams(wantParams);
302 OHOS::AppExecFwk::ElementName element;
303 element.SetAbilityName("");
304 element.SetBundleName("");
305 element.SetDeviceID("");
306 WantIn_->SetElement(element);
307 WantIn_->SetType("");
308
309 size_t pos1;
310 size_t pos2;
311 bool result = false;
312
313 Parcel in;
314 pos1 = in.GetWritePosition();
315 result = WantIn_->Marshalling(in);
316 pos2 = in.GetWritePosition();
317 EXPECT_EQ(result, true);
318 GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
319
320 pos1 = in.GetWritePosition();
321 result = WantIn_->Marshalling(in);
322 pos2 = in.GetWritePosition();
323 EXPECT_EQ(result, true);
324 GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
325
326 pos1 = in.GetReadPosition();
327 std::shared_ptr<Want> WantOut_(Want::Unmarshalling(in));
328 if (WantOut_ != nullptr) {
329 pos2 = in.GetReadPosition();
330 CompareWant(WantIn_, WantOut_);
331 EXPECT_EQ(valueInt, Integer::Unbox(IInteger::Query(WantOut_->GetParams().GetParam(keyStr))));
332 GTEST_LOG_(INFO) << "Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
333 }
334
335 pos1 = in.GetReadPosition();
336 std::shared_ptr<Want> WantOut2_(Want::Unmarshalling(in));
337 if (WantOut2_ != nullptr) {
338 pos2 = in.GetReadPosition();
339 CompareWant(WantIn_, WantOut2_);
340 EXPECT_EQ(valueInt, Integer::Unbox(IInteger::Query(WantOut2_->GetParams().GetParam(keyStr))));
341 GTEST_LOG_(INFO) << "Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
342 }
343 }
344
345 /**
346 * @tc.number: AaFwk_Want_Parcelable_0400
347 * @tc.name: Marshalling/Unmarshalling
348 * @tc.desc: marshalling Want, and then check result.
349 */
350 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0400, Function | MediumTest | Level1)
351 {
352 std::shared_ptr<Want> WantIn_ = std::make_shared<Want>();
353 if (WantIn_ == nullptr) {
354 return;
355 }
356
357 WantIn_->SetAction("12345");
358 WantIn_->SetFlags(123);
359 WantIn_->AddEntity("12345");
360 WantIn_->AddEntity("@#￥#3243adsafdf_中文");
361 WantIn_->AddEntity("");
362 WantParams wantParams;
363 std::string keyStr = "12345667";
364 std::string valueString = "123";
365 wantParams.SetParam(keyStr, String::Box(valueString));
366 WantIn_->SetParams(wantParams);
367 OHOS::AppExecFwk::ElementName element;
368 element.SetAbilityName("12345");
369 element.SetBundleName("12345");
370 element.SetDeviceID("12345");
371 WantIn_->SetElement(element);
372 WantIn_->SetType("12345");
373
374 size_t pos1;
375 size_t pos2;
376 bool result = false;
377
378 Parcel in;
379 pos1 = in.GetWritePosition();
380 result = WantIn_->Marshalling(in);
381 pos2 = in.GetWritePosition();
382 EXPECT_EQ(result, true);
383 GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
384
385 pos1 = in.GetWritePosition();
386 result = WantIn_->Marshalling(in);
387 pos2 = in.GetWritePosition();
388 EXPECT_EQ(result, true);
389 GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
390
391 pos1 = in.GetReadPosition();
392 std::shared_ptr<Want> WantOut_(Want::Unmarshalling(in));
393 if (WantOut_ != nullptr) {
394 pos2 = in.GetReadPosition();
395 CompareWant(WantIn_, WantOut_);
396 EXPECT_EQ(valueString, String::Unbox(IString::Query(WantOut_->GetParams().GetParam(keyStr))));
397 GTEST_LOG_(INFO) << "Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
398 }
399
400 pos1 = in.GetReadPosition();
401 std::shared_ptr<Want> WantOut2_(Want::Unmarshalling(in));
402 if (WantOut2_ != nullptr) {
403 pos2 = in.GetReadPosition();
404 CompareWant(WantIn_, WantOut2_);
405 EXPECT_EQ(valueString, String::Unbox(IString::Query(WantOut2_->GetParams().GetParam(keyStr))));
406 GTEST_LOG_(INFO) << "Unmarshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
407 }
408 }
409
410 /**
411 * @tc.number: AaFwk_Want_Parcelable_0500
412 * @tc.name: Marshalling/Unmarshalling
413 * @tc.desc: marshalling Want, and then check result.
414 */
415 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0500, Function | MediumTest | Level1)
416 {
417 GTEST_LOG_(INFO) << "AaFwk_Want_Parcelable_005 start";
418 std::shared_ptr<Want> WantIn_ = std::make_shared<Want>();
419 if (WantIn_ == nullptr) {
420 return;
421 }
422
423 WantIn_->SetAction("system.test.action");
424 WantIn_->SetFlags(64);
425 WantIn_->AddEntity("system.test.entity");
426
427 OHOS::AppExecFwk::ElementName element;
428 element.SetAbilityName("system.test.abilityname");
429 element.SetBundleName("system.test.bundlename");
430 element.SetDeviceID("system.test.deviceid");
431 WantIn_->SetElement(element);
432
433 WantParams wantParams;
434 std::string keyStr = "system.test.wantparams.key";
435 std::string MIMEKEY = "mime-type";
436 wantParams.SetParam(MIMEKEY, String::Box("system.test.uritype"));
437
438 std::string valueString = "system.wantparams.value.content.test";
439 wantParams.SetParam(keyStr, String::Box(valueString));
440 WantIn_->SetParams(wantParams);
441
442 // want SetParam arraydata test
443 std::vector<bool> boolArrayValue = {true, false, true};
444 WantIn_->SetParam(std::string("bool_arraykey"), boolArrayValue);
445
446 std::vector<byte> byteArrayValue = {'?', 'a', '\\'};
447 WantIn_->SetParam(std::string("byte_arraykey"), byteArrayValue);
448
449 std::vector<zchar> charArrayValue = {U'e', U'l', U'l', U'o'};
450 WantIn_->SetParam(std::string("char_arraykey"), charArrayValue);
451
452 std::vector<short> shortArrayValue = {-1, 0, 1};
453 WantIn_->SetParam(std::string("short_arraykey"), shortArrayValue);
454
455 std::vector<int> intArrayValue = {-10, 0, 10};
456 WantIn_->SetParam(std::string("int_arraykey"), intArrayValue);
457
458 std::vector<long> longArrayValue = {-100, 0, 100};
459 WantIn_->SetParam(std::string("long_arraykey"), longArrayValue);
460
461 std::vector<float> floatArrayValue = {-100.1, 0.1, 100.1};
462 WantIn_->SetParam(std::string("float_arraykey"), floatArrayValue);
463
464 std::vector<double> doubleArrayValue = {-1000.1, 0.1, 1000.1};
465 WantIn_->SetParam(std::string("double_arraykey"), doubleArrayValue);
466
467 std::vector<std::string> stringArrayValue = {"stringtest1", "string@test2", "string@!#test2"};
468 WantIn_->SetParam(std::string("string_arraykey"), stringArrayValue);
469
470 Want wantCopy(*WantIn_);
471 std::vector<std::string> teststringArrayValue1 = WantIn_->GetStringArrayParam(std::string("string_arraykey"));
472 std::vector<std::string> teststringArrayValue2 = wantCopy.GetStringArrayParam(std::string("string_arraykey"));
473 bool copyarraycompare = CompareArrayData<std::string>(teststringArrayValue1, teststringArrayValue1);
474 EXPECT_EQ(copyarraycompare, true);
475 std::string str = (copyarraycompare == true) ? "true" : "false";
476 GTEST_LOG_(INFO) << "copyarraycompare=" << str.c_str();
477
478 Parcel in;
479 bool result = false;
480 result = WantIn_->Marshalling(in);
481 EXPECT_EQ(result, true);
482 std::shared_ptr<Want> WantOut_(Want::Unmarshalling(in));
483 if (WantOut_ != nullptr) {
484 GTEST_LOG_(INFO) << "WantOut_->GetAction().c_str(): " << WantOut_->GetAction().c_str();
485 EXPECT_STREQ(WantOut_->GetAction().c_str(), std::string("system.test.action").c_str());
486
487 int flags = WantOut_->GetFlags();
488 GTEST_LOG_(INFO) << "WantOut_->GetFlags(): " << flags;
489 EXPECT_EQ(((int)(flags)), 64);
490
491 bool hasentity = WantOut_->HasEntity("system.test.entity");
492 GTEST_LOG_(INFO) << "WantOut_->HasEntity(system.test.entity)" << hasentity;
493 EXPECT_EQ(hasentity, true);
494
495 WantOut_->RemoveEntity(std::string("system.test.entity"));
496 hasentity = WantOut_->HasEntity(std::string("system.test.entity"));
497 GTEST_LOG_(INFO) << "WantOut_->RemoveEntity(system.test.entity)" << hasentity;
498 EXPECT_EQ(hasentity, false);
499
500 std::string outtype = WantOut_->GetType();
501 GTEST_LOG_(INFO) << "WantOut_->GetType()" << outtype.c_str();
502 EXPECT_STREQ(outtype.c_str(), std::string("system.test.uritype").c_str());
503
504 element = WantOut_->GetElement();
505 GTEST_LOG_(INFO) << "element.GetAbilityName().c_str(): " << element.GetAbilityName().c_str();
506 EXPECT_STREQ(element.GetAbilityName().c_str(), std::string("system.test.abilityname").c_str());
507
508 GTEST_LOG_(INFO) << "element->GetBundleName().c_str(): " << element.GetBundleName().c_str();
509 EXPECT_STREQ(element.GetBundleName().c_str(), std::string("system.test.bundlename").c_str());
510
511 GTEST_LOG_(INFO) << "element.GetDeviceID().c_str(): " << element.GetDeviceID().c_str();
512 EXPECT_STREQ(element.GetDeviceID().c_str(), std::string("system.test.deviceid").c_str());
513
514 std::string param_content = WantOut_->GetStringParam(keyStr);
515 GTEST_LOG_(INFO) << "WantOut_->GetStringParam(keyStr): " << param_content.c_str();
516
517 // want SetParam arraydata test
518 std::vector<bool> retboolArray;
519 retboolArray = WantOut_->GetBoolArrayParam(std::string("bool_arraykey"));
520
521 bool arraycompare = CompareArrayData<bool>(retboolArray, boolArrayValue);
522 EXPECT_EQ(arraycompare, true);
523
524 std::vector<byte> retbyteArrayValue;
525 retbyteArrayValue = WantOut_->GetByteArrayParam(std::string("byte_arraykey"));
526 arraycompare = CompareArrayData<byte>(retbyteArrayValue, byteArrayValue);
527 EXPECT_EQ(arraycompare, true);
528
529 std::vector<zchar> retcharArrayValue;
530 retcharArrayValue = WantOut_->GetCharArrayParam(std::string("char_arraykey"));
531 arraycompare = CompareArrayData<zchar>(retcharArrayValue, charArrayValue);
532 EXPECT_EQ(arraycompare, true);
533
534 std::vector<short> retshortArrayValue;
535 retshortArrayValue = WantOut_->GetShortArrayParam(std::string("short_arraykey"));
536 arraycompare = CompareArrayData<short>(retshortArrayValue, shortArrayValue);
537 EXPECT_EQ(arraycompare, true);
538
539 std::vector<int> retintArrayValue;
540 retintArrayValue = WantOut_->GetIntArrayParam(std::string("int_arraykey"));
541 arraycompare = CompareArrayData<int>(retintArrayValue, intArrayValue);
542 EXPECT_EQ(arraycompare, true);
543
544 std::vector<long> retlonArrayValue;
545 retlonArrayValue = WantOut_->GetLongArrayParam(std::string("long_arraykey"));
546 arraycompare = CompareArrayData<long>(retlonArrayValue, longArrayValue);
547 EXPECT_EQ(arraycompare, true);
548
549 std::vector<float> retfloatArrayValue;
550 retfloatArrayValue = WantOut_->GetFloatArrayParam(std::string("float_arraykey"));
551 arraycompare = CompareArrayData<float>(retfloatArrayValue, floatArrayValue);
552 EXPECT_EQ(arraycompare, true);
553
554 std::vector<double> retdoubleArrayValue;
555 retdoubleArrayValue = WantOut_->GetDoubleArrayParam(std::string("double_arraykey"));
556 arraycompare = CompareArrayData<double>(retdoubleArrayValue, doubleArrayValue);
557 EXPECT_EQ(arraycompare, true);
558
559 std::vector<std::string> retstringArrayValue;
560 retstringArrayValue = WantOut_->GetStringArrayParam(std::string("string_arraykey"));
561 arraycompare = CompareArrayData<std::string>(retstringArrayValue, stringArrayValue);
562 EXPECT_EQ(arraycompare, true);
563
564 GTEST_LOG_(INFO) << "AaFwk_Want_Parcelable_005 end";
565 }
566 }
567
CompareWant(const std::shared_ptr<Want> & want1,const std::shared_ptr<Want> & want2) const568 void WantBaseTest::CompareWant(const std::shared_ptr<Want> &want1, const std::shared_ptr<Want> &want2) const
569 {
570 Operation opt1 = want1->GetOperation();
571 Operation opt2 = want2->GetOperation();
572 EXPECT_EQ(opt1.GetDeviceId(), opt2.GetDeviceId());
573 EXPECT_EQ(opt1.GetBundleName(), opt2.GetBundleName());
574 EXPECT_EQ(opt1.GetAbilityName(), opt2.GetAbilityName());
575
576 EXPECT_EQ(want1->GetAction(), want2->GetAction());
577 EXPECT_EQ(want1->GetFlags(), want2->GetFlags());
578 EXPECT_EQ(want1->GetType(), want2->GetType());
579 EXPECT_EQ(want1->CountEntities(), want2->CountEntities());
580
581 int count = want1->CountEntities();
582 std::vector<std::string> entities1 = want1->GetEntities();
583 std::vector<std::string> entities2 = want2->GetEntities();
584 for (int i = 0; i < count; i++) {
585 EXPECT_EQ(entities1.at(i), entities2.at(i));
586 }
587
588 OHOS::AppExecFwk::ElementName element1 = want1->GetElement();
589 OHOS::AppExecFwk::ElementName element2 = want2->GetElement();
590 EXPECT_EQ(element1.GetURI(), element1.GetURI());
591
592 std::set<std::string> key1;
593 std::set<std::string> key2;
594 key1 = want1->GetParams().KeySet();
595 key2 = want2->GetParams().KeySet();
596 EXPECT_EQ(key1.size(), key2.size());
597
598 std::set<std::string>::iterator iter1 = key1.begin();
599 std::set<std::string>::iterator iter2 = key2.begin();
600 for (; (iter1 != key1.end() && iter2 != key2.end()); iter1++, iter2++) {
601 EXPECT_EQ(*iter1, *iter2);
602 }
603 }
604
CompareWant(const std::shared_ptr<Want> & want1,const std::shared_ptr<Want> & want2,std::map<std::string,std::string> & keys) const605 bool WantBaseTest::CompareWant(const std::shared_ptr<Want> &want1, const std::shared_ptr<Want> &want2,
606 std::map<std::string, std::string> &keys) const
607 {
608 if (want1 == nullptr || want2 == nullptr) {
609 return false;
610 }
611 EXPECT_STREQ(want1->GetAction().c_str(), want2->GetAction().c_str());
612 EXPECT_EQ(want1->CountEntities(), want2->CountEntities());
613
614 if (want1->CountEntities() != want2->CountEntities()) {
615 return false;
616 }
617
618 int count = want1->CountEntities();
619
620 std::vector<std::string> entities1 = want1->GetEntities();
621 std::vector<std::string> entities2 = want2->GetEntities();
622 for (int i = 0; i < count; i++) {
623 EXPECT_EQ(entities1.at(i), entities2.at(i));
624 }
625 EXPECT_EQ(want1->GetFlags(), want2->GetFlags());
626 EXPECT_EQ(want1->GetElement(), want2->GetElement());
627
628 for (auto it = keys.begin(); it != keys.end(); it++) {
629 if (it->second == boolType) {
630 bool v1 = want1->GetBoolParam(it->first, false);
631 bool v2 = want2->GetBoolParam(it->first, false);
632 EXPECT_EQ(v1, v2);
633 EXPECT_EQ(v1, true);
634 } else if (it->second == boolArrayType) {
635 std::vector<bool> v1 = want1->GetBoolArrayParam(it->first);
636 std::vector<bool> v2 = want2->GetBoolArrayParam(it->first);
637 EXPECT_EQ(v1, v2);
638 } else if (it->second == byteType) {
639 byte v1 = want1->GetByteParam(it->first, 'j');
640 byte v2 = want2->GetByteParam(it->first, 'k');
641 EXPECT_EQ(v1, v2);
642 } else if (it->second == byteArrayType) {
643 std::vector<byte> v1 = want1->GetByteArrayParam(it->first);
644 std::vector<byte> v2 = want2->GetByteArrayParam(it->first);
645 EXPECT_EQ(v1, v2);
646 } else if (it->second == charType) {
647 zchar v1 = want1->GetCharParam(it->first, 0x01AB);
648 zchar v2 = want2->GetCharParam(it->first, 0x02CD);
649 EXPECT_EQ(v1, v2);
650 } else if (it->second == charArrayType) {
651 std::vector<zchar> v1 = want1->GetCharArrayParam(it->first);
652 std::vector<zchar> v2 = want2->GetCharArrayParam(it->first);
653 EXPECT_EQ(v1, v2);
654 } else if (it->second == shortType) {
655 short default1 = 123;
656 short default2 = 456;
657 short v1 = want1->GetShortParam(it->first, default1);
658 short v2 = want2->GetShortParam(it->first, default2);
659 EXPECT_EQ(v1, v2);
660 } else if (it->second == shortArrayType) {
661 std::vector<short> v1 = want1->GetShortArrayParam(it->first);
662 std::vector<short> v2 = want2->GetShortArrayParam(it->first);
663 EXPECT_EQ(v1, v2);
664 } else if (it->second == intType) {
665 int default1 = 1230000;
666 int default2 = 4560000;
667 int v1 = want1->GetIntParam(it->first, default1);
668 int v2 = want2->GetIntParam(it->first, default2);
669 EXPECT_EQ(v1, v2);
670 } else if (it->second == intArrayType) {
671 std::vector<int> v1 = want1->GetIntArrayParam(it->first);
672 std::vector<int> v2 = want2->GetIntArrayParam(it->first);
673 EXPECT_EQ(v1, v2);
674 } else if (it->second == longType) {
675 long default1 = 1e8;
676 long default2 = 2e8;
677 long v1 = want1->GetLongParam(it->first, default1);
678 long v2 = want2->GetLongParam(it->first, default2);
679 EXPECT_EQ(v1, v2);
680 } else if (it->second == longArrayType) {
681 std::vector<long> v1 = want1->GetLongArrayParam(it->first);
682 std::vector<long> v2 = want2->GetLongArrayParam(it->first);
683 EXPECT_EQ(v1, v2);
684 } else if (it->second == floatType) {
685 float default1 = 12.3;
686 float default2 = 45.6;
687 float v1 = want1->GetFloatParam(it->first, default1);
688 float v2 = want2->GetFloatParam(it->first, default2);
689 EXPECT_EQ(v1, v2);
690 } else if (it->second == floatArrayType) {
691 std::vector<float> v1 = want1->GetFloatArrayParam(it->first);
692 std::vector<float> v2 = want2->GetFloatArrayParam(it->first);
693 EXPECT_EQ(v1, v2);
694 } else if (it->second == doubleType) {
695 double default1 = 12.3;
696 double default2 = 45.6;
697 double v1 = want1->GetDoubleParam(it->first, default1);
698 double v2 = want2->GetDoubleParam(it->first, default2);
699 EXPECT_EQ(v1, v2);
700 } else if (it->second == doubleArrayType) {
701 std::vector<double> v1 = want1->GetDoubleArrayParam(it->first);
702 std::vector<double> v2 = want2->GetDoubleArrayParam(it->first);
703 EXPECT_EQ(v1, v2);
704 } else if (it->second == stringType) {
705 std::string v1 = want1->GetStringParam(it->first);
706 std::string v2 = want2->GetStringParam(it->first);
707 EXPECT_EQ(v1, v2);
708 } else if (it->second == stringArrayType) {
709 std::vector<std::string> v1 = want1->GetStringArrayParam(it->first);
710 std::vector<std::string> v2 = want2->GetStringArrayParam(it->first);
711 EXPECT_EQ(v1, v2);
712 }
713 }
714
715 return true;
716 }
717
SendParcelTest(const std::shared_ptr<Want> & want,std::map<std::string,std::string> & keys) const718 void WantBaseTest::SendParcelTest(const std::shared_ptr<Want> &want, std::map<std::string, std::string> &keys) const
719 {
720 size_t pos1;
721 size_t pos2;
722 Parcel data;
723 bool result = false;
724
725 pos1 = data.GetWritePosition();
726 result = data.WriteParcelable(want.get());
727 pos2 = data.GetWritePosition();
728 EXPECT_EQ(result, true);
729 GTEST_LOG_(INFO) << "SendParcelTest: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
730
731 std::shared_ptr<Want> wantNew(data.ReadParcelable<Want>());
732 EXPECT_NE(wantNew, nullptr);
733
734 if (wantNew != nullptr) {
735 result = CompareWant(want, wantNew, keys);
736 EXPECT_EQ(result, true);
737 }
738 }
739
AddBoolParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const740 void WantBaseTest::AddBoolParams(
741 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
742 {
743 std::string key;
744 std::string boolKey = "boolKey";
745 std::string boolArrayKey = "boolArrayKey";
746 for (int i = 0; i < loop; i++) {
747 if (flag & FLAG_TEST_SINGLE) {
748 bool boolValue = true;
749 keys[boolKey + std::to_string(i)] = boolType;
750 want.SetParam(boolKey + std::to_string(i), boolValue);
751 }
752
753 if (flag & FLAG_TEST_ARRAY) {
754 std::vector<bool> boolArrayValue = {true, false, true};
755 keys[key] = boolArrayType;
756 want.SetParam(key, boolArrayValue);
757 }
758 }
759 }
760
AddByteParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const761 void WantBaseTest::AddByteParams(
762 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
763 {
764 std::string key;
765 std::string byteKey = "byteKey";
766 std::string byteArrayKey = "byteArrayKey";
767 for (int i = 0; i < loop; i++) {
768 if (flag & FLAG_TEST_SINGLE) {
769 byte byteValue = 'z';
770 key = byteKey + std::to_string(i);
771 keys[key] = byteType;
772 want.SetParam(key, byteValue);
773 }
774
775 if (flag & FLAG_TEST_ARRAY) {
776 std::vector<byte> byteArrayValue = {'?', 'a', '\\'};
777 key = byteArrayKey + std::to_string(i);
778 keys[key] = byteArrayType;
779 want.SetParam(key, byteArrayValue);
780 }
781 }
782 }
783
AddCharParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const784 void WantBaseTest::AddCharParams(
785 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
786 {
787 std::string key;
788 std::string charKey = "charKey";
789 std::string charArrayKey = "charArrayKey";
790 for (int i = 0; i < loop; i++) {
791 if (flag & FLAG_TEST_SINGLE) {
792 zchar charValue = U'h';
793 key = charKey + std::to_string(i);
794 keys[key] = charType;
795 want.SetParam(key, charValue);
796 }
797
798 if (flag & FLAG_TEST_ARRAY) {
799 std::vector<zchar> charArrayValue = {U'e', U'l', U'l', U'o'};
800 key = charArrayKey + std::to_string(i);
801 keys[key] = charArrayType;
802 want.SetParam(key, charArrayValue);
803 }
804 }
805 }
806
AddShortParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const807 void WantBaseTest::AddShortParams(
808 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
809 {
810 std::string key;
811 std::string shortKey = "shortKey";
812 std::string shortArrayKey = "shortArrayKey";
813 for (int i = 0; i < loop; i++) {
814 if (flag & FLAG_TEST_SINGLE) {
815 short shortValue = 1;
816 key = shortKey + std::to_string(i);
817 keys[key] = shortType;
818 want.SetParam(key, shortValue);
819 }
820
821 if (flag & FLAG_TEST_ARRAY) {
822 std::vector<short> shortArrayValue = {-1, 0, 1};
823 key = shortArrayKey + std::to_string(i);
824 keys[key] = shortArrayType;
825 want.SetParam(key, shortArrayValue);
826 }
827 }
828 }
829
AddIntParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const830 void WantBaseTest::AddIntParams(Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
831 {
832 std::string key;
833 std::string intKey = "intKey";
834 std::string intArrayKey = "intArrayKey";
835 for (int i = 0; i < loop; i++) {
836 if (flag & FLAG_TEST_SINGLE) {
837 int intValue = 10;
838 key = intKey + std::to_string(i);
839 keys[key] = intType;
840 want.SetParam(key, intValue);
841 }
842
843 if (flag & FLAG_TEST_ARRAY) {
844 std::vector<int> intArrayValue = {-10, 0, 10};
845 key = intArrayKey + std::to_string(i);
846 keys[key] = intArrayType;
847 want.SetParam(key, intArrayValue);
848 }
849 }
850 }
851
AddLongParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const852 void WantBaseTest::AddLongParams(
853 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
854 {
855 std::string key;
856 std::string longKey = "longKey";
857 std::string longArrayKey = "longArrayKey";
858 for (int i = 0; i < loop; i++) {
859 if (flag & FLAG_TEST_SINGLE) {
860 long longValue = 100L;
861 key = longKey + std::to_string(i);
862 keys[key] = longType;
863 want.SetParam(key, longValue);
864 }
865
866 if (flag & FLAG_TEST_ARRAY) {
867 std::vector<long> longArrayValue = {-100, 0, 100};
868 key = longArrayKey + std::to_string(i);
869 keys[key] = longArrayType;
870 want.SetParam(key, longArrayValue);
871 }
872 }
873 }
874
AddFloatParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const875 void WantBaseTest::AddFloatParams(
876 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
877 {
878 std::string key;
879 std::string floatKey = "floatKey";
880 std::string floatArrayKey = "floatArrayKey";
881 for (int i = 0; i < loop; i++) {
882 if (flag & FLAG_TEST_SINGLE) {
883 float floatValue = 100.1f;
884 key = floatKey + std::to_string(i);
885 keys[key] = floatType;
886 want.SetParam(key, floatValue);
887 }
888
889 if (flag & FLAG_TEST_ARRAY) {
890 std::vector<float> floatArrayValue = {-100.1, 0.1, 100.1};
891 key = floatArrayKey + std::to_string(i);
892 keys[key] = floatArrayType;
893 want.SetParam(key, floatArrayValue);
894 }
895 }
896 }
897
AddDoubleParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const898 void WantBaseTest::AddDoubleParams(
899 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
900 {
901 std::string key;
902 std::string doubleKey = "doubleKey";
903 std::string doubleArrayKey = "doubleArrayKey";
904 for (int i = 0; i < loop; i++) {
905 if (flag & FLAG_TEST_SINGLE) {
906 double doubleValue = 1000.1;
907 key = doubleKey + std::to_string(i);
908 keys[key] = doubleType;
909 want.SetParam(key, doubleValue);
910 }
911
912 if (flag & FLAG_TEST_ARRAY) {
913 std::vector<double> doubleArrayValue = {-1000.1, 0.1, 1000.1};
914 key = doubleArrayKey + std::to_string(i);
915 keys[key] = doubleArrayType;
916 want.SetParam(key, doubleArrayValue);
917 }
918 }
919 }
920
AddStringParams(Want & want,std::map<std::string,std::string> & keys,int loop,unsigned int flag) const921 void WantBaseTest::AddStringParams(
922 Want &want, std::map<std::string, std::string> &keys, int loop, unsigned int flag) const
923 {
924 std::string key;
925 std::string stringKey = "stringKey";
926 std::string stringArrayKey = "stringArrayKey";
927 for (int i = 0; i < loop; i++) {
928 if (flag & FLAG_TEST_SINGLE) {
929 string stringValue = "zzzz";
930 key = stringKey + std::to_string(i);
931 keys[key] = stringType;
932 want.SetParam(key, stringValue);
933 }
934
935 if (flag & FLAG_TEST_ARRAY) {
936 std::vector<std::string> stringArrayValue = {"??", "aa", "\\\\"};
937 key = stringArrayKey + std::to_string(i);
938 keys[key] = stringArrayType;
939 want.SetParam(key, stringArrayValue);
940 }
941 }
942 }
943
944 /**
945 * @tc.number: AaFwk_Want_Parcelable_0600
946 * @tc.name: parcelable
947 * @tc.desc: Verify parcelable.
948 */
949 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0600, Function | MediumTest | Level1)
950 {
951 std::string action = "want.action.test";
952 unsigned int flag = 0x789;
953 std::string entity = "want.entity.test";
954 OHOS::AppExecFwk::ElementName element("bundlename", "appname", "abilityname");
955
956 std::shared_ptr<Want> want = std::make_shared<Want>();
957 if (want != nullptr) {
958 want->SetAction(action);
959 want->AddEntity(entity);
960 want->AddFlags(flag);
961 want->SetElement(element);
962
963 std::map<std::string, std::string> keys;
964
965 SendParcelTest(want, keys);
966 }
967 }
968
969 /**
970 * @tc.number: AaFwk_Want_Parcelable_0700
971 * @tc.name: parcelable
972 * @tc.desc: Verify parcelable.
973 */
974 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0700, Function | MediumTest | Level1)
975 {
976 std::string action = "want.action.test";
977 unsigned int flag = 0x789;
978 std::string entity = "want.entity.test";
979 OHOS::AppExecFwk::ElementName element("bundlename", "appname", "abilityname");
980
981 std::shared_ptr<Want> want = std::make_shared<Want>();
982 if (want != nullptr) {
983 want->SetAction(action);
984 want->AddEntity(entity);
985 want->AddFlags(flag);
986 want->SetElement(element);
987
988 int loop = 1;
989 std::map<std::string, std::string> keys;
990
991 AddByteParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
992 AddCharParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
993 AddShortParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
994 AddIntParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
995 AddLongParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
996 AddFloatParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
997 AddDoubleParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
998 AddStringParams(*(want.get()), keys, loop, FLAG_TEST_BOTH);
999
1000 SendParcelTest(want, keys);
1001 }
1002 }
1003
1004 /**
1005 * @tc.number: AaFwk_Want_Parcelable_0800
1006 * @tc.name: parcelable
1007 * @tc.desc: Verify parcelable.
1008 */
1009 HWTEST_F(WantBaseTest, AaFwk_Want_Parcelable_0800, Function | MediumTest | Level1)
1010 {
1011 std::string action = "want.action.test";
1012 unsigned int flag = 0x789;
1013 std::string entity = "want.entity.test";
1014 OHOS::AppExecFwk::ElementName element("bundlename", "appname", "abilityname");
1015
1016 std::shared_ptr<Want> want = std::make_shared<Want>();
1017 if (want != nullptr) {
1018 want->SetAction(action);
1019 want->AddEntity(entity);
1020 want->AddFlags(flag);
1021 want->SetElement(element);
1022 std::map<std::string, std::string> keys;
1023
1024 SendParcelTest(want, keys);
1025 }
1026 }
1027
1028 /**
1029 * @tc.number: AaFwk_Want_FormatMimeType_0100
1030 * @tc.name: formatMimeType
1031 * @tc.desc: formats data of a specified MIME type.
1032 */
1033 HWTEST_F(WantBaseTest, AaFwk_Want_FormatMimeType_0100, Function | MediumTest | Level1)
1034 {
1035 std::string mimeType = "Application/Envoy";
1036 std::string mimeTypeResult = "application/envoy";
1037
1038 EXPECT_EQ(mimeTypeResult, Want::FormatMimeType(mimeType));
1039 }
1040
1041 /**
1042 * @tc.number: AaFwk_Want_FormatMimeType_0200
1043 * @tc.name: formatMimeType
1044 * @tc.desc: formats data of a specified MIME type.
1045 */
1046 HWTEST_F(WantBaseTest, AaFwk_Want_FormatMimeType_0200, Function | MediumTest | Level1)
1047 {
1048 std::string mimeType = "APPLICATION/ENVOY";
1049 std::string mimeTypeResult = "application/envoy";
1050
1051 EXPECT_EQ(mimeTypeResult, Want::FormatMimeType(mimeType));
1052 }
1053
1054 /**
1055 * @tc.number: AaFwk_Want_FormatMimeType_0300
1056 * @tc.name: formatMimeType
1057 * @tc.desc: formats data of a specified MIME type.
1058 */
1059 HWTEST_F(WantBaseTest, AaFwk_Want_FormatMimeType_0300, Function | MediumTest | Level1)
1060 {
1061 std::string mimeType = " Appl icati on/ Envoy ";
1062 std::string mimeTypeResult = "application/envoy";
1063
1064 EXPECT_EQ(mimeTypeResult, Want::FormatMimeType(mimeType));
1065 }
1066
1067 /**
1068 * @tc.number: AaFwk_Want_FormatMimeType_0400
1069 * @tc.name: formatMimeType
1070 * @tc.desc: formats data of a specified MIME type.
1071 */
1072 HWTEST_F(WantBaseTest, AaFwk_Want_FormatMimeType_0400, Function | MediumTest | Level1)
1073 {
1074 std::string mimeType = " Appl icati on/ Envoy ; yovnE ;no itaci lppA ";
1075 std::string mimeTypeResult = "application/envoy";
1076
1077 EXPECT_EQ(mimeTypeResult, Want::FormatMimeType(mimeType));
1078 }
1079
1080 /**
1081 * @tc.number: AaFwk_Want_ParseUri_ToUri_0100
1082 * @tc.name: ParseUri and ToUri
1083 * @tc.desc: Verify the function when Want is empty.
1084 */
1085 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0100, Function | MediumTest | Level1)
1086 {
1087 std::size_t pos = 0;
1088 std::size_t content = 0;
1089 std::size_t head = 0;
1090 Want wantOrigin;
1091
1092 std::string uri = wantOrigin.ToUri();
1093
1094 head = uri.find(WantBaseTest::URI_STRING_HEAD, pos);
1095 EXPECT_EQ(head, pos);
1096 if (head != std::string::npos) {
1097 pos += head + WantBaseTest::URI_STRING_HEAD.length() - 1;
1098 }
1099
1100 content = uri.find(WantBaseTest::URI_STRING_END, pos);
1101 EXPECT_EQ(content, pos);
1102 if (content != std::string::npos) {
1103 pos += WantBaseTest::URI_STRING_END.length();
1104 }
1105
1106 EXPECT_EQ(uri.length(), pos);
1107
1108 Want *wantNew = Want::ParseUri(uri);
1109 EXPECT_NE(wantNew, nullptr);
1110
1111 if (wantNew != nullptr) {
1112 EXPECT_EQ(wantNew->GetAction(), std::string(""));
1113 for (auto entity : wantNew->GetEntities()) {
1114 EXPECT_EQ(entity, std::string(""));
1115 }
1116 OHOS::AppExecFwk::ElementName element;
1117 EXPECT_EQ(wantNew->GetElement(), element);
1118 EXPECT_EQ(static_cast<int>(wantNew->GetFlags()), 0);
1119
1120 delete wantNew;
1121 }
1122 }
1123
1124 /**
1125 * @tc.number: AaFwk_Want_ParseUri_ToUri_0200
1126 * @tc.name: ParseUri and ToUri
1127 * @tc.desc: Verify the function when Want only has action/entity/flag/element.
1128 */
1129 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0200, Function | MediumTest | Level1)
1130 {
1131 std::string search;
1132
1133 std::string action = Want::ACTION_PLAY;
1134 std::string entity = Want::ENTITY_VIDEO;
1135 unsigned int flag = 0x0f0f0f0f;
1136 std::string flagStr = "0x0f0f0f0f";
1137 std::string device = "device1";
1138 std::string bundle = "bundle1";
1139 std::string ability = "ability1";
1140 OHOS::AppExecFwk::ElementName element(device, bundle, ability);
1141
1142 Want wantOrigin;
1143 wantOrigin.SetAction(action);
1144 wantOrigin.AddEntity(entity);
1145 wantOrigin.AddFlags(flag);
1146 wantOrigin.SetElement(element);
1147
1148 std::string uri = wantOrigin.ToUri();
1149 Want *wantNew = Want::ParseUri(uri);
1150 EXPECT_NE(wantNew, nullptr);
1151
1152 if (wantNew != nullptr) {
1153 EXPECT_EQ(wantNew->GetAction(), action);
1154 for (auto entityItem : wantNew->GetEntities()) {
1155 EXPECT_EQ(entityItem, entity);
1156 }
1157 EXPECT_EQ(wantNew->GetElement().GetDeviceID(), device);
1158 EXPECT_EQ(wantNew->GetElement().GetBundleName(), bundle);
1159 EXPECT_EQ(wantNew->GetElement().GetAbilityName(), ability);
1160 EXPECT_EQ(wantNew->GetFlags(), flag);
1161
1162 delete wantNew;
1163 wantNew = nullptr;
1164 }
1165 }
1166
1167 /**
1168 * @tc.number: AaFwk_Want_ParseUri_ToUri_0300
1169 * @tc.name: ParseUri and ToUri
1170 * @tc.desc: Verify the function when Want only has parameter and the parameter
1171 * has only 1 float type element.
1172 */
1173 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0300, Function | MediumTest | Level1)
1174 {
1175 std::string search;
1176 std::string substring;
1177 std::size_t pos = 0;
1178 std::size_t length = 0;
1179 std::size_t result = 0;
1180 std::size_t delims = 0;
1181 std::size_t head = 0;
1182 Want wantOrigin;
1183 std::string keyFloat = "keyFloat";
1184 float valueFloatOrigin = 123.4;
1185 wantOrigin.SetParam(keyFloat, valueFloatOrigin);
1186
1187 std::string uri = wantOrigin.ToUri();
1188
1189 search = WantBaseTest::URI_STRING_HEAD;
1190 result = uri.find(search, pos);
1191 EXPECT_EQ(result, pos);
1192 if (result != std::string::npos) {
1193 head = result + search.length();
1194 }
1195 length += head;
1196
1197 search = Float::SIGNATURE + std::string(".") + keyFloat + std::string("=");
1198 result = uri.find(search);
1199 EXPECT_NE(result, std::string::npos);
1200 EXPECT_GE(result, head);
1201 length += search.length();
1202 if (result != std::string::npos) {
1203 pos = result + search.length();
1204 delims = uri.find(";", pos);
1205 if (delims != std::string::npos) {
1206 substring = uri.substr(pos, delims - pos);
1207 float valueFloatNew = Float::Unbox(Float::Parse(substring));
1208 EXPECT_EQ(valueFloatNew, valueFloatOrigin);
1209 length += substring.length() + 1;
1210 }
1211 }
1212
1213 search = WantBaseTest::URI_STRING_END;
1214 result = uri.find(search);
1215 EXPECT_NE(result, std::string::npos);
1216 EXPECT_GE(result, head);
1217 if (result != std::string::npos) {
1218 length += search.length() - 1;
1219 }
1220
1221 EXPECT_EQ(uri.length(), length);
1222
1223 Want *wantNew = Want::ParseUri(uri);
1224 EXPECT_NE(wantNew, nullptr);
1225
1226 if (wantNew != nullptr) {
1227 float floatNew = wantNew->GetFloatParam(keyFloat, 0.1);
1228 float floatOld = wantOrigin.GetFloatParam(keyFloat, 1.1);
1229 EXPECT_EQ(floatNew, floatOld);
1230 delete wantNew;
1231 }
1232 }
1233
1234 /**
1235 * @tc.number: AaFwk_Want_ParseUri_ToUri_0400
1236 * @tc.name: ParseUri and ToUri
1237 * @tc.desc: Verify the function when Want only has parameter and the parameter
1238 * has only one float and one string type element.
1239 */
1240 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0400, Function | MediumTest | Level1)
1241 {
1242 std::string search;
1243 std::string substring;
1244 std::size_t pos = 0;
1245 std::size_t length = 0;
1246 std::size_t result = 0;
1247 std::size_t delims = 0;
1248 std::size_t head = 0;
1249 Want wantOrigin;
1250 std::string keyFloat = "keyFloat";
1251 std::string keyString = "keyString";
1252 float valueFloatOrigin = 123.4;
1253 std::string valueStringOrigin = "abcd";
1254 wantOrigin.SetParam(keyFloat, valueFloatOrigin);
1255 wantOrigin.SetParam(keyString, valueStringOrigin);
1256
1257 std::string uri = wantOrigin.ToUri();
1258
1259 search = WantBaseTest::URI_STRING_HEAD;
1260 result = uri.find(search, pos);
1261 EXPECT_NE(result, std::string::npos);
1262 EXPECT_EQ(result, pos);
1263 if (result != std::string::npos) {
1264 head = result + search.length();
1265 }
1266 length += head;
1267
1268 search = Float::SIGNATURE + std::string(".") + keyFloat + std::string("=");
1269 result = uri.find(search);
1270 EXPECT_NE(result, std::string::npos);
1271 EXPECT_GE(result, head);
1272 length += search.length();
1273 if (result != std::string::npos) {
1274 pos = result + search.length();
1275 delims = uri.find(";", pos);
1276 if (delims != std::string::npos) {
1277 substring = uri.substr(pos, delims - pos);
1278 float valueFloatNew = Float::Unbox(Float::Parse(substring));
1279 EXPECT_EQ(valueFloatNew, valueFloatOrigin);
1280 length += substring.length() + 1;
1281 }
1282 }
1283
1284 search = String::SIGNATURE + std::string(".") + keyString + std::string("=");
1285 result = uri.find(search);
1286 EXPECT_NE(result, std::string::npos);
1287 EXPECT_GE(result, head);
1288 length += search.length();
1289 if (result != std::string::npos) {
1290 pos = result + search.length();
1291 delims = uri.find(";", result);
1292 if (delims != std::string::npos) {
1293 std::string substring = uri.substr(pos, delims - pos);
1294 std::string valueStringNew = String::Unbox(String::Parse(substring));
1295 EXPECT_EQ(valueStringNew, valueStringOrigin);
1296 length += substring.length() + 1;
1297 }
1298 }
1299
1300 search = WantBaseTest::URI_STRING_END;
1301 result = uri.find(search);
1302 EXPECT_NE(result, std::string::npos);
1303 EXPECT_GE(result, head);
1304 if (result != std::string::npos) {
1305 length += search.length() - 1;
1306 }
1307
1308 EXPECT_EQ(uri.length(), length);
1309
1310 Want *wantNew = Want::ParseUri(uri);
1311 EXPECT_NE(wantNew, nullptr);
1312
1313 if (wantNew != nullptr) {
1314 float floatNew = wantNew->GetFloatParam(keyFloat, 0);
1315 float floatOld = wantOrigin.GetFloatParam(keyFloat, 1);
1316 EXPECT_EQ(floatNew, floatOld);
1317
1318 std::string stringNew = wantNew->GetStringParam(keyString);
1319 std::string stringOld = wantOrigin.GetStringParam(keyString);
1320 EXPECT_EQ(stringNew, stringOld);
1321
1322 delete wantNew;
1323 }
1324 }
1325
1326 /**
1327 * @tc.number: AaFwk_Want_ParseUri_ToUri_0500
1328 * @tc.name: ParseUri and ToUri
1329 * @tc.desc: Verify the function when Want only has parameter and the parameter
1330 * has only one float array type element.
1331 */
1332 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0500, Function | MediumTest | Level1)
1333 {
1334 std::string search;
1335 std::string substring;
1336 std::size_t pos = 0;
1337 std::size_t length = 0;
1338 std::size_t result = 0;
1339 std::size_t delims = 0;
1340 std::size_t head = 0;
1341 Want wantOrigin;
1342 std::string keyFloatArray = "keyFloatArray";
1343 std::vector<float> valueFloatArrayOrigin = {1.1, 2.1, 3.1};
1344 wantOrigin.SetParam(keyFloatArray, valueFloatArrayOrigin);
1345
1346 std::string uri = wantOrigin.ToUri();
1347
1348 search = WantBaseTest::URI_STRING_HEAD;
1349 result = uri.find(search, pos);
1350 EXPECT_NE(result, std::string::npos);
1351 EXPECT_EQ(result, pos);
1352 if (result != std::string::npos) {
1353 head = result + search.length();
1354 }
1355 length += head;
1356
1357 search = Array::SIGNATURE + std::string(".") + keyFloatArray + std::string("=");
1358 result = uri.find(search);
1359 EXPECT_NE(result, std::string::npos);
1360 EXPECT_GE(result, head);
1361 length += search.length();
1362 if (result != std::string::npos) {
1363 pos = result + search.length();
1364 delims = uri.find(";", result);
1365 if (delims != std::string::npos) {
1366 std::string substring = uri.substr(pos, delims - pos);
1367 sptr<IArray> array = Array::Parse(substring);
1368 std::vector<float> valueFloatArrayNew;
1369 auto func = [&valueFloatArrayNew](
__anond3d612830102( IInterface *object) 1370 IInterface *object) { valueFloatArrayNew.push_back(Float::Unbox(IFloat::Query(object))); };
1371 Array::ForEach(array, func);
1372 EXPECT_EQ(valueFloatArrayNew, valueFloatArrayOrigin);
1373 length += substring.length() + 1;
1374 }
1375 }
1376
1377 search = WantBaseTest::URI_STRING_END;
1378 result = uri.find(search);
1379 EXPECT_NE(result, std::string::npos);
1380 EXPECT_GE(result, head);
1381 if (result != std::string::npos) {
1382 length += search.length() - 1;
1383 }
1384
1385 EXPECT_EQ(uri.length(), length);
1386
1387 Want *wantNew = Want::ParseUri(uri);
1388 EXPECT_NE(wantNew, nullptr);
1389
1390 if (wantNew != nullptr) {
1391 std::vector<float> arrayNew = wantNew->GetFloatArrayParam(keyFloatArray);
1392 std::vector<float> arrayOld = wantOrigin.GetFloatArrayParam(keyFloatArray);
1393 EXPECT_EQ(arrayNew, arrayOld);
1394 delete wantNew;
1395 }
1396 }
1397
1398 /**
1399 * @tc.number: AaFwk_Want_ParseUri_ToUri_0600
1400 * @tc.name: ParseUri and ToUri
1401 * @tc.desc: Verify the function when Want only has parameter and the parameter
1402 * has only one int array and one string array type element
1403 */
1404 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0600, Function | MediumTest | Level1)
1405 {
1406 std::string search;
1407 std::string substring;
1408 std::size_t pos = 0;
1409 std::size_t length = 0;
1410 std::size_t result = 0;
1411 std::size_t delims = 0;
1412 std::size_t head = 0;
1413 Want wantOrigin;
1414 std::string keyFloatArray = "keyFloatArray";
1415 std::string keyStringArray = "keyStringArray";
1416 std::vector<float> valueFloatArrayOrigin = {1.1, 2.1, 3.1};
1417 std::vector<std::string> valueStringArrayOrigin = {"aa", "bb", "cc"};
1418 wantOrigin.SetParam(keyFloatArray, valueFloatArrayOrigin);
1419 wantOrigin.SetParam(keyStringArray, valueStringArrayOrigin);
1420
1421 std::string uri = wantOrigin.ToUri();
1422
1423 search = WantBaseTest::URI_STRING_HEAD;
1424 result = uri.find(search, pos);
1425 EXPECT_NE(result, std::string::npos);
1426 EXPECT_EQ(result, pos);
1427 if (result != std::string::npos) {
1428 head = result + search.length();
1429 }
1430 length += head;
1431
1432 search = Array::SIGNATURE + std::string(".") + keyFloatArray + std::string("=");
1433 result = uri.find(search);
1434 EXPECT_NE(result, std::string::npos);
1435 EXPECT_GE(result, head);
1436 length += search.length();
1437 if (result != std::string::npos) {
1438 pos = result + search.length();
1439 delims = uri.find(";", result);
1440 if (delims != std::string::npos) {
1441 std::string substring = uri.substr(pos, delims - pos);
1442 sptr<IArray> array = Array::Parse(substring);
1443 std::vector<float> valueFloatArrayNew;
1444 auto func = [&valueFloatArrayNew](
__anond3d612830202( IInterface *object) 1445 IInterface *object) { valueFloatArrayNew.push_back(Float::Unbox(IFloat::Query(object))); };
1446 Array::ForEach(array, func);
1447 EXPECT_EQ(valueFloatArrayNew, valueFloatArrayOrigin);
1448 length += substring.length() + 1;
1449 }
1450 }
1451
1452 search = Array::SIGNATURE + std::string(".") + keyStringArray + std::string("=");
1453 result = uri.find(search);
1454 EXPECT_NE(result, std::string::npos);
1455 EXPECT_GE(result, head);
1456 length += search.length();
1457 if (result != std::string::npos) {
1458 pos = result + search.length();
1459 delims = uri.find(";", result);
1460 if (delims != std::string::npos) {
1461 std::string substring = uri.substr(pos, delims - pos);
1462 sptr<IArray> array = Array::Parse(substring);
1463 std::vector<std::string> valueStringArrayNew;
__anond3d612830302(IInterface *object) 1464 auto func = [&valueStringArrayNew](IInterface *object) {
1465 valueStringArrayNew.push_back(String::Unbox(IString::Query(object)));
1466 };
1467 Array::ForEach(array, func);
1468 EXPECT_EQ(valueStringArrayNew, valueStringArrayOrigin);
1469 length += substring.length() + 1;
1470 }
1471 }
1472
1473 search = WantBaseTest::URI_STRING_END;
1474 result = uri.find(search);
1475 EXPECT_NE(result, std::string::npos);
1476 EXPECT_GE(result, head);
1477 if (result != std::string::npos) {
1478 length += search.length() - 1;
1479 }
1480
1481 EXPECT_EQ(uri.length(), length);
1482
1483 Want *wantNew = Want::ParseUri(uri);
1484 EXPECT_NE(wantNew, nullptr);
1485
1486 if (wantNew != nullptr) {
1487 std::vector<float> arrayFloatNew = wantNew->GetFloatArrayParam(keyFloatArray);
1488 std::vector<float> arrayFloatOld = wantOrigin.GetFloatArrayParam(keyFloatArray);
1489 EXPECT_EQ(arrayFloatNew, arrayFloatOld);
1490
1491 std::vector<std::string> arrayStringNew = wantNew->GetStringArrayParam(keyStringArray);
1492 std::vector<std::string> arrayStringOld = wantOrigin.GetStringArrayParam(keyStringArray);
1493 EXPECT_EQ(arrayStringNew, arrayStringOld);
1494
1495 delete wantNew;
1496 }
1497 }
1498
1499 /**
1500 * @tc.number: AaFwk_Want_ParseUri_ToUri_0700
1501 * @tc.name: ParseUri and ToUri
1502 * @tc.desc: Verify the function when the length of input string is 0.
1503 */
1504 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0700, Function | MediumTest | Level1)
1505 {
1506 std::string uri;
1507 EXPECT_EQ(static_cast<int>(uri.length()), 0);
1508
1509 Want *want = Want::ParseUri(uri);
1510 EXPECT_EQ(want, nullptr);
1511
1512 if (want != nullptr) {
1513 delete want;
1514 }
1515 }
1516
1517 /**
1518 * @tc.number: AaFwk_Want_ParseUri_ToUri_0800
1519 * @tc.name: ParseUri and ToUri
1520 * @tc.desc: Verify the function when the action etc. are empty.
1521 */
1522 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0800, Function | MediumTest | Level1)
1523 {
1524 std::string empty;
1525 std::string uri = "#Intent;action=;entity=;device=;bundle=;ability=;flag=;end";
1526 EXPECT_NE(static_cast<int>(uri.length()), 0);
1527
1528 Want *want = Want::ParseUri(uri);
1529 EXPECT_NE(want, nullptr);
1530
1531 if (want != nullptr) {
1532 EXPECT_EQ(want->GetAction(), empty);
1533 for (auto entityItem : want->GetEntities()) {
1534 EXPECT_EQ(entityItem, empty);
1535 }
1536 EXPECT_EQ(want->GetFlags(), (unsigned int)0);
1537 OHOS::AppExecFwk::ElementName element;
1538 EXPECT_EQ(want->GetElement(), element);
1539 EXPECT_EQ(want->HasParameter(empty), false);
1540 delete want;
1541 }
1542 }
1543
1544 /**
1545 * @tc.number: AaFwk_Want_ParseUri_ToUri_0900
1546 * @tc.name: ParseUri and ToUri
1547 * @tc.desc: Verify the function when flag is not number.
1548 */
1549 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_0900, Function | MediumTest | Level1)
1550 {
1551 std::string empty;
1552 std::string uri = "#Intent;action=want.action.VIEW;flag=\"123\";end";
1553 EXPECT_NE(static_cast<int>(uri.length()), 0);
1554
1555 Want *want = Want::ParseUri(uri);
1556 EXPECT_EQ(want, nullptr);
1557 if (want != nullptr) {
1558 delete want;
1559 want = nullptr;
1560 }
1561 }
1562
1563 /**
1564 * @tc.number: AaFwk_Want_ParseUri_ToUri_1000
1565 * @tc.name: ParseUri and ToUri
1566 * @tc.desc: Verify the function when head is not "#Intent".
1567 */
1568 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_1000, Function | MediumTest | Level1)
1569 {
1570 std::string empty;
1571 std::string uri = "action=want.action.VIEW;end";
1572 EXPECT_NE(static_cast<int>(uri.length()), 0);
1573
1574 Want *want = Want::ParseUri(uri);
1575 EXPECT_EQ(want, nullptr);
1576 if (want != nullptr) {
1577 delete want;
1578 want = nullptr;
1579 }
1580 }
1581
1582 /**
1583 * @tc.number: AaFwk_Want_ParseUri_ToUri_1100
1584 * @tc.name: ParseUri and ToUri
1585 * @tc.desc: Verify the function when flag is empty.
1586 */
1587 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_1100, Function | MediumTest | Level1)
1588 {
1589 std::string empty;
1590 std::string uri = "#Intent;flag=;end";
1591 EXPECT_NE(static_cast<int>(uri.length()), 0);
1592
1593 Want *want = Want::ParseUri(uri);
1594 EXPECT_NE(want, nullptr);
1595
1596 if (want != nullptr) {
1597 EXPECT_EQ(want->GetFlags(), static_cast<unsigned int>(0));
1598 delete want;
1599 }
1600 }
1601
1602 /**
1603 * @tc.number: AaFwk_Want_ParseUri_ToUri_1200
1604 * @tc.name: ParseUri and ToUri
1605 * @tc.desc: Verify the function when x is capital.
1606 */
1607 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_1200, Function | MediumTest | Level1)
1608 {
1609 std::string empty;
1610 unsigned int flag = 0X12345678;
1611 std::string uri = "#Intent;flag=0X12345678;end";
1612 EXPECT_NE(static_cast<int>(uri.length()), 0);
1613
1614 Want *want = Want::ParseUri(uri);
1615 EXPECT_NE(want, nullptr);
1616
1617 if (want != nullptr) {
1618 EXPECT_EQ(want->GetFlags(), flag);
1619 delete want;
1620 }
1621 }
1622
1623 /**
1624 * @tc.number: AaFwk_Want_ParseUri_ToUri_1300
1625 * @tc.name: ParseUri and ToUri
1626 * @tc.desc: Verify the function when special character.
1627 */
1628 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_1300, Function | MediumTest | Level1)
1629 {
1630 std::string action = "\\";
1631 std::string entity = "../../../jj/j=075/./.;;/07507399/\\\\;;--==.com.\a\b\tfoobar.vide\073\\075";
1632 unsigned int flag = 0x0f0f0f0f;
1633 std::string flagStr = "0x0f0f0f0f";
1634 std::string key = "\\kkk=.=;";
1635 std::string value = "==\\\\\\.;\\;\\;\\=\\\073075\\\\075073";
1636
1637 Want wantOrigin;
1638 wantOrigin.SetAction(action);
1639 wantOrigin.AddEntity(entity);
1640 wantOrigin.AddFlags(flag);
1641 wantOrigin.SetParam(key, value);
1642
1643 std::string uri = wantOrigin.ToUri();
1644
1645 Want *wantNew = Want::ParseUri(uri);
1646 EXPECT_NE(wantNew, nullptr);
1647
1648 if (wantNew != nullptr) {
1649 EXPECT_STREQ(wantNew->GetAction().c_str(), action.c_str());
1650 for (auto entityItem : wantNew->GetEntities()) {
1651 EXPECT_EQ(entityItem, entity);
1652 }
1653 EXPECT_EQ(wantNew->GetFlags(), flag);
1654 EXPECT_EQ(wantNew->GetStringParam(key), value);
1655
1656 delete wantNew;
1657 wantNew = nullptr;
1658 }
1659 }
1660
1661 /**
1662 * @tc.number: AaFwk_Want_ParseUri_ToUri_1400
1663 * @tc.name: ParseUri and ToUri
1664 * @tc.desc: Verify the function when no '=' or only has a '='.
1665 */
1666 HWTEST_F(WantBaseTest, AaFwk_Want_ParseUri_ToUri_1400, Function | MediumTest | Level1)
1667 {
1668 std::string uri = "#Intent;action;end";
1669 Want *want = Want::ParseUri(uri);
1670 EXPECT_EQ(want, nullptr);
1671 if (want != nullptr) {
1672 delete want;
1673 want = nullptr;
1674 }
1675
1676 uri = "#Intent;entity;end";
1677 want = Want::ParseUri(uri);
1678 EXPECT_EQ(want, nullptr);
1679 if (want != nullptr) {
1680 delete want;
1681 want = nullptr;
1682 }
1683
1684 uri = "#Intent;device;end";
1685 want = Want::ParseUri(uri);
1686 EXPECT_EQ(want, nullptr);
1687 if (want != nullptr) {
1688 delete want;
1689 want = nullptr;
1690 }
1691
1692 uri = "#Intent;bundle;end";
1693 want = Want::ParseUri(uri);
1694 EXPECT_EQ(want, nullptr);
1695 if (want != nullptr) {
1696 delete want;
1697 want = nullptr;
1698 }
1699
1700 uri = "#Intent;ability;end";
1701 want = Want::ParseUri(uri);
1702 EXPECT_EQ(want, nullptr);
1703 if (want != nullptr) {
1704 delete want;
1705 want = nullptr;
1706 }
1707
1708 uri = "#Intent;flag;end";
1709 want = Want::ParseUri(uri);
1710 EXPECT_EQ(want, nullptr);
1711 if (want != nullptr) {
1712 delete want;
1713 want = nullptr;
1714 }
1715
1716 uri = "#Intent;param;end";
1717 want = Want::ParseUri(uri);
1718 EXPECT_EQ(want, nullptr);
1719 if (want != nullptr) {
1720 delete want;
1721 want = nullptr;
1722 }
1723
1724 uri = "#Intent;=;end";
1725 want = Want::ParseUri(uri);
1726 EXPECT_NE(want, nullptr);
1727 if (want != nullptr) {
1728 delete want;
1729 want = nullptr;
1730 }
1731
1732 uri = "#Intent;abc=;end";
1733 want = Want::ParseUri(uri);
1734 EXPECT_NE(want, nullptr);
1735 if (want != nullptr) {
1736 delete want;
1737 want = nullptr;
1738 }
1739
1740 uri = "#Intent;=abc;end";
1741 want = Want::ParseUri(uri);
1742 EXPECT_NE(want, nullptr);
1743 if (want != nullptr) {
1744 delete want;
1745 want = nullptr;
1746 }
1747
1748 uri = "#Intent;xxxx=yyy;end";
1749 want = Want::ParseUri(uri);
1750 EXPECT_NE(want, nullptr);
1751 if (want != nullptr) {
1752 delete want;
1753 want = nullptr;
1754 }
1755
1756 uri = "#Intent;;;;;;end";
1757 want = Want::ParseUri(uri);
1758 EXPECT_NE(want, nullptr);
1759 if (want != nullptr) {
1760 delete want;
1761 want = nullptr;
1762 }
1763 }
1764
1765 /**
1766 * @tc.number: AaFwk_Want_Flags_0100
1767 * @tc.name: SetFlags/AddFlags/GetFlags/RemoveFlags
1768 * @tc.desc: Verify SetFlags/AddFlags/GetFlags/RemoveFlags.
1769 */
1770 HWTEST_F(WantBaseTest, AaFwk_Want_Flags_0100, Function | MediumTest | Level1)
1771 {
1772 int flags = 3;
1773 int returnsflags;
1774 int description = 8;
1775
1776 want_->SetFlags(description);
1777 want_->AddFlags(flags);
1778 returnsflags = want_->GetFlags();
1779 EXPECT_EQ(11, returnsflags);
1780
1781 want_->RemoveFlags(flags);
1782 returnsflags = want_->GetFlags();
1783 EXPECT_EQ(description, returnsflags);
1784 }
1785
1786 /**
1787 * @tc.number: AaFwk_Want_MakeMainAbility_0100
1788 * @tc.name: MakeMainAbility
1789 * @tc.desc: Verify MakeMainAbility.
1790 */
1791 HWTEST_F(WantBaseTest, AaFwk_Want_MakeMainAbility_0100, Function | MediumTest | Level1)
1792 {
1793 ElementName elementName;
1794
1795 std::string action("action.system.home");
1796 std::string entity("entity.system.home");
1797
1798 Want *wantNew = want_->MakeMainAbility(elementName);
1799 if (wantNew != nullptr) {
1800 std::vector<std::string> entities = wantNew->GetEntities();
1801
1802 EXPECT_EQ((size_t)1, entities.size());
1803 if (entities.size() > 0) {
1804 EXPECT_EQ(entity, entities.at(0));
1805 }
1806 EXPECT_EQ(action, wantNew->GetAction());
1807 EXPECT_EQ(elementName, wantNew->GetElement());
1808
1809 delete wantNew;
1810 wantNew = nullptr;
1811 }
1812 }
1813
1814 /**
1815 * @tc.number: AaFwk_Want_ClearWant_0100
1816 * @tc.name: ClearWant
1817 * @tc.desc: Verify ClearWant.
1818 */
1819 HWTEST_F(WantBaseTest, AaFwk_Want_ClearWant_0100, Function | MediumTest | Level1)
1820 {
1821 Want want;
1822 ElementName elementName;
1823 std::string empty = "";
1824 want_->ClearWant(&want);
1825
1826 EXPECT_EQ((uint)0, want_->GetFlags());
1827 EXPECT_EQ(empty, want_->GetType());
1828 EXPECT_EQ(empty, want_->GetAction());
1829 EXPECT_EQ(elementName, want_->GetElement());
1830 EXPECT_EQ((size_t)0, want_->GetEntities().size());
1831 EXPECT_EQ(0, want_->CountEntities());
1832 }
1833
1834 /**
1835 * @tc.number: AaFwk_Want_replaceParams_0100
1836 * @tc.name: replaceParams(wantParams)
1837 * @tc.desc: Verify the function when the input string is empty.
1838 */
1839 HWTEST_F(WantBaseTest, AaFwk_Want_replaceParams_0100, Function | MediumTest | Level1)
1840 {
1841 WantParams wantParams;
1842 std::string keyStr = "123";
1843 std::string valueStr = "123";
1844 wantParams.SetParam(keyStr, String::Box(valueStr));
1845 want_->ReplaceParams(wantParams);
1846
1847 EXPECT_EQ(valueStr, String::Unbox(IString::Query(want_->GetParams().GetParam(keyStr))));
1848 }
1849
1850 /**
1851 * @tc.number: AaFwk_Want_setElement_0100
1852 * @tc.name:setElement / setElementName
1853 * @tc.desc: Verify the function when the input string is empty.
1854 */
1855 HWTEST_F(WantBaseTest, AaFwk_Want_setElement_0100, Function | MediumTest | Level1)
1856 {
1857 std::string valueStr1 = "xxxxx";
1858 std::string valueStr2 = "uaid";
1859 std::string valueStr3 = "uaygfi";
1860
1861 OHOS::AppExecFwk::ElementName elementname1;
1862 OHOS::AppExecFwk::ElementName elementname2;
1863 OHOS::AppExecFwk::ElementName elementname3;
1864 ElementName elementname4;
1865 elementname1.SetAbilityName(valueStr1);
1866 elementname2.SetDeviceID(valueStr2);
1867 elementname3.SetBundleName(valueStr3);
1868 want_->SetElement(elementname1);
1869 EXPECT_EQ(valueStr1, want_->GetElement().GetAbilityName());
1870
1871 want_->SetElement(elementname2);
1872 EXPECT_EQ(valueStr2, want_->GetElement().GetDeviceID());
1873
1874 want_->SetElement(elementname3);
1875 EXPECT_EQ(valueStr3, want_->GetElement().GetBundleName());
1876
1877 want_->SetElementName(valueStr3, valueStr1);
1878 EXPECT_EQ(valueStr1, want_->GetElement().GetAbilityName());
1879 EXPECT_EQ(valueStr3, want_->GetElement().GetBundleName());
1880
1881 want_->SetElementName(valueStr2, valueStr3, valueStr1);
1882 EXPECT_EQ(valueStr1, want_->GetElement().GetAbilityName());
1883 EXPECT_EQ(valueStr2, want_->GetElement().GetDeviceID());
1884 EXPECT_EQ(valueStr3, want_->GetElement().GetBundleName());
1885 }
1886
1887 /**
1888 * @tc.number: AaFwk_Want_Action_0200
1889 * @tc.name:SetAction / GetAction
1890 * @tc.desc: Verify the function when the input string is empty.
1891 */
1892 HWTEST_F(WantBaseTest, AaFwk_Want_Action_0200, Function | MediumTest | Level1)
1893 {
1894 std::string setValue;
1895 want_->SetAction(setValue);
1896 EXPECT_EQ(setValue, want_->GetAction());
1897 }
1898
1899 /**
1900 * @tc.number: AaFwk_Want_Action_0300
1901 * @tc.name:SetAction / GetAction
1902 * @tc.desc: Verify the function when the input string contains special characters.
1903 */
1904 HWTEST_F(WantBaseTest, AaFwk_Want_Action_0300, Function | MediumTest | Level1)
1905 {
1906 std::string setValue("action.system.com");
1907 want_->SetAction(setValue);
1908 EXPECT_STREQ(setValue.c_str(), want_->GetAction().c_str());
1909 }
1910
1911 using testByteType = std::tuple<std::string, std::string, byte, byte, byte>;
1912 class WantParametersBoolArrayTest : public testing::TestWithParam<testByteType> {
1913 public:
WantParametersBoolArrayTest()1914 WantParametersBoolArrayTest()
1915 {
1916 want_ = nullptr;
1917 }
~WantParametersBoolArrayTest()1918 ~WantParametersBoolArrayTest()
1919 {
1920 want_ = nullptr;
1921 }
1922 static void SetUpTestCase(void);
1923 static void TearDownTestCase(void);
1924 void SetUp();
1925 void TearDown();
1926 std::shared_ptr<Want> want_;
1927 };
1928
SetUpTestCase(void)1929 void WantParametersBoolArrayTest::SetUpTestCase(void)
1930 {}
1931
TearDownTestCase(void)1932 void WantParametersBoolArrayTest::TearDownTestCase(void)
1933 {}
1934
SetUp(void)1935 void WantParametersBoolArrayTest::SetUp(void)
1936 {
1937 want_ = std::make_shared<Want>();
1938 }
1939
TearDown(void)1940 void WantParametersBoolArrayTest::TearDown(void)
1941 {}
1942
1943 /**
1944 * @tc.number: AaFwk_Want_BoolArray_0100
1945 * @tc.name:SetBoolArrayParam/GetBoolArrayParam
1946 * @tc.desc: Verify when parameter change.
1947 */
1948 HWTEST_P(WantParametersBoolArrayTest, AaFwk_Want_BoolArray_0100, Function | MediumTest | Level1)
1949 {
1950 std::string setKey = std::get<0>(GetParam());
1951 std::string getKey = std::get<1>(GetParam());
1952 byte setValue = std::get<2>(GetParam());
1953 byte defaultValue = std::get<3>(GetParam());
1954 byte result = std::get<4>(GetParam());
1955 want_->SetParam(setKey, setValue);
1956 EXPECT_EQ(result, want_->GetByteParam(getKey, defaultValue));
1957 }
1958
1959 INSTANTIATE_TEST_CASE_P(WantParametersBoolArrayTestCaseP, WantParametersBoolArrayTest,
1960 testing::Values(testByteType("", "aa", '#', 'U', 'U'), testByteType("", "", 'N', 'K', 'N'),
1961 testByteType("1*中_aR", "aa", 'a', '%', '%'), testByteType("1*中_aR", "1*中_aR", 'a', 'z', 'a')));
1962
1963 using testBoolArrayType = std::tuple<std::string, std::string, std::vector<bool>, std::vector<bool>, std::vector<bool>>;
1964 class WantBoolArrayParamTest : public testing::TestWithParam<testBoolArrayType> {
1965 public:
WantBoolArrayParamTest()1966 WantBoolArrayParamTest()
1967 {
1968 want_ = nullptr;
1969 }
~WantBoolArrayParamTest()1970 ~WantBoolArrayParamTest()
1971 {
1972 want_ = nullptr;
1973 }
1974 static void SetUpTestCase(void);
1975 static void TearDownTestCase(void);
1976 void SetUp();
1977 void TearDown();
1978 std::shared_ptr<Want> want_;
1979 };
1980
SetUpTestCase(void)1981 void WantBoolArrayParamTest::SetUpTestCase(void)
1982 {}
1983
TearDownTestCase(void)1984 void WantBoolArrayParamTest::TearDownTestCase(void)
1985 {}
1986
SetUp(void)1987 void WantBoolArrayParamTest::SetUp(void)
1988 {
1989 want_ = std::make_shared<Want>();
1990 }
1991
TearDown(void)1992 void WantBoolArrayParamTest::TearDown(void)
1993 {}
1994
1995 /**
1996 * @tc.number: AaFwk_Want_BoolArray_0200
1997 * @tc.name:SetBoolArrayParam/GetBoolArrayParam
1998 * @tc.desc: Verify when parameter change.
1999 */
2000 HWTEST_P(WantBoolArrayParamTest, AaFwk_Want_BoolArray_0200, Function | MediumTest | Level1)
2001 {
2002 std::string setKey = std::get<0>(GetParam());
2003 std::string getKey = std::get<1>(GetParam());
2004 std::vector<bool> setValue = std::get<2>(GetParam());
2005 std::vector<bool> defaultValue = std::get<3>(GetParam());
2006 std::vector<bool> result = std::get<4>(GetParam());
2007 want_->SetParam(setKey, setValue);
2008 EXPECT_EQ(result, want_->GetBoolArrayParam(getKey));
2009 }
2010
2011 INSTANTIATE_TEST_CASE_P(WantBoolArrayParamTestCaseP, WantBoolArrayParamTest,
2012 testing::Values(testBoolArrayType("", "aa", {true, false}, {}, {}),
2013 testBoolArrayType("", "", {true, false}, {}, {true, false}),
2014 testBoolArrayType("1*中_aR", "aa", {true, false}, {}, {}),
2015 testBoolArrayType("1*中_aR", "1*中_aR", {false, true}, {}, {false, true})));
2016
2017 using testCharArrayType =
2018 std::tuple<std::string, std::string, std::vector<zchar>, std::vector<zchar>, std::vector<zchar>>;
2019 class WantCharArrayParamTest : public testing::TestWithParam<testCharArrayType> {
2020 public:
WantCharArrayParamTest()2021 WantCharArrayParamTest()
2022 {
2023 want_ = nullptr;
2024 }
~WantCharArrayParamTest()2025 ~WantCharArrayParamTest()
2026 {
2027 want_ = nullptr;
2028 }
2029 static void SetUpTestCase(void);
2030 static void TearDownTestCase(void);
2031 void SetUp();
2032 void TearDown();
2033 std::shared_ptr<Want> want_;
2034 };
2035
SetUpTestCase(void)2036 void WantCharArrayParamTest::SetUpTestCase(void)
2037 {}
2038
TearDownTestCase(void)2039 void WantCharArrayParamTest::TearDownTestCase(void)
2040 {}
2041
SetUp(void)2042 void WantCharArrayParamTest::SetUp(void)
2043 {
2044 want_ = std::make_shared<Want>();
2045 }
2046
TearDown(void)2047 void WantCharArrayParamTest::TearDown(void)
2048 {}
2049
2050 /**
2051 * @tc.number: AaFwk_Want_Parameters_CharArray_0100
2052 * @tc.name: SetParam/GetCharArrayParam
2053 * @tc.desc: Verify when parameter change.
2054 */
2055 HWTEST_P(WantCharArrayParamTest, AaFwk_Want_Parameters_CharArray_0100, Function | MediumTest | Level1)
2056 {
2057 std::string setKey = std::get<0>(GetParam());
2058 std::string getKey = std::get<1>(GetParam());
2059 std::vector<zchar> setValue = std::get<2>(GetParam());
2060 std::vector<zchar> defaultValue = std::get<3>(GetParam());
2061 std::vector<zchar> result = std::get<4>(GetParam());
2062 want_->SetParam(setKey, setValue);
2063 EXPECT_EQ(result, want_->GetCharArrayParam(getKey));
2064 }
2065
2066 INSTANTIATE_TEST_CASE_P(WantCharArrayParamTestCaseP, WantCharArrayParamTest,
2067 testing::Values(testCharArrayType("", "aa", {U'中', U'文'}, {}, {}),
2068 testCharArrayType("", "", {U'中', U'文'}, {}, {U'中', U'文'}),
2069 testCharArrayType("1*中_aR", "aa", {U'中', U'文'}, {}, {}),
2070 testCharArrayType("1*中_aR", "1*中_aR", {U'中', U'文'}, {}, {U'中', U'文'})));
2071
2072 /**
2073 * @tc.number: AaFwk_Want_Parameters_CharArray_0200
2074 * @tc.name: GetCharArrayParam
2075 * @tc.desc: Verify when the value is char array.
2076 */
2077 HWTEST_F(WantCharArrayParamTest, AaFwk_Want_Parameters_CharArray_0200, Function | MediumTest | Level1)
2078 {
2079 std::vector<zchar> defaultValue;
2080 std::string getKey("aa");
2081 EXPECT_EQ(defaultValue, want_->GetCharArrayParam(getKey));
2082 }
2083
2084 /**
2085 * @tc.number: AaFwk_Want_Parameters_CharArray_0300
2086 * @tc.name: SetParam/GetCharArrayParam
2087 * @tc.desc: Verify when the value is char array.
2088 */
2089 HWTEST_F(WantCharArrayParamTest, AaFwk_Want_Parameters_CharArray_0300, Function | MediumTest | Level1)
2090 {
2091 std::string emptyStr("ff");
2092 std::vector<zchar> firstValue({U'中', U'文'});
2093 std::vector<zchar> secondValue({U'字', U'符'});
2094 std::vector<zchar> thirdValue({U'集', U'英'});
2095 std::string keyStr("aa");
2096 want_->SetParam(emptyStr, firstValue);
2097 want_->SetParam(emptyStr, firstValue);
2098 want_->SetParam(emptyStr, secondValue);
2099 std::vector<zchar> defaultValue;
2100 EXPECT_EQ(defaultValue, want_->GetCharArrayParam(keyStr));
2101 want_->SetParam(emptyStr, thirdValue);
2102 EXPECT_EQ(thirdValue, want_->GetCharArrayParam(emptyStr));
2103 }
2104
2105 /**
2106 * @tc.number: AaFwk_Want_Parameters_CharArray_0400
2107 * @tc.name: SetParam/GetCharArrayParam
2108 * @tc.desc: Verify when the value is char array.
2109 */
2110 HWTEST_F(WantCharArrayParamTest, AaFwk_Want_Parameters_CharArray_0400, Function | MediumTest | Level1)
2111 {
2112 std::string firstKey("%1uH3");
2113 std::vector<zchar> firstValue({U'中', U'文'});
2114 std::vector<zchar> secondValue({U'字', U'符'});
2115 std::vector<zchar> defaultValue;
2116 std::string secondKey("aa");
2117 want_->SetParam(firstKey, firstValue);
2118 want_->SetParam(firstKey, firstValue);
2119 want_->SetParam(firstKey, secondValue);
2120 EXPECT_EQ(secondValue, want_->GetCharArrayParam(firstKey));
2121 want_->SetParam(firstKey, firstValue);
2122 EXPECT_EQ(defaultValue, want_->GetCharArrayParam(secondKey));
2123 }
2124
2125 using testCharType = std::tuple<std::string, std::string, zchar, zchar, zchar>;
2126 class WantCharParamTest : public testing::TestWithParam<testCharType> {
2127 public:
WantCharParamTest()2128 WantCharParamTest()
2129 {
2130 want_ = nullptr;
2131 }
~WantCharParamTest()2132 ~WantCharParamTest()
2133 {
2134 want_ = nullptr;
2135 }
2136 static void SetUpTestCase(void);
2137 static void TearDownTestCase(void);
2138 void SetUp();
2139 void TearDown();
2140 std::shared_ptr<Want> want_;
2141 };
2142
SetUpTestCase(void)2143 void WantCharParamTest::SetUpTestCase(void)
2144 {}
2145
TearDownTestCase(void)2146 void WantCharParamTest::TearDownTestCase(void)
2147 {}
2148
SetUp(void)2149 void WantCharParamTest::SetUp(void)
2150 {
2151 want_ = std::make_shared<Want>();
2152 }
2153
TearDown(void)2154 void WantCharParamTest::TearDown(void)
2155 {}
2156
2157 /**
2158 * @tc.number: AaFwk_Want_Parameters_Char_0100
2159 * @tc.name: SetParam/GetCharParam
2160 * @tc.desc: Verify when the value is char array.
2161 */
2162 HWTEST_P(WantCharParamTest, AaFwk_Want_Parameters_Char_0100, Function | MediumTest | Level1)
2163 {
2164 std::string setKey = std::get<0>(GetParam());
2165 std::string getKey = std::get<1>(GetParam());
2166 zchar setValue = std::get<2>(GetParam());
2167 zchar defaultValue = std::get<3>(GetParam());
2168 zchar result = std::get<4>(GetParam());
2169 want_->SetParam(setKey, setValue);
2170 EXPECT_EQ(result, want_->GetCharParam(getKey, defaultValue));
2171 }
2172
2173 INSTANTIATE_TEST_CASE_P(WantParametersCharTestCaseP, WantCharParamTest,
2174 testing::Values(testCharType("", "aa", U'#', U'中', U'中'), testCharType("", "", U'中', U'K', U'中'),
2175 testCharType("1*中_aR", "aa", U'a', U'中', U'中'), testCharType("1*中_aR", "1*中_aR", U'中', U'z', U'中')));
2176
2177 /**
2178 * @tc.number: AaFwk_Want_Parameters_Char_0200
2179 * @tc.name: SetParam/GetCharParam
2180 * @tc.desc: Verify when the value is char
2181 */
2182 HWTEST_F(WantCharParamTest, AaFwk_Want_Parameters_Char_0200, Function | MediumTest | Level1)
2183 {
2184 zchar defaultValue = U'文';
2185 std::string getKey("aa");
2186 EXPECT_EQ(defaultValue, want_->GetCharParam(getKey, defaultValue));
2187 }
2188
2189 /**
2190 * @tc.number: AaFwk_Want_Parameters_Char_0300
2191 * @tc.name: SetParam/GetCharParam
2192 * @tc.desc: Verify when the value is char.
2193 */
2194 HWTEST_F(WantCharParamTest, AaFwk_Want_Parameters_Char_0300, Function | MediumTest | Level1)
2195 {
2196 std::string emptyStr("jj");
2197 zchar firstValue = U'中';
2198 zchar secondValue = U'文';
2199 zchar thirdValue = U'字';
2200 zchar firstDefaultValue = U'符';
2201 zchar secondDefaultValue = U'集';
2202 std::string keyStr("aa");
2203 want_->SetParam(emptyStr, firstValue);
2204 want_->SetParam(emptyStr, firstValue);
2205 want_->SetParam(emptyStr, secondValue);
2206 EXPECT_EQ(firstDefaultValue, want_->GetCharParam(keyStr, firstDefaultValue));
2207 want_->SetParam(emptyStr, thirdValue);
2208 EXPECT_EQ(thirdValue, want_->GetCharParam(emptyStr, secondDefaultValue));
2209 }
2210
2211 /**
2212 * @tc.number: AaFwk_Want_Parameters_Char_0400
2213 * @tc.name: SetParam/GetCharParam
2214 * @tc.desc: Verify when the value is char.
2215 */
2216 HWTEST_F(WantCharParamTest, AaFwk_Want_Parameters_Char_0400, Function | MediumTest | Level1)
2217 {
2218 std::string firstKey("%1uH3");
2219 zchar firstValue = U'中';
2220 zchar secondValue = U'文';
2221 zchar firstDefaultValue = U'字';
2222 zchar secondDefaultValue = U'符';
2223 std::string secondKey("aa");
2224 want_->SetParam(firstKey, firstValue);
2225 want_->SetParam(firstKey, firstValue);
2226 want_->SetParam(firstKey, secondValue);
2227 EXPECT_EQ(secondValue, want_->GetCharParam(firstKey, firstDefaultValue));
2228 want_->SetParam(firstKey, firstValue);
2229 EXPECT_EQ(secondDefaultValue, want_->GetCharParam(secondKey, secondDefaultValue));
2230 }
2231
2232 using testDoubleArrayType =
2233 std::tuple<std::string, std::string, std::vector<double>, std::vector<double>, std::vector<double>>;
2234 class WantDoubleArrayParamTest : public testing::TestWithParam<testDoubleArrayType> {
2235 public:
WantDoubleArrayParamTest()2236 WantDoubleArrayParamTest()
2237 {
2238 want_ = nullptr;
2239 }
~WantDoubleArrayParamTest()2240 ~WantDoubleArrayParamTest()
2241 {
2242 want_ = nullptr;
2243 }
2244 static void SetUpTestCase(void);
2245 static void TearDownTestCase(void);
2246 void SetUp();
2247 void TearDown();
2248 std::shared_ptr<Want> want_;
2249 };
2250
SetUpTestCase(void)2251 void WantDoubleArrayParamTest::SetUpTestCase(void)
2252 {}
2253
TearDownTestCase(void)2254 void WantDoubleArrayParamTest::TearDownTestCase(void)
2255 {}
2256
SetUp(void)2257 void WantDoubleArrayParamTest::SetUp(void)
2258 {
2259 want_ = std::make_shared<Want>();
2260 }
2261
TearDown(void)2262 void WantDoubleArrayParamTest::TearDown(void)
2263 {}
2264
2265 /**
2266 * @tc.number: AaFwk_Want_DoubleArray_0100
2267 * @tc.name: SetParam/GetDoubleArrayParam
2268 * @tc.desc: Verify when parameter change.
2269 */
2270 HWTEST_P(WantDoubleArrayParamTest, AaFwk_Want_DoubleArray_0100, Function | MediumTest | Level1)
2271 {
2272 std::string setKey = std::get<0>(GetParam());
2273 std::string getKey = std::get<1>(GetParam());
2274 std::vector<double> setValue = std::get<2>(GetParam());
2275 std::vector<double> defaultValue = std::get<3>(GetParam());
2276 std::vector<double> result = std::get<4>(GetParam());
2277 want_->SetParam(setKey, setValue);
2278 EXPECT_EQ(result, want_->GetDoubleArrayParam(getKey));
2279 }
2280
2281 INSTANTIATE_TEST_CASE_P(WantDoubleArrayParamTestCaseP, WantDoubleArrayParamTest,
2282 testing::Values(testDoubleArrayType("", "aa", {-1.1, -2.1}, {}, {}),
2283 testDoubleArrayType("", "", {-41.1, -42.1}, {}, {-41.1, -42.1}),
2284 testDoubleArrayType("1*中_aR", "aa", {50.1, 51.1}, {}, {}),
2285 testDoubleArrayType("1*中_aR", "1*中_aR", {5000.1, 5001.1}, {}, {5000.1, 5001.1})));
2286
2287 /**
2288 * @tc.number: AaFwk_Want_DoubleArray_0200
2289 * @tc.name: SetParam/GetDoubleArrayParam
2290 * @tc.desc: Verify when parameter change.
2291 */
2292 HWTEST_F(WantDoubleArrayParamTest, AaFwk_Want_DoubleArray_0200, Function | MediumTest | Level1)
2293 {
2294 std::vector<double> defaultValue;
2295 std::string key = "aa";
2296 EXPECT_EQ(defaultValue, want_->GetDoubleArrayParam(key));
2297 }
2298
2299 /**
2300 * @tc.number: AaFwk_Want_DoubleArray_0300
2301 * @tc.name: SetParam/GetDoubleArrayParam
2302 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key
2303 */
2304 HWTEST_F(WantDoubleArrayParamTest, AaFwk_Want_DoubleArray_0300, Function | MediumTest | Level1)
2305 {
2306 std::vector<double> defaultValue;
2307 std::string setKey1 = "cc";
2308 std::string setKey2 = "aa";
2309 std::vector<double> setValue1 = {1.1, 2.1};
2310 std::vector<double> setValue2 = {5.1, 6.1};
2311 want_->SetParam(setKey1, setValue1);
2312 want_->SetParam(setKey1, setValue1);
2313 setValue1 = {2.1, 3.1};
2314 want_->SetParam(setKey1, setValue1);
2315 EXPECT_EQ(defaultValue, want_->GetDoubleArrayParam(setKey2));
2316 setValue1 = {4.1, 5.1};
2317 want_->SetParam(setKey1, setValue1);
2318 EXPECT_EQ(setValue1, want_->GetDoubleArrayParam(setKey1));
2319 }
2320
2321 /**
2322 * @tc.number: AaFwk_Want_DoubleArray_0400
2323 * @tc.name: SetParam/GetDoubleArrayParam
2324 * @tc.desc: set empty-string key repeatedly, then get param of the key
2325 */
2326 HWTEST_F(WantDoubleArrayParamTest, AaFwk_Want_DoubleArray_0400, Function | MediumTest | Level1)
2327 {
2328 std::vector<double> defaultValue;
2329 std::string setKey1 = "%1uH3";
2330 std::string setKey2 = "aa";
2331 std::vector<double> setValue1 = {-1.1, -2.1};
2332 std::vector<double> setValue2 = {9.1, 10.1};
2333 want_->SetParam(setKey1, setValue1);
2334 want_->SetParam(setKey1, setValue1);
2335 setValue1 = {0.1, 1.1};
2336 want_->SetParam(setKey1, setValue1);
2337 EXPECT_EQ(setValue1, want_->GetDoubleArrayParam(setKey1));
2338 setValue1 = {4.1, 5.1};
2339 want_->SetParam(setKey1, setValue1);
2340 setValue1 = {-10.1, -11.1};
2341 EXPECT_EQ(defaultValue, want_->GetDoubleArrayParam(setKey2));
2342 }
2343
2344 using testFloatArrayType =
2345 std::tuple<std::string, std::string, std::vector<float>, std::vector<float>, std::vector<float>>;
2346 class WantFloatArrayParamTest : public testing::TestWithParam<testFloatArrayType> {
2347 public:
WantFloatArrayParamTest()2348 WantFloatArrayParamTest()
2349 {
2350 want_ = nullptr;
2351 }
~WantFloatArrayParamTest()2352 ~WantFloatArrayParamTest()
2353 {
2354 want_ = nullptr;
2355 }
2356 static void SetUpTestCase(void);
2357 static void TearDownTestCase(void);
2358 void SetUp();
2359 void TearDown();
2360 std::shared_ptr<Want> want_;
2361 };
2362
SetUpTestCase(void)2363 void WantFloatArrayParamTest::SetUpTestCase(void)
2364 {}
2365
TearDownTestCase(void)2366 void WantFloatArrayParamTest::TearDownTestCase(void)
2367 {}
2368
SetUp(void)2369 void WantFloatArrayParamTest::SetUp(void)
2370 {
2371 want_ = std::make_shared<Want>();
2372 }
2373
TearDown(void)2374 void WantFloatArrayParamTest::TearDown(void)
2375 {}
2376
2377 /**
2378 * @tc.number: AaFwk_Want_FloatArray_0100
2379 * @tc.name: SetParam/GetFloatArrayParam
2380 * @tc.desc: Verify when parameter change.
2381 */
2382 HWTEST_P(WantFloatArrayParamTest, AaFwk_Want_FloatArray_0100, Function | MediumTest | Level1)
2383 {
2384 std::string setKey = std::get<0>(GetParam());
2385 std::string getKey = std::get<1>(GetParam());
2386 std::vector<float> setValue = std::get<2>(GetParam());
2387 std::vector<float> defaultValue = std::get<3>(GetParam());
2388 std::vector<float> result = std::get<4>(GetParam());
2389 want_->SetParam(setKey, setValue);
2390 EXPECT_EQ(result, want_->GetFloatArrayParam(getKey));
2391 }
2392
2393 INSTANTIATE_TEST_CASE_P(WantFloatArrayParamTestCaseP, WantFloatArrayParamTest,
2394 testing::Values(testFloatArrayType("", "aa", {-1.1, -2.1}, {}, {}),
2395 testFloatArrayType("", "", {-41.1, -42.1}, {}, {-41.1, -42.1}),
2396 testFloatArrayType("1*中_aR", "aa", {50.1, 51.1}, {}, {}),
2397 testFloatArrayType("1*中_aR", "1*中_aR", {5000.1, 5001.1}, {}, {5000.1, 5001.1})));
2398
2399 /**
2400 * @tc.number: AaFwk_Want_FloatArray_0200
2401 * @tc.name: SetParam/GetFloatArrayParam
2402 * @tc.desc: get param when WantParam is empty
2403 */
2404 HWTEST_F(WantFloatArrayParamTest, AaFwk_Want_FloatArray_0200, Function | MediumTest | Level1)
2405 {
2406 std::vector<float> defaultValue;
2407 std::string key = "aa";
2408 EXPECT_EQ(defaultValue, want_->GetFloatArrayParam(key));
2409 }
2410
2411 /**
2412 * @tc.number: AaFwk_Want_FloatArray_0300
2413 * @tc.name: SetParam & GetFloatArrayParam
2414 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key
2415 */
2416 HWTEST_F(WantFloatArrayParamTest, AaFwk_Want_FloatArray_0300, Function | MediumTest | Level1)
2417 {
2418 std::vector<float> defaultValue;
2419 std::string setKey1 = "hh";
2420 std::string setKey2 = "aa";
2421 std::vector<float> setValue1 = {1.1, 2.1};
2422 want_->SetParam(setKey1, setValue1);
2423 want_->SetParam(setKey1, setValue1);
2424 setValue1 = {2.1, 3.1};
2425 want_->SetParam(setKey1, setValue1);
2426 EXPECT_EQ(defaultValue, want_->GetFloatArrayParam(setKey2));
2427 setValue1 = {4.1, 5.1};
2428 want_->SetParam(setKey1, setValue1);
2429 EXPECT_EQ(setValue1, want_->GetFloatArrayParam(setKey1));
2430 }
2431
2432 /**
2433 * @tc.number: AaFwk_Want_FloatArray_0400
2434 * @tc.name: SetParam & GetFloatArrayParam
2435 * @tc.desc: set empty-string key repeatedly, then get param of the key
2436 */
2437 HWTEST_F(WantFloatArrayParamTest, AaFwk_Want_FloatArray_0400, Function | MediumTest | Level1)
2438 {
2439 std::vector<float> defaultValue;
2440 std::string setKey1 = "%1uH3";
2441 std::string setKey2 = "aa";
2442 std::vector<float> setValue1 = {-1.1, -2.1};
2443 std::vector<float> setValue2 = {9.1, 10.1};
2444 want_->SetParam(setKey1, setValue1);
2445 want_->SetParam(setKey1, setValue1);
2446 setValue1 = {0.1, 1.1};
2447 want_->SetParam(setKey1, setValue1);
2448 EXPECT_EQ(setValue1, want_->GetFloatArrayParam(setKey1));
2449 setValue1 = {4.1, 5.1};
2450 want_->SetParam(setKey1, setValue1);
2451 EXPECT_EQ(defaultValue, want_->GetFloatArrayParam(setKey2));
2452 }
2453
2454 using testLongArrayType = std::tuple<std::string, std::string, std::vector<long>, std::vector<long>, std::vector<long>>;
2455 class WantLongArrayParamTest : public testing::TestWithParam<testLongArrayType> {
2456 public:
WantLongArrayParamTest()2457 WantLongArrayParamTest()
2458 {
2459 want_ = nullptr;
2460 }
~WantLongArrayParamTest()2461 ~WantLongArrayParamTest()
2462 {
2463 want_ = nullptr;
2464 }
2465 static void SetUpTestCase(void);
2466 static void TearDownTestCase(void);
2467 void SetUp();
2468 void TearDown();
2469 std::shared_ptr<Want> want_;
2470 };
2471
SetUpTestCase(void)2472 void WantLongArrayParamTest::SetUpTestCase(void)
2473 {}
2474
TearDownTestCase(void)2475 void WantLongArrayParamTest::TearDownTestCase(void)
2476 {}
2477
SetUp(void)2478 void WantLongArrayParamTest::SetUp(void)
2479 {
2480 want_ = std::make_shared<Want>();
2481 }
2482
TearDown(void)2483 void WantLongArrayParamTest::TearDown(void)
2484 {}
2485
2486 /**
2487 * @tc.number: AaFwk_Want_LongArray_0100
2488 * @tc.name: SetParam & GetLongArrayParam
2489 * @tc.desc: Verify when parameter change.
2490 */
2491 HWTEST_P(WantLongArrayParamTest, AaFwk_Want_LongArray_0100, Function | MediumTest | Level1)
2492 {
2493 std::string setKey = std::get<0>(GetParam());
2494 std::string getKey = std::get<1>(GetParam());
2495 std::vector<long> setValue = std::get<2>(GetParam());
2496 std::vector<long> defaultValue = std::get<3>(GetParam());
2497 std::vector<long> result = std::get<4>(GetParam());
2498 want_->SetParam(setKey, setValue);
2499 EXPECT_EQ(result, want_->GetLongArrayParam(getKey));
2500 }
2501
2502 INSTANTIATE_TEST_CASE_P(WantLongArrayParamTestCaseP, WantLongArrayParamTest,
2503 testing::Values(testLongArrayType("", "aa", {-1, 3, 25, -9}, {}, {}),
2504 testLongArrayType("", "", {-41, 0, 0, 9}, {}, {-41, 0, 0, 9}),
2505 testLongArrayType("1*中_aR", "aa", {50, 2, -9}, {}, {}),
2506 testLongArrayType("1*中_aR", "1*中_aR", {-5000}, {}, {-5000})));
2507
2508 /**
2509 * @tc.number: AaFwk_Want_LongArray_0200
2510 * @tc.name: SetParam & GetLongArrayParam
2511 * @tc.desc: get param when WantParam is empty
2512 */
2513 HWTEST_F(WantLongArrayParamTest, AaFwk_Want_LongArray_0200, Function | MediumTest | Level1)
2514 {
2515 std::vector<long> defaultValue;
2516 std::string key = "aa";
2517 EXPECT_EQ(defaultValue, want_->GetLongArrayParam(key));
2518 }
2519
2520 /**
2521 * @tc.number: AaFwk_Want_LongArray_0300
2522 * @tc.name: SetParam & GetLongArrayParam
2523 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key
2524 */
2525 HWTEST_F(WantLongArrayParamTest, AaFwk_Want_LongArray_0300, Function | MediumTest | Level1)
2526 {
2527 std::vector<long> defaultValue;
2528 std::string setKey1 = "bb";
2529 std::string setKey2 = "aa";
2530 std::vector<long> setValue1 = {1, 2};
2531 want_->SetParam(setKey1, setValue1);
2532 want_->SetParam(setKey1, setValue1);
2533 setValue1 = {2, 3};
2534 want_->SetParam(setKey1, setValue1);
2535 EXPECT_EQ(defaultValue, want_->GetLongArrayParam(setKey2));
2536 setValue1 = {4, 5};
2537 want_->SetParam(setKey1, setValue1);
2538 EXPECT_EQ(setValue1, want_->GetLongArrayParam(setKey1));
2539 }
2540
2541 /**
2542 * @tc.number: AaFwk_Want_LongArray_0400
2543 * @tc.name: SetParam & GetLongArrayParam
2544 * @tc.desc: set empty-string key repeatedly, then get param of the key
2545 */
2546 HWTEST_F(WantLongArrayParamTest, AaFwk_Want_LongArray_0400, Function | MediumTest | Level1)
2547 {
2548 std::vector<long> defaultValue;
2549 std::string setKey1 = "%1uH3";
2550 std::string setKey2 = "aa";
2551 std::vector<long> setValue1 = {-1, -2};
2552 want_->SetParam(setKey1, setValue1);
2553 want_->SetParam(setKey1, setValue1);
2554 setValue1 = {0, 1};
2555 want_->SetParam(setKey1, setValue1);
2556 EXPECT_EQ(setValue1, want_->GetLongArrayParam(setKey1));
2557 setValue1 = {4, 5};
2558 want_->SetParam(setKey1, setValue1);
2559 EXPECT_EQ(defaultValue, want_->GetLongArrayParam(setKey2));
2560 }
2561
2562 using testShortArrayType =
2563 std::tuple<std::string, std::string, std::vector<short>, std::vector<short>, std::vector<short>>;
2564 class WantShortArrayParamTest : public testing::TestWithParam<testShortArrayType> {
2565 public:
WantShortArrayParamTest()2566 WantShortArrayParamTest()
2567 {
2568 want_ = nullptr;
2569 }
~WantShortArrayParamTest()2570 ~WantShortArrayParamTest()
2571 {
2572 want_ = nullptr;
2573 }
2574 static void SetUpTestCase(void);
2575 static void TearDownTestCase(void);
2576 void SetUp();
2577 void TearDown();
2578 std::shared_ptr<Want> want_;
2579 };
2580
SetUpTestCase(void)2581 void WantShortArrayParamTest::SetUpTestCase(void)
2582 {}
2583
TearDownTestCase(void)2584 void WantShortArrayParamTest::TearDownTestCase(void)
2585 {}
2586
SetUp(void)2587 void WantShortArrayParamTest::SetUp(void)
2588 {
2589 want_ = std::make_shared<Want>();
2590 }
2591
TearDown(void)2592 void WantShortArrayParamTest::TearDown(void)
2593 {}
2594
2595 /**
2596 * @tc.number: AaFwk_Want_ShortArray_0100
2597 * @tc.name: SetParam/GetShortArrayParam
2598 * @tc.desc: Verify when parameter change.
2599 */
2600 HWTEST_P(WantShortArrayParamTest, AaFwk_Want_ShortArray_0100, Function | MediumTest | Level1)
2601 {
2602 std::string setKey = std::get<0>(GetParam());
2603 std::string getKey = std::get<1>(GetParam());
2604 std::vector<short> setValue = std::get<2>(GetParam());
2605 std::vector<short> defaultValue = std::get<3>(GetParam());
2606 std::vector<short> result = std::get<4>(GetParam());
2607 want_->SetParam(setKey, setValue);
2608 EXPECT_EQ(result, want_->GetShortArrayParam(getKey));
2609 }
2610
2611 INSTANTIATE_TEST_CASE_P(WantShortArrayParamTestCaseP, WantShortArrayParamTest,
2612 testing::Values(testShortArrayType("", "aa", {-1, 3, 25, -9}, {}, {}),
2613 testShortArrayType("", "", {-41, 0, 0, 9}, {}, {-41, 0, 0, 9}),
2614 testShortArrayType("1*中_aR", "aa", {50, 2, -9}, {}, {}),
2615 testShortArrayType("1*中_aR", "1*中_aR", {-5000}, {}, {-5000})));
2616
2617 /**
2618 * @tc.number: AaFwk_Want_ShortArray_0200
2619 * @tc.name: SetParam/GetShortArrayParam
2620 * @tc.desc: Verify when the value is short array
2621 */
2622 HWTEST_F(WantShortArrayParamTest, AaFwk_Want_ShortArray_0200, Function | MediumTest | Level1)
2623 {
2624 std::vector<short> defaultValue;
2625 std::string getKey("aa");
2626 EXPECT_EQ(defaultValue, want_->GetShortArrayParam(getKey));
2627 }
2628
2629 /**
2630 * @tc.number: AaFwk_Want_ShortArray_0300
2631 * @tc.name: SetParam/GetShortArrayParam
2632 * @tc.desc: Verify when the value is short array
2633 */
2634 HWTEST_F(WantShortArrayParamTest, AaFwk_Want_ShortArray_0300, Function | MediumTest | Level1)
2635 {
2636 std::string emptyStr("hh");
2637 std::vector<short> firstValue({1, 4, -9});
2638 std::vector<short> secondValue({1, 8, -9});
2639 std::vector<short> thirdValue({1, 4, 9});
2640 std::string keyStr("aa");
2641 want_->SetParam(emptyStr, firstValue);
2642 want_->SetParam(emptyStr, firstValue);
2643 want_->SetParam(emptyStr, secondValue);
2644 std::vector<short> defaultValue;
2645 EXPECT_EQ(defaultValue, want_->GetShortArrayParam(keyStr));
2646 want_->SetParam(emptyStr, thirdValue);
2647 EXPECT_EQ(thirdValue, want_->GetShortArrayParam(emptyStr));
2648 }
2649
2650 /**
2651 * @tc.number: AaFwk_Want_ShortArray_0400
2652 * @tc.name: SetParam/GetShortArrayParam
2653 * @tc.desc: Verify when the value is short array
2654 */
2655 HWTEST_F(WantShortArrayParamTest, AaFwk_Want_ShortArray_0400, Function | MediumTest | Level1)
2656 {
2657 std::string firstKey("%1uH3");
2658 std::vector<short> firstValue({-1, -2});
2659 std::vector<short> secondValue({-1, -2, -1, -2, 0});
2660 std::vector<short> thirdValue({-1, -2, 100});
2661 std::string secondKey("aa");
2662 want_->SetParam(firstKey, firstValue);
2663 want_->SetParam(firstKey, firstValue);
2664 want_->SetParam(firstKey, secondValue);
2665 EXPECT_EQ(secondValue, want_->GetShortArrayParam(firstKey));
2666 want_->SetParam(firstKey, thirdValue);
2667 std::vector<short> defaultValue;
2668 EXPECT_EQ(defaultValue, want_->GetShortArrayParam(secondKey));
2669 }
2670
2671 using testShortType = std::tuple<std::string, std::string, short, short, short>;
2672 class WantShortParamTest : public testing::TestWithParam<testShortType> {
2673 public:
WantShortParamTest()2674 WantShortParamTest()
2675 {
2676 want_ = nullptr;
2677 }
~WantShortParamTest()2678 ~WantShortParamTest()
2679 {}
2680 static void SetUpTestCase(void);
2681 static void TearDownTestCase(void);
2682 void SetUp();
2683 void TearDown();
2684 std::shared_ptr<Want> want_;
2685 };
2686
SetUpTestCase(void)2687 void WantShortParamTest::SetUpTestCase(void)
2688 {}
2689
TearDownTestCase(void)2690 void WantShortParamTest::TearDownTestCase(void)
2691 {}
2692
SetUp(void)2693 void WantShortParamTest::SetUp(void)
2694 {
2695 want_ = std::make_shared<Want>();
2696 }
2697
TearDown(void)2698 void WantShortParamTest::TearDown(void)
2699 {}
2700
2701 /**
2702 * @tc.number: AaFwk_Want_Short_0100
2703 * @tc.name: SetParam/GetShortParam
2704 * @tc.desc: Verify when parameter change.
2705 */
2706 HWTEST_P(WantShortParamTest, AaFwk_Want_Short_0100, Function | MediumTest | Level1)
2707 {
2708 std::string setKey = std::get<0>(GetParam());
2709 std::string getKey = std::get<1>(GetParam());
2710 short setValue = std::get<2>(GetParam());
2711 short defaultValue = std::get<3>(GetParam());
2712 short result = std::get<4>(GetParam());
2713 want_->SetParam(setKey, setValue);
2714 EXPECT_EQ(result, want_->GetShortParam(getKey, defaultValue));
2715 }
2716
2717 INSTANTIATE_TEST_CASE_P(WantShortParamTestCaseP, WantShortParamTest,
2718 testing::Values(testShortType("", "aa", -1, 100, 100), testShortType("", "", -9, -41, -9),
2719 testShortType("1*中_aR", "aa", 50, 5, 5), testShortType("1*中_aR", "1*中_aR", -5000, 5000, -5000)));
2720
2721 /**
2722 * @tc.number: AaFwk_Want_Short_0200
2723 * @tc.name: SetParam/GetShortParam
2724 * @tc.desc: Verify when the value is short
2725 */
2726 HWTEST_F(WantShortParamTest, AaFwk_Want_Short_0200, Function | MediumTest | Level1)
2727 {
2728 short defaultValue = 200;
2729 std::string getKey("aa");
2730 EXPECT_EQ(defaultValue, want_->GetShortParam(getKey, defaultValue));
2731 }
2732 /**
2733 * @tc.number: AaFwk_Want_Short_0300
2734 * @tc.name: SetParam/GetShortParam
2735 * @tc.desc: Verify when the value is short
2736 */
2737 HWTEST_F(WantShortParamTest, AaFwk_Want_Short_0300, Function | MediumTest | Level1)
2738 {
2739 std::string emptyStr("bb");
2740 short firstValue = 1;
2741 short secondValue = 2;
2742 short thirdValue = 4;
2743 short firstDefaultValue = 3;
2744 short secondDefaultValue = 5;
2745 std::string keyStr("aa");
2746 want_->SetParam(emptyStr, firstValue);
2747 want_->SetParam(emptyStr, firstValue);
2748 want_->SetParam(emptyStr, secondValue);
2749 EXPECT_EQ(firstDefaultValue, want_->GetShortParam(keyStr, firstDefaultValue));
2750 want_->SetParam(emptyStr, thirdValue);
2751 EXPECT_EQ(thirdValue, want_->GetShortParam(emptyStr, secondDefaultValue));
2752 }
2753
2754 /**
2755 * @tc.number: AaFwk_Want_Short_0400
2756 * @tc.name: SetParam/GetShortParam
2757 * @tc.desc: Verify when the value is short
2758 */
2759 HWTEST_F(WantShortParamTest, AaFwk_Want_Short_0400, Function | MediumTest | Level1)
2760 {
2761 std::string firstKey("%1uH3");
2762 short firstValue = -1;
2763 short secondValue = 0;
2764 short thirdValue = 4;
2765 short firstDefaultValue = 9;
2766 short secondDefaultValue = -10;
2767 std::string secondKey("aa");
2768 want_->SetParam(firstKey, firstValue);
2769 want_->SetParam(firstKey, firstValue);
2770 want_->SetParam(firstKey, secondValue);
2771 EXPECT_EQ(secondValue, want_->GetShortParam(firstKey, firstDefaultValue));
2772 want_->SetParam(firstKey, thirdValue);
2773 EXPECT_EQ(secondDefaultValue, want_->GetShortParam(secondKey, secondDefaultValue));
2774 }
2775
2776 using testStrArrayType =
2777 std::tuple<std::string, std::string, std::vector<std::string>, std::vector<std::string>, std::vector<std::string>>;
2778 class WantStringArrayParamTest : public testing::TestWithParam<testStrArrayType> {
2779 public:
WantStringArrayParamTest()2780 WantStringArrayParamTest()
2781 {
2782 want_ = nullptr;
2783 }
~WantStringArrayParamTest()2784 ~WantStringArrayParamTest()
2785 {}
2786 static void SetUpTestCase(void);
2787 static void TearDownTestCase(void);
2788 void SetUp();
2789 void TearDown();
2790 std::shared_ptr<Want> want_ = nullptr;
2791 };
2792
SetUpTestCase(void)2793 void WantStringArrayParamTest::SetUpTestCase(void)
2794 {}
2795
TearDownTestCase(void)2796 void WantStringArrayParamTest::TearDownTestCase(void)
2797 {}
2798
SetUp(void)2799 void WantStringArrayParamTest::SetUp(void)
2800 {
2801 want_ = std::make_shared<Want>();
2802 }
2803
TearDown(void)2804 void WantStringArrayParamTest::TearDown(void)
2805 {}
2806
2807 /**
2808 * @tc.number: AaFwk_Want_StringArray_0100
2809 * @tc.name: SetParam/GetStringArrayParam
2810 * @tc.desc: Verify when parameter change.
2811 */
2812 HWTEST_P(WantStringArrayParamTest, AaFwk_Want_StringArray_0100, Function | MediumTest | Level1)
2813 {
2814 std::string setKey = std::get<0>(GetParam());
2815 std::string getKey = std::get<1>(GetParam());
2816 std::vector<std::string> setValue = std::get<2>(GetParam());
2817 std::vector<std::string> defaultValue = std::get<3>(GetParam());
2818 std::vector<std::string> result = std::get<4>(GetParam());
2819 want_->SetParam(setKey, setValue);
2820 EXPECT_EQ(result, want_->GetStringArrayParam(getKey));
2821 }
2822
2823 INSTANTIATE_TEST_CASE_P(WantStringArrayParamTestCaseP, WantStringArrayParamTest,
2824 testing::Values(testStrArrayType("", "aa", {"1*中_aR", "dbdb"}, {}, {}),
2825 testStrArrayType("", "", {"1*中_aR", "dbdb"}, {}, {"1*中_aR", "dbdb"}),
2826 testStrArrayType("1*中_aR", "aa", {"1*中_aR", "dbdb"}, {}, {}),
2827 testStrArrayType("1*中_aR", "1*中_aR", {"1*中_aR", "dbdb"}, {}, {"1*中_aR", "dbdb"})));
2828
2829 /**
2830 * @tc.number: AaFwk_Want_StringArray_0200
2831 * @tc.name: SetParam/GetStringArrayParam
2832 * @tc.desc: get param when WantParam is empty
2833 */
2834 HWTEST_F(WantStringArrayParamTest, AaFwk_Want_StringArray_0200, Function | MediumTest | Level1)
2835 {
2836 std::vector<std::string> defaultValue;
2837 std::string key = "aa";
2838 std::vector<std::string> resultValue = want_->GetStringArrayParam(key);
2839 EXPECT_EQ(defaultValue, resultValue);
2840 }
2841
2842 /**
2843 * @tc.number: AaFwk_Want_StringArray_0300
2844 * @tc.name: SetParam/GetStringArrayParam
2845 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key
2846 */
2847 HWTEST_F(WantStringArrayParamTest, AaFwk_Want_StringArray_0300, Function | MediumTest | Level1)
2848 {
2849 std::vector<std::string> defaultValue;
2850 std::vector<std::string> setValue1 = {"aaa", "2132"};
2851 std::vector<std::string> setValue2 = {"1*中_aR", "dbdb"};
2852 std::string key1 = "cc";
2853 std::string key2 = "aa";
2854 want_->SetParam(key1, setValue1);
2855 want_->SetParam(key1, setValue1);
2856 want_->SetParam(key1, setValue2);
2857 std::vector<std::string> resultValue = want_->GetStringArrayParam(key2);
2858 EXPECT_EQ(defaultValue, resultValue);
2859
2860 want_->SetParam(key1, setValue1);
2861 resultValue = want_->GetStringArrayParam(key1);
2862 EXPECT_EQ(setValue1, resultValue);
2863 }
2864
2865 /**
2866 * @tc.number: AaFwk_Want_StringArray_0400
2867 * @tc.name: SetParam/GetStringArrayParam
2868 * @tc.desc: set empty-string key repeatedly, then get param of the key
2869 */
2870 HWTEST_F(WantStringArrayParamTest, AaFwk_Want_StringArray_0400, Function | MediumTest | Level1)
2871 {
2872 std::vector<std::string> defaultValue;
2873 std::vector<std::string> setValue = {"aaa", "2132"};
2874 std::string key1 = "%1uH3";
2875 std::string key2 = "aa";
2876 want_->SetParam(key1, setValue);
2877 want_->SetParam(key1, setValue);
2878 setValue = {"1*中_aR", "3#$%"};
2879 want_->SetParam(key1, setValue);
2880 std::vector<std::string> resultValue = want_->GetStringArrayParam(key1);
2881 EXPECT_EQ(setValue, resultValue);
2882
2883 setValue = {"aaa", "2132"};
2884 want_->SetParam(key1, setValue);
2885 resultValue = want_->GetStringArrayParam(key2);
2886 EXPECT_EQ(defaultValue, resultValue);
2887 }
2888
2889 using testStrType = std::tuple<std::string, std::string, std::string, std::string, std::string>;
2890 class WantStringParamTest : public testing::TestWithParam<testStrType> {
2891 public:
WantStringParamTest()2892 WantStringParamTest()
2893 {
2894 want_ = nullptr;
2895 }
~WantStringParamTest()2896 ~WantStringParamTest()
2897 {}
2898 static void SetUpTestCase(void);
2899 static void TearDownTestCase(void);
2900 void SetUp();
2901 void TearDown();
2902 std::shared_ptr<Want> want_;
2903 };
2904
SetUpTestCase(void)2905 void WantStringParamTest::SetUpTestCase(void)
2906 {}
2907
TearDownTestCase(void)2908 void WantStringParamTest::TearDownTestCase(void)
2909 {}
2910
SetUp(void)2911 void WantStringParamTest::SetUp(void)
2912 {
2913 want_ = std::make_shared<Want>();
2914 }
2915
TearDown(void)2916 void WantStringParamTest::TearDown(void)
2917 {}
2918
2919 /**
2920 * @tc.number: AaFwk_Want_String_0100
2921 * @tc.name: SetParam/GetStringParam
2922 * @tc.desc: Verify when parameter change.
2923 */
2924 HWTEST_P(WantStringParamTest, AaFwk_Want_String_0100, Function | MediumTest | Level1)
2925 {
2926 std::string setKey = std::get<0>(GetParam());
2927 std::string getKey = std::get<1>(GetParam());
2928 std::string setValue = std::get<2>(GetParam());
2929 std::string defaultValue = std::get<3>(GetParam());
2930 std::string result = std::get<4>(GetParam());
2931 want_->SetParam(setKey, setValue);
2932 EXPECT_EQ(result, want_->GetStringParam(getKey));
2933 }
2934
2935 INSTANTIATE_TEST_CASE_P(WantStringParamTestCaseP, WantStringParamTest,
2936 testing::Values(testStrType("", "aa", "1*中_aR", "", ""), testStrType("", "", "1*中_aR", "", "1*中_aR"),
2937 testStrType("1*中_aR", "aa", "aaa", "", ""), testStrType("1*中_aR", "1*中_aR", "aaa", "", "aaa")));
2938
2939 /**
2940 * @tc.number: AaFwk_Want_String_0200
2941 * @tc.name: SetParam/GetStringParam
2942 * @tc.desc: get param when WantParam is empty.
2943 */
2944 HWTEST_F(WantStringParamTest, AaFwk_Want_String_0200, Function | MediumTest | Level1)
2945 {
2946 std::string defaultStrValue;
2947 std::string key = "aa";
2948 EXPECT_EQ(defaultStrValue, want_->GetStringParam(key));
2949 }
2950
2951 /**
2952 * @tc.number: AaFwk_Want_String_0300
2953 * @tc.name: SetParam/GetStringParam
2954 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key.
2955 */
2956 HWTEST_F(WantStringParamTest, AaFwk_Want_String_0300, Function | MediumTest | Level1)
2957 {
2958 std::string defaultStrValue;
2959 std::string setValue1 = "aaa";
2960 std::string setValue2 = "1*中_aR";
2961 std::string key1 = "dd";
2962 std::string key2 = "aa";
2963 want_->SetParam(key1, setValue1);
2964 want_->SetParam(key1, setValue1);
2965 want_->SetParam(key1, setValue2);
2966 EXPECT_EQ(defaultStrValue, want_->GetStringParam(key2));
2967 want_->SetParam(key1, setValue1);
2968 EXPECT_EQ(setValue1, want_->GetStringParam(key1));
2969 }
2970
2971 /**
2972 * @tc.number: AaFwk_Want_String_0400
2973 * @tc.name: SetParam/GetStringParam
2974 * @tc.desc: set empty-string key repeatedly, then get param of the key.
2975 */
2976 HWTEST_F(WantStringParamTest, AaFwk_Want_String_0400, Function | MediumTest | Level1)
2977 {
2978 std::string key1 = "%1uH3";
2979 std::string defaultStrValue;
2980 std::string setValue1 = "aaa";
2981 std::string setValue2 = "1*中_aR";
2982 std::string key2 = "aa";
2983 want_->SetParam(key1, setValue1);
2984 want_->SetParam(key1, setValue1);
2985 want_->SetParam(key1, setValue2);
2986 EXPECT_EQ("1*中_aR", want_->GetStringParam(key1));
2987 want_->SetParam(key1, setValue1);
2988 EXPECT_EQ(defaultStrValue, want_->GetStringParam(key2));
2989 }
2990
2991 using testLongType = std::tuple<std::string, std::string, long, long, long>;
2992 class WantLongParamTest : public testing::TestWithParam<testLongType> {
2993 public:
WantLongParamTest()2994 WantLongParamTest()
2995 {
2996 want_ = nullptr;
2997 }
~WantLongParamTest()2998 ~WantLongParamTest()
2999 {}
3000 static void SetUpTestCase(void);
3001 static void TearDownTestCase(void);
3002 void SetUp();
3003 void TearDown();
3004 std::shared_ptr<Want> want_ = nullptr;
3005 };
3006
SetUpTestCase(void)3007 void WantLongParamTest::SetUpTestCase(void)
3008 {}
3009
TearDownTestCase(void)3010 void WantLongParamTest::TearDownTestCase(void)
3011 {}
3012
SetUp(void)3013 void WantLongParamTest::SetUp(void)
3014 {
3015 want_ = std::make_shared<Want>();
3016 }
3017
TearDown(void)3018 void WantLongParamTest::TearDown(void)
3019 {}
3020
3021 /**
3022 * @tc.number: AaFwk_Want_LongParam_0100
3023 * @tc.name: SetParam/GetLongParam
3024 * @tc.desc: Verify when parameter change.
3025 */
3026 HWTEST_P(WantLongParamTest, AaFwk_Want_LongParam_0100, Function | MediumTest | Level1)
3027 {
3028 std::string setKey = std::get<0>(GetParam());
3029 std::string getKey = std::get<1>(GetParam());
3030 long setValue = std::get<2>(GetParam());
3031 long defaultValue = std::get<3>(GetParam());
3032 long result = std::get<4>(GetParam());
3033 want_->SetParam(setKey, setValue);
3034 EXPECT_EQ(result, want_->GetLongParam(getKey, defaultValue));
3035 }
3036
3037 INSTANTIATE_TEST_CASE_P(WantLongParamTestCaseP, WantLongParamTest,
3038 testing::Values(testLongType("b1", "b1", -1, 100, -1), testLongType("b3", "b4", 600, 200, 200),
3039 testLongType("b5", "b5", 50, 6, 50), testLongType("b6", "b7", 1000, 2200, 2200)));
3040
3041 /**
3042 * @tc.number: AaFwk_Want_LongParam_0200
3043 * @tc.name: SetParam/GetLongParam
3044 * @tc.desc: get param when WantParam is empty.
3045 */
3046 HWTEST_F(WantLongParamTest, AaFwk_Want_LongParam_0200, Function | MediumTest | Level1)
3047 {
3048 long defaultValue = 100;
3049 std::string key = "aa";
3050 EXPECT_EQ(defaultValue, want_->GetLongParam(key, defaultValue));
3051 }
3052
3053 /**
3054 * @tc.number: AaFwk_Want_LongParam_0300
3055 * @tc.name: SetParam/GetLongParam
3056 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key.
3057 */
3058 HWTEST_F(WantLongParamTest, AaFwk_Want_LongParam_0300, Function | MediumTest | Level1)
3059 {
3060 std::string setKey1 = "dd";
3061 std::string setKey2 = "aa";
3062 long setValue1 = 1;
3063 long setValue2 = 5;
3064 want_->SetParam(setKey1, setValue1);
3065 want_->SetParam(setKey1, setValue1);
3066 setValue1 = 2;
3067 want_->SetParam(setKey1, setValue1);
3068 setValue1 = 3;
3069 EXPECT_EQ(setValue1, want_->GetLongParam(setKey2, setValue1));
3070 setValue1 = 4;
3071 want_->SetParam(setKey1, setValue1);
3072 EXPECT_EQ(setValue1, want_->GetLongParam(setKey1, setValue2));
3073 }
3074
3075 /**
3076 * @tc.number: AaFwk_Want_LongParam_0400
3077 * @tc.name: SetParam/GetLongParam
3078 * @tc.desc: set empty-string key repeatedly, then get param of the key.
3079 */
3080 HWTEST_F(WantLongParamTest, AaFwk_Want_LongParam_0400, Function | MediumTest | Level1)
3081 {
3082 std::string setKey1 = "%1uH3";
3083 std::string setKey2 = "aa";
3084 long setValue1 = -1;
3085 long setValue2 = 9;
3086 want_->SetParam(setKey1, setValue1);
3087 want_->SetParam(setKey1, setValue1);
3088 setValue1 = 0;
3089 want_->SetParam(setKey1, setValue1);
3090 EXPECT_EQ(setValue1, want_->GetLongParam(setKey1, setValue2));
3091 setValue1 = 4;
3092 want_->SetParam(setKey1, setValue1);
3093 setValue1 = -10;
3094 EXPECT_EQ(setValue1, want_->GetLongParam(setKey2, setValue1));
3095 }
3096
3097 using testIntType = std::tuple<std::string, std::string, int, int, int>;
3098 class WantIntParamTest : public testing::TestWithParam<testIntType> {
3099 public:
WantIntParamTest()3100 WantIntParamTest()
3101 {
3102 want_ = nullptr;
3103 }
~WantIntParamTest()3104 ~WantIntParamTest()
3105 {
3106 want_ = nullptr;
3107 }
3108 static void SetUpTestCase(void);
3109 static void TearDownTestCase(void);
3110 void SetUp();
3111 void TearDown();
3112 std::shared_ptr<Want> want_;
3113 };
3114
SetUpTestCase(void)3115 void WantIntParamTest::SetUpTestCase(void)
3116 {}
3117
TearDownTestCase(void)3118 void WantIntParamTest::TearDownTestCase(void)
3119 {}
3120
SetUp(void)3121 void WantIntParamTest::SetUp(void)
3122 {
3123 want_ = std::make_shared<Want>();
3124 }
3125
TearDown(void)3126 void WantIntParamTest::TearDown(void)
3127 {}
3128
3129 /**
3130 * @tc.number: AaFwk_Want_IntParam_0100
3131 * @tc.name: SetParam/GetIntParam
3132 * @tc.desc: Verify when parameter change.
3133 */
3134 HWTEST_P(WantIntParamTest, AaFwk_Want_IntParam_0100, Function | MediumTest | Level1)
3135 {
3136 std::string setKey = std::get<0>(GetParam());
3137 std::string getKey = std::get<1>(GetParam());
3138 int setValue = std::get<2>(GetParam());
3139 int defaultValue = std::get<3>(GetParam());
3140 int result = std::get<4>(GetParam());
3141 want_->SetParam(setKey, setValue);
3142 EXPECT_EQ(result, want_->GetIntParam(getKey, defaultValue));
3143 }
3144
3145 INSTANTIATE_TEST_CASE_P(WantParametersIntTestCaseP, WantIntParamTest,
3146 testing::Values(testIntType("", "aa", -1, 100, 100), testIntType("", "", -9, -41, -9),
3147 testIntType("1*中_aR", "aa", 50, 5, 5), testIntType("1*中_aR", "1*中_aR", -5000, 5000, -5000)));
3148
3149 /**
3150 * @tc.number: AaFwk_Want_IntParam_0200
3151 * @tc.name: SetParam/GetIntParam
3152 * @tc.desc: Verify when the value is integer.
3153 */
3154 HWTEST_F(WantIntParamTest, AaFwk_Want_IntParam_0200, Function | MediumTest | Level1)
3155 {
3156 int defaultValue = 200;
3157 std::string getKey("aa");
3158 EXPECT_EQ(defaultValue, want_->GetIntParam(getKey, defaultValue));
3159 }
3160
3161 /**
3162 * @tc.number: AaFwk_Want_IntParam_0300
3163 * @tc.name: SetParam/GetIntParam
3164 * @tc.desc: Verify when the value is integer.
3165 */
3166 HWTEST_F(WantIntParamTest, AaFwk_Want_IntParam_0300, Function | MediumTest | Level1)
3167 {
3168 std::string emptyStr("bb");
3169 int firstValue = 1;
3170 int secondValue = 2;
3171 int thirdValue = 4;
3172 int firstDefaultValue = 3;
3173 int secondDefaultValue = 5;
3174 std::string keyStr("aa");
3175 want_->SetParam(emptyStr, firstValue);
3176 want_->SetParam(emptyStr, firstValue);
3177 want_->SetParam(emptyStr, secondValue);
3178 EXPECT_EQ(firstDefaultValue, want_->GetIntParam(keyStr, firstDefaultValue));
3179 want_->SetParam(emptyStr, thirdValue);
3180 EXPECT_EQ(thirdValue, want_->GetIntParam(emptyStr, secondDefaultValue));
3181 }
3182
3183 /**
3184 * @tc.number: AaFwk_Want_IntParam_0400
3185 * @tc.name: SetParam/GetIntParam
3186 * @tc.desc: Verify when the value is integer.
3187 */
3188 HWTEST_F(WantIntParamTest, AaFwk_Want_IntParam_0400, Function | MediumTest | Level1)
3189 {
3190 std::string firstKey("%1uH3");
3191 int firstValue = -1;
3192 int secondValue = 0;
3193 int thirdValue = 4;
3194 int firstDefaultValue = 9;
3195 int secondDefaultValue = -10;
3196 std::string secondKey("aa");
3197 want_->SetParam(firstKey, firstValue);
3198 want_->SetParam(firstKey, firstValue);
3199 want_->SetParam(firstKey, secondValue);
3200 EXPECT_EQ(secondValue, want_->GetIntParam(firstKey, firstDefaultValue));
3201 want_->SetParam(firstKey, thirdValue);
3202 EXPECT_EQ(secondDefaultValue, want_->GetIntParam(secondKey, secondDefaultValue));
3203 }
3204
3205 using testIntArrayType = std::tuple<std::string, std::string, std::vector<int>, std::vector<int>, std::vector<int>>;
3206 class WantIntArrayParamTest : public testing::TestWithParam<testIntArrayType> {
3207 public:
WantIntArrayParamTest()3208 WantIntArrayParamTest()
3209 {
3210 want_ = nullptr;
3211 }
~WantIntArrayParamTest()3212 ~WantIntArrayParamTest()
3213 {
3214 want_ = nullptr;
3215 }
3216 static void SetUpTestCase(void);
3217 static void TearDownTestCase(void);
3218 void SetUp();
3219 void TearDown();
3220 std::shared_ptr<Want> want_;
3221 };
3222
SetUpTestCase(void)3223 void WantIntArrayParamTest::SetUpTestCase(void)
3224 {}
3225
TearDownTestCase(void)3226 void WantIntArrayParamTest::TearDownTestCase(void)
3227 {}
3228
SetUp(void)3229 void WantIntArrayParamTest::SetUp(void)
3230 {
3231 want_ = std::make_shared<Want>();
3232 }
3233
TearDown(void)3234 void WantIntArrayParamTest::TearDown(void)
3235 {}
3236
3237 /**
3238 * @tc.number: AaFwk_Want_IntArrayParam_0100
3239 * @tc.name: SetParam/GetIntArrayParam
3240 * @tc.desc: Verify when parameter change.
3241 */
3242 HWTEST_P(WantIntArrayParamTest, AaFwk_Want_IntArrayParam_0100, Function | MediumTest | Level1)
3243 {
3244 std::string setKey = std::get<0>(GetParam());
3245 std::string getKey = std::get<1>(GetParam());
3246 std::vector<int> setValue = std::get<2>(GetParam());
3247 std::vector<int> defaultValue = std::get<3>(GetParam());
3248 std::vector<int> result = std::get<4>(GetParam());
3249 want_->SetParam(setKey, setValue);
3250 EXPECT_EQ(result, want_->GetIntArrayParam(getKey));
3251 }
3252
3253 INSTANTIATE_TEST_CASE_P(WantIntArrayParamTestCaseP, WantIntArrayParamTest,
3254 testing::Values(testIntArrayType("", "aa", {-1, 3, 25, -9}, {}, {}),
3255 testIntArrayType("", "", {-41, 0, 0, 9}, {}, {-41, 0, 0, 9}),
3256 testIntArrayType("1*中_aR", "aa", {50, 2, -9}, {}, {}),
3257 testIntArrayType("1*中_aR", "1*中_aR", {-5000}, {}, {-5000})));
3258
3259 /**
3260 * @tc.number: AaFwk_Want_IntArrayParam_0200
3261 * @tc.name: SetParam/GetIntArrayParam
3262 * @tc.desc: Verify when the value is integer array.
3263 */
3264 HWTEST_F(WantIntArrayParamTest, AaFwk_Want_IntArrayParam_0200, Function | MediumTest | Level1)
3265 {
3266 std::vector<int> defaultValue;
3267 std::string getKey("aa");
3268 EXPECT_EQ(defaultValue, want_->GetIntArrayParam(getKey));
3269 }
3270
3271 /**
3272 * @tc.number: AaFwk_Want_IntArrayParam_0300
3273 * @tc.name: SetParam/GetIntArrayParam
3274 * @tc.desc: Verify when the value is integer array.
3275 */
3276 HWTEST_F(WantIntArrayParamTest, AaFwk_Want_IntArrayParam_0300, Function | MediumTest | Level1)
3277 {
3278 std::string emptyStr("cc");
3279 std::vector<int> firstValue({1, 4, -9});
3280 std::vector<int> secondValue({1, 8, -9});
3281 std::vector<int> thirdValue({1, 4, 9});
3282 std::string keyStr("aa");
3283 want_->SetParam(emptyStr, firstValue);
3284 want_->SetParam(emptyStr, firstValue);
3285 want_->SetParam(emptyStr, secondValue);
3286 std::vector<int> defaultValue;
3287 EXPECT_EQ(defaultValue, want_->GetIntArrayParam(keyStr));
3288 want_->SetParam(emptyStr, thirdValue);
3289 EXPECT_EQ(thirdValue, want_->GetIntArrayParam(emptyStr));
3290 }
3291
3292 /**
3293 * @tc.number: AaFwk_Want_IntArrayParam_0400
3294 * @tc.name: SetParam/GetIntArrayParam
3295 * @tc.desc: Verify when the value is integer array.
3296 */
3297 HWTEST_F(WantIntArrayParamTest, AaFwk_Want_IntArrayParam_0400, Function | MediumTest | Level1)
3298 {
3299 std::string firstKey("%1uH3");
3300 std::vector<int> firstValue({-1, -2});
3301 std::vector<int> secondValue({-1, -2, -1, -2, 0});
3302 std::vector<int> thirdValue({-1, -2, 100});
3303 std::string secondKey("aa");
3304 want_->SetParam(firstKey, firstValue);
3305 want_->SetParam(firstKey, firstValue);
3306 want_->SetParam(firstKey, secondValue);
3307 EXPECT_EQ(secondValue, want_->GetIntArrayParam(firstKey));
3308 want_->SetParam(firstKey, thirdValue);
3309 std::vector<int> defaultValue;
3310 EXPECT_EQ(defaultValue, want_->GetIntArrayParam(secondKey));
3311 }
3312
3313 using testFloatType = std::tuple<std::string, std::string, float, float, float>;
3314 class WantFloatParamTest : public testing::TestWithParam<testFloatType> {
3315 public:
WantFloatParamTest()3316 WantFloatParamTest()
3317 {
3318 want_ = nullptr;
3319 }
~WantFloatParamTest()3320 ~WantFloatParamTest()
3321 {
3322 want_ = nullptr;
3323 }
3324
3325 static void SetUpTestCase(void);
3326 static void TearDownTestCase(void);
3327 void SetUp();
3328 void TearDown();
3329 std::shared_ptr<Want> want_;
3330 };
3331
SetUpTestCase(void)3332 void WantFloatParamTest::SetUpTestCase(void)
3333 {}
3334
TearDownTestCase(void)3335 void WantFloatParamTest::TearDownTestCase(void)
3336 {}
3337
SetUp(void)3338 void WantFloatParamTest::SetUp(void)
3339 {
3340 want_ = std::make_shared<Want>();
3341 }
3342
TearDown(void)3343 void WantFloatParamTest::TearDown(void)
3344 {}
3345
3346 /**
3347 * @tc.number: AaFwk_Want_FloatParam_0100
3348 * @tc.name: SetParam/GetFloatParam
3349 * @tc.desc: Verify when parameter change.
3350 */
3351 HWTEST_P(WantFloatParamTest, AaFwk_Want_FloatParam_0100, Function | MediumTest | Level1)
3352 {
3353 std::string setKey = std::get<0>(GetParam());
3354 std::string getKey = std::get<1>(GetParam());
3355 float setValue = std::get<2>(GetParam());
3356 float defaultValue = std::get<3>(GetParam());
3357 float result = std::get<4>(GetParam());
3358 want_->SetParam(setKey, setValue);
3359 EXPECT_EQ(result, want_->GetFloatParam(getKey, defaultValue));
3360 }
3361
3362 INSTANTIATE_TEST_CASE_P(WantFloatParamTestCaseP, WantFloatParamTest,
3363 testing::Values(testFloatType("", "aa", -1.1, 100.1, 100.1), testFloatType("", "", -9.1, -41.1, -9.1),
3364 testFloatType("1*中_aR", "aa", 50.1, 5.1, 5.1), testFloatType("1*中_aR", "1*中_aR", -5000.1, 5000.1, -5000.1)));
3365
3366 /**
3367 * @tc.number: AaFwk_Want_FloatParam_0200
3368 * @tc.name: SetParam/GetFloatParam
3369 * @tc.desc: get param when WantParam is empty.
3370 */
3371 HWTEST_F(WantFloatParamTest, AaFwk_Want_FloatParam_0200, Function | MediumTest | Level1)
3372 {
3373 float defaultValue = 100.1;
3374 std::string key = "aa";
3375 EXPECT_EQ(defaultValue, want_->GetFloatParam(key, defaultValue));
3376 }
3377
3378 /**
3379 * @tc.number: AaFwk_Want_FloatParam_0300
3380 * @tc.name: SetParam/GetFloatParam
3381 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key.
3382 */
3383 HWTEST_F(WantFloatParamTest, AaFwk_Want_FloatParam_0300, Function | MediumTest | Level1)
3384 {
3385 std::string setKey1 = "ee";
3386 std::string setKey2 = "aa";
3387 float setValue1 = 1.1;
3388 float setValue2 = 5.1;
3389 want_->SetParam(setKey1, setValue1);
3390 want_->SetParam(setKey1, setValue1);
3391 setValue1 = 2.1;
3392 want_->SetParam(setKey1, setValue1);
3393 setValue1 = 3.1;
3394 EXPECT_EQ(setValue1, want_->GetFloatParam(setKey2, setValue1));
3395 setValue1 = 4.1;
3396 want_->SetParam(setKey1, setValue1);
3397 EXPECT_EQ(setValue1, want_->GetFloatParam(setKey1, setValue2));
3398 }
3399
3400 /**
3401 * @tc.number: AaFwk_Want_FloatParam_0400
3402 * @tc.name: SetParam/GetFloatParam
3403 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key.
3404 */
3405 HWTEST_F(WantFloatParamTest, AaFwk_Want_FloatParam_0400, Function | MediumTest | Level1)
3406 {
3407 std::string setKey1 = "%1uH3";
3408 std::string setKey2 = "aa";
3409 float setValue1 = -1.1;
3410 float setValue2 = 9.1;
3411 want_->SetParam(setKey1, setValue1);
3412 want_->SetParam(setKey1, setValue1);
3413 setValue1 = 0.1;
3414 want_->SetParam(setKey1, setValue1);
3415 EXPECT_EQ(setValue1, want_->GetFloatParam(setKey1, setValue2));
3416 setValue1 = 4.1;
3417 want_->SetParam(setKey1, setValue1);
3418 setValue1 = -10.1;
3419 EXPECT_EQ(setValue1, want_->GetFloatParam(setKey2, setValue1));
3420 }
3421
3422 using testDoubleType = std::tuple<std::string, std::string, double, double, double>;
3423 class WantDoubleParamTest : public testing::TestWithParam<testDoubleType> {
3424 public:
WantDoubleParamTest()3425 WantDoubleParamTest()
3426 {
3427 want_ = nullptr;
3428 }
~WantDoubleParamTest()3429 ~WantDoubleParamTest()
3430 {
3431 want_ = nullptr;
3432 }
3433 static void SetUpTestCase(void);
3434 static void TearDownTestCase(void);
3435 void SetUp();
3436 void TearDown();
3437 std::shared_ptr<Want> want_;
3438 };
3439
SetUpTestCase(void)3440 void WantDoubleParamTest::SetUpTestCase(void)
3441 {}
3442
TearDownTestCase(void)3443 void WantDoubleParamTest::TearDownTestCase(void)
3444 {}
3445
SetUp(void)3446 void WantDoubleParamTest::SetUp(void)
3447 {
3448 want_ = std::make_shared<Want>();
3449 }
3450
TearDown(void)3451 void WantDoubleParamTest::TearDown(void)
3452 {}
3453
3454 /**
3455 * @tc.number: AaFwk_Want_DoubleParam_0100
3456 * @tc.name: SetParam/GetDoubleParam
3457 * @tc.desc: Verify when parameter change.
3458 */
3459 HWTEST_P(WantDoubleParamTest, AaFwk_Want_DoubleParam_0100, Function | MediumTest | Level1)
3460 {
3461 std::string setKey = std::get<0>(GetParam());
3462 std::string getKey = std::get<1>(GetParam());
3463 double setValue = std::get<2>(GetParam());
3464 double defaultValue = std::get<3>(GetParam());
3465 double result = std::get<4>(GetParam());
3466 want_->SetParam(setKey, setValue);
3467 EXPECT_EQ(result, want_->GetDoubleParam(getKey, defaultValue));
3468 }
3469
3470 INSTANTIATE_TEST_CASE_P(WantDoubleParamTestCaseP, WantDoubleParamTest,
3471 testing::Values(testDoubleType("", "aa", -1.1, 100.1, 100.1), testDoubleType("", "", -9.1, -41.1, -9.1),
3472 testDoubleType("1*中_aR", "aa", 50.1, 5.1, 5.1),
3473 testDoubleType("1*中_aR", "1*中_aR", -5000.1, 5000.1, -5000.1)));
3474
3475 /**
3476 * @tc.number: AaFwk_Want_DoubleParam_0300
3477 * @tc.name: SetParam & GetDoubleParam
3478 * @tc.desc: set empty-string key repeatedly, but get param of another nonexistent key.
3479 */
3480 HWTEST_F(WantDoubleParamTest, AaFwk_Want_DoubleParam_0300, Function | MediumTest | Level1)
3481 {
3482 double defaultValue = 100.1;
3483 std::string key = "aa";
3484 EXPECT_EQ(defaultValue, want_->GetDoubleParam(key, defaultValue));
3485 }
3486
3487 /**
3488 * @tc.number: AaFwk_Want_DoubleParam_0400
3489 * @tc.name: SetParam & GetDoubleParam
3490 * @tc.desc: set empty-string key repeatedly, then get param of the key.
3491 */
3492 HWTEST_F(WantDoubleParamTest, AaFwk_Want_DoubleParam_0400, Function | MediumTest | Level1)
3493 {
3494 std::string setKey1 = "ff";
3495 std::string setKey2 = "aa";
3496 double setValue1 = 1.1;
3497 double setValue2 = 5.1;
3498 want_->SetParam(setKey1, setValue1);
3499 want_->SetParam(setKey1, setValue1);
3500 setValue1 = 2.1;
3501 want_->SetParam(setKey1, setValue1);
3502 setValue1 = 3.1;
3503 EXPECT_EQ(setValue1, want_->GetDoubleParam(setKey2, setValue1));
3504 setValue1 = 4.1;
3505 want_->SetParam(setKey1, setValue1);
3506 EXPECT_EQ(setValue1, want_->GetDoubleParam(setKey1, setValue2));
3507 }
3508
3509 /**
3510 * @tc.number: AaFwk_Want_ByteArray_0100
3511 * @tc.name: SetParam/GetByteArrayParam
3512 * @tc.desc: Verify when parameter change.
3513 */
3514 HWTEST_F(WantDoubleParamTest, AaFwk_Want_ByteArray_0100, Function | MediumTest | Level1)
3515 {
3516 std::string setKey1 = "%1uH3";
3517 std::string setKey2 = "aa";
3518 double setValue1 = -1.1;
3519 double setValue2 = 9.1;
3520 want_->SetParam(setKey1, setValue1);
3521 want_->SetParam(setKey1, setValue1);
3522 setValue1 = 0.1;
3523 want_->SetParam(setKey1, setValue1);
3524 EXPECT_EQ(setValue1, want_->GetDoubleParam(setKey1, setValue2));
3525 setValue1 = 4.1;
3526 want_->SetParam(setKey1, setValue1);
3527 setValue1 = -10.1;
3528 EXPECT_EQ(setValue1, want_->GetDoubleParam(setKey2, setValue1));
3529 }
3530
3531 using testByteArrayType = std::tuple<std::string, std::string, std::vector<byte>, std::vector<byte>, std::vector<byte>>;
3532 class WantByteArrayParamTest : public testing::TestWithParam<testByteArrayType> {
3533 public:
WantByteArrayParamTest()3534 WantByteArrayParamTest()
3535 {
3536 want_ = nullptr;
3537 }
~WantByteArrayParamTest()3538 ~WantByteArrayParamTest()
3539 {
3540 want_ = nullptr;
3541 }
3542 static void SetUpTestCase(void);
3543 static void TearDownTestCase(void);
3544 void SetUp();
3545 void TearDown();
3546 std::shared_ptr<Want> want_;
3547 };
3548
SetUpTestCase(void)3549 void WantByteArrayParamTest::SetUpTestCase(void)
3550 {}
3551
TearDownTestCase(void)3552 void WantByteArrayParamTest::TearDownTestCase(void)
3553 {}
3554
SetUp(void)3555 void WantByteArrayParamTest::SetUp(void)
3556 {
3557 want_ = std::make_shared<Want>();
3558 }
3559
TearDown(void)3560 void WantByteArrayParamTest::TearDown(void)
3561 {}
3562
3563 /**
3564 * @tc.number: AaFwk_Want_ByteArray_0100
3565 * @tc.name: SetParam/GetByteArrayParam
3566 * @tc.desc: Verify when parameter change.
3567 */
3568 HWTEST_P(WantByteArrayParamTest, AaFwk_Want_ByteArray_0100, Function | MediumTest | Level1)
3569 {
3570 std::string setKey = std::get<0>(GetParam());
3571 std::string getKey = std::get<1>(GetParam());
3572 std::vector<byte> setValue = std::get<2>(GetParam());
3573 std::vector<byte> defaultValue = std::get<3>(GetParam());
3574 std::vector<byte> result = std::get<4>(GetParam());
3575 want_->SetParam(setKey, setValue);
3576 EXPECT_EQ(result, want_->GetByteArrayParam(getKey));
3577 }
3578
3579 INSTANTIATE_TEST_CASE_P(WantByteArrayParamTestCaseP, WantByteArrayParamTest,
3580 testing::Values(testByteArrayType("", "aa", {'*', 'D'}, {}, {}),
3581 testByteArrayType("", "", {'%', ')'}, {}, {'%', ')'}), testByteArrayType("1*中_aR", "aa", {'R', '.'}, {}, {}),
3582 testByteArrayType("1*中_aR", "1*中_aR", {'R', 'b'}, {}, {'R', 'b'})));
3583
3584 /**
3585 * @tc.number: AaFwk_Want_ByteArray_0200
3586 * @tc.name: SetParam/GetByteArrayParam
3587 * @tc.desc: Verify when the value is byte array.
3588 */
3589 HWTEST_F(WantByteArrayParamTest, AaFwk_Want_ByteArray_0200, Function | MediumTest | Level1)
3590 {
3591 std::vector<byte> defaultValue;
3592 std::string getKey("aa");
3593 EXPECT_EQ(defaultValue, want_->GetByteArrayParam(getKey));
3594 }
3595
3596 /**
3597 * @tc.number: AaFwk_Want_ByteArray_0300
3598 * @tc.name: SetParam/GetByteArrayParam
3599 * @tc.desc: Verify when the value is byte array.
3600 */
3601 HWTEST_F(WantByteArrayParamTest, AaFwk_Want_ByteArray_0300, Function | MediumTest | Level1)
3602 {
3603 std::string emptyStr("gg");
3604 std::vector<byte> firstValue({'a', '2'});
3605 std::vector<byte> secondValue({'1', 'd'});
3606 std::vector<byte> thirdValue({'t', '3'});
3607 std::string keyStr("aa");
3608 want_->SetParam(emptyStr, firstValue);
3609 want_->SetParam(emptyStr, firstValue);
3610 want_->SetParam(emptyStr, secondValue);
3611 std::vector<byte> defaultValue;
3612 EXPECT_EQ(defaultValue, want_->GetByteArrayParam(keyStr));
3613 want_->SetParam(emptyStr, thirdValue);
3614 EXPECT_EQ(thirdValue, want_->GetByteArrayParam(emptyStr));
3615 }
3616
3617 /**
3618 * @tc.number: AaFwk_Want_ByteArray_0400
3619 * @tc.name: SetParam/GetByteArrayParam
3620 * @tc.desc: Verify when the value is byte array.
3621 */
3622 HWTEST_F(WantByteArrayParamTest, AaFwk_Want_ByteArray_0400, Function | MediumTest | Level1)
3623 {
3624 std::string firstKey("%1uH3");
3625 std::vector<byte> firstValue({'a', '2'});
3626 std::vector<byte> secondValue({'w', '$'});
3627 std::vector<byte> defaultValue;
3628 std::string secondKey("aa");
3629 want_->SetParam(firstKey, firstValue);
3630 want_->SetParam(firstKey, firstValue);
3631 want_->SetParam(firstKey, secondValue);
3632 EXPECT_EQ(secondValue, want_->GetByteArrayParam(firstKey));
3633 want_->SetParam(firstKey, firstValue);
3634 EXPECT_EQ(defaultValue, want_->GetByteArrayParam(secondKey));
3635 }
3636
3637 using testBoolType = std::tuple<std::string, std::string, bool, bool, bool>;
3638 class WantBoolParamTest : public testing::TestWithParam<testBoolType> {
3639 public:
WantBoolParamTest()3640 WantBoolParamTest()
3641 {
3642 want_ = nullptr;
3643 }
~WantBoolParamTest()3644 ~WantBoolParamTest()
3645 {
3646 want_ = nullptr;
3647 }
3648 static void SetUpTestCase(void);
3649 static void TearDownTestCase(void);
3650 void SetUp();
3651 void TearDown();
3652 std::shared_ptr<Want> want_;
3653 };
3654
SetUpTestCase(void)3655 void WantBoolParamTest::SetUpTestCase(void)
3656 {}
3657
TearDownTestCase(void)3658 void WantBoolParamTest::TearDownTestCase(void)
3659 {}
3660
SetUp(void)3661 void WantBoolParamTest::SetUp(void)
3662 {
3663 want_ = std::make_shared<Want>();
3664 }
3665
TearDown(void)3666 void WantBoolParamTest::TearDown(void)
3667 {}
3668
3669 /**
3670 * @tc.number: AaFwk_Want_BoolParam_0100
3671 * @tc.name: SetParam/GetBoolParam
3672 * @tc.desc: Verify when parameter change.
3673 */
3674 HWTEST_P(WantBoolParamTest, AaFwk_Want_BoolParam_0100, Function | MediumTest | Level1)
3675 {
3676 std::string setKey = std::get<0>(GetParam());
3677 std::string getKey = std::get<1>(GetParam());
3678 bool setValue = std::get<2>(GetParam());
3679 bool defaultValue = std::get<3>(GetParam());
3680 bool result = std::get<4>(GetParam());
3681 want_->SetParam(setKey, setValue);
3682 EXPECT_EQ(result, want_->GetBoolParam(getKey, defaultValue));
3683 }
3684
3685 INSTANTIATE_TEST_CASE_P(WantBoolParamTestCaseP, WantBoolParamTest,
3686 testing::Values(testBoolType("b1", "aa", true, true, true), testBoolType("b1", "aa", true, false, false),
3687 testBoolType("b2", "b2", true, true, true), testBoolType("b3", "b3", true, false, true),
3688 testBoolType("123", "123", true, false, true), testBoolType("123", "aa", true, false, false),
3689 testBoolType("-~*&%￥", "-~*&%￥", true, false, true), testBoolType("-~*&%￥", "aa", true, false, false),
3690 testBoolType("中文", "中文", true, false, true), testBoolType("中文", "aa", true, false, false),
3691 testBoolType("_中文ddPEJKJ#(&*~#^%", "_中文ddPEJKJ#(&*~#^%", true, false, true),
3692 testBoolType("_中文ddPEJKJ#(&*~#^%", "123", true, false, false)));
3693
3694 /**
3695 * @tc.number: AaFwk_Want_BoolParam_0200
3696 * @tc.name: SetParam/GetBoolParam
3697 * @tc.desc: Verify when set twice and get twice.
3698 */
3699 HWTEST_F(WantBoolParamTest, AaFwk_Want_BoolParam_0200, Function | MediumTest | Level1)
3700 {
3701 std::string firstKey("_中文ddPEJKJ#(&*~#^%");
3702 std::string secondKey("key33");
3703 want_->SetParam(firstKey, true);
3704 want_->SetParam(secondKey, true);
3705 EXPECT_EQ(true, want_->GetBoolParam(firstKey, false));
3706 EXPECT_EQ(true, want_->GetBoolParam(secondKey, false));
3707 }
3708
3709 /**
3710 * @tc.number: AaFwk_Want_BoolParam_0300
3711 * @tc.name: SetParam/GetBoolParam
3712 * @tc.desc: Verify when set 20 times, and get once.
3713 */
3714 HWTEST_F(WantBoolParamTest, AaFwk_Want_BoolParam_0300, Function | MediumTest | Level1)
3715 {
3716 std::string keyStr("_中文ddPEJKJ#(&*~#^%");
3717 for (int i = 0; i < 20; i++) {
3718 want_->SetParam(keyStr, true);
3719 }
3720 EXPECT_EQ(true, want_->GetBoolParam(keyStr, false));
3721 }
3722
3723 /**
3724 * @tc.number: AaFwk_Want_Want_0100
3725 * @tc.name: Want() and Want(want)
3726 * @tc.desc: Verify Want()
3727 */
3728 HWTEST_F(WantBaseTest, AaFwk_Want_Want_0100, Function | MediumTest | Level1)
3729 {
3730 Want want;
3731
3732 EXPECT_EQ((uint)0, want.GetFlags());
3733 EXPECT_EQ(std::string(""), want.GetAction());
3734
3735 std::vector<std::string> vect = want.GetEntities();
3736 EXPECT_EQ((size_t)0, vect.size());
3737 EXPECT_EQ(std::string(""), want.GetType());
3738
3739 want.SetFlags(10);
3740 want.SetAction("system.Action.test");
3741 want.AddEntity("system.Entity.test");
3742 want.SetType("system.Type.test");
3743
3744 Want want2(want);
3745 EXPECT_EQ("system.Action.test", want2.GetAction());
3746 EXPECT_EQ(true, want2.HasEntity("system.Entity.test"));
3747 EXPECT_EQ("system.Type.test", want2.GetType());
3748 }
3749
3750 /**
3751 * @tc.number: AaFwk_Want_Entity_0100
3752 * @tc.name: [AddEntity or RemoveEntity] & HasEntity &CountEntities
3753 * @tc.desc: Verify [AddEntity or RemoveEntity] & HasEntity &CountEntities
3754 */
3755 HWTEST_F(WantBaseTest, AaFwk_Want_Entity_0100, Function | MediumTest | Level1)
3756 {
3757 std::string entity1 = "entity.system.entity1";
3758
3759 want_->AddEntity(entity1);
3760
3761 EXPECT_EQ(true, want_->HasEntity(entity1));
3762 EXPECT_EQ(1, want_->CountEntities());
3763 want_->RemoveEntity(entity1);
3764 EXPECT_EQ(false, want_->HasEntity(entity1));
3765 EXPECT_EQ(0, want_->CountEntities());
3766 int length = want_->GetEntities().size();
3767 EXPECT_EQ(0, length);
3768
3769 std::string entity2 = "entity.system.entity2";
3770
3771 want_->AddEntity(entity1);
3772 want_->AddEntity(entity2);
3773
3774 EXPECT_EQ(true, want_->HasEntity(entity1));
3775 EXPECT_EQ(2, want_->CountEntities());
3776 EXPECT_EQ(true, want_->HasEntity(entity2));
3777 EXPECT_EQ(2, want_->CountEntities());
3778
3779 want_->RemoveEntity(entity1);
3780 want_->RemoveEntity(entity2);
3781 EXPECT_EQ(0, want_->CountEntities());
3782 int length2 = want_->GetEntities().size();
3783
3784 EXPECT_EQ(0, length2);
3785 }
3786
3787 /**
3788 * @tc.number: AaFwk_Want_HasParameter_0100
3789 * @tc.name: SetParam and HasParameter
3790 * @tc.desc: Verify HasParameter()
3791 */
3792 HWTEST_F(WantBaseTest, AaFwk_Want_HasParameter_0100, Function | MediumTest | Level1)
3793 {
3794
3795 std::vector<std::string> vector;
3796 std::string key = "system.want.test.key";
3797 std::string key2 = "system.want.test.key2";
3798
3799 vector.push_back("system.want.test.content");
3800 want_->SetParam(key, vector);
3801 EXPECT_EQ(true, want_->HasParameter(key));
3802
3803 want_->SetParam(key2, vector);
3804 EXPECT_EQ(true, want_->HasParameter(key2));
3805 }
3806 /**
3807 * @tc.number: AaFwk_Want_HasParameter_0200
3808 * @tc.name: SetParam and HasParameter
3809 * @tc.desc: Verify HasParameter()
3810 */
3811 HWTEST_F(WantBaseTest, AaFwk_Want_HasParameter_0200, Function | MediumTest | Level1)
3812 {
3813 std::string key = std::to_string(Array::SIGNATURE) + ".#Intent;key=3{\"\\b\\\";end";
3814 std::vector<zchar> arrayValue = {'.', '=', ';'};
3815 std::shared_ptr<Want> p1 = std::make_shared<Want>();
3816 if (p1 == nullptr) {
3817 return;
3818 }
3819 p1->SetParam(key, arrayValue);
3820 Want *newWant = nullptr;
3821 newWant = Want::ParseUri(p1->ToUri());
3822 if (newWant == nullptr) {
3823 return;
3824 }
3825 std::shared_ptr<Want> p2(newWant);
3826 CompareWant(p1, p2);
3827 }
3828 /**
3829 * @tc.number: AaFwk_Want_ToString_0100
3830 * @tc.name: ToString and FromString
3831 * @tc.desc: Verify FromString()
3832 */
3833 HWTEST_F(WantBaseTest, AaFwk_Want_ToString_0100, Function | MediumTest | Level1)
3834 {
3835 std::string deviceId = "deviceId";
3836 std::string bundleName = "bundleName";
3837 std::string abilityName ="abilityName";
3838 std::string uri = "url";
3839 std::string type = "type";
3840 unsigned int flags = 1;
3841 std::string action = "action";
3842 WantParams parameters;
3843 std::vector<std::string> entities = {"entity.system.entity1", "entity.system.entity2"};
3844
3845 std::string keyBool = "key_bool";
3846 bool valueBool = true;
3847 parameters.SetParam(keyBool, Boolean::Box(valueBool));
3848
3849 std::string keyStr = "key_string";
3850 std::string valueString = "123";
3851 parameters.SetParam(keyStr, String::Box(valueString));
3852
3853 std::string keyInt = "key_int";
3854 int valueInt = 111;
3855 parameters.SetParam(keyStr, Integer::Box(valueInt));
3856
3857 std::shared_ptr<Want> want1 = std::make_shared<Want>();
3858 if (want1 == nullptr) {
3859 return;
3860 }
3861 want1->SetElementName(deviceId, bundleName, abilityName);
3862 want1->SetUri(uri);
3863 want1->SetType(type);
3864 want1->SetFlags(flags);
3865 want1->SetAction(action);
3866 for (auto entity : entities) {
3867 want1->AddEntity(entity);
3868 }
3869
3870 std::string jsonString = want1->ToString();
3871 Want *newWant = Want::FromString(jsonString);
3872 if (newWant == nullptr) {
3873 return;
3874 }
3875 std::shared_ptr<Want> want2(newWant);
3876
3877 CompareWant(want1, want2);
3878 }
3879 } // namespace AAFwk
3880 } // namespace OHOS