1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <cstdint>
18
19 #define private public
20 #include "want_params_wrapper.h"
21 #undef protected
22 #include "byte_wrapper.h"
23 #include "double_wrapper.h"
24 #include "float_wrapper.h"
25 #include "int_wrapper.h"
26 #include "long_wrapper.h"
27 #include "short_wrapper.h"
28 #include "string_wrapper.h"
29
30 using namespace testing::ext;
31 using namespace OHOS;
32 using namespace AAFwk;
33
34 namespace {
35 const std::string STRING_WANT_PARAMS_KEY_01 = "key01";
36 const std::string STRING_WANT_PARAMS_VALUE_01 = "value01";
37 const std::string STRING_WANT_PARAMS_STRING_01 = "{\"key01\":{\"9\":\"value01\"}}";
38
39 const std::string STRING_WANT_PARAMS_KEY_02 = "key02";
40 const std::string STRING_WANT_PARAMS_VALUE_02 = "value02";
41 const std::string STRING_WANT_PARAMS_STRING_0201 =
42 "{\"key01\":{\"101\":{\"key02\":{\"9\":\"value02\"}}},\"key02\":{\"9\":\"value02\"}}";
43 } // namespace
44
45 class WantParamWrapperBaseTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp() override;
50 void TearDown() override;
51
52 WantParams wantParams_;
53 std::shared_ptr<WantParamWrapper> wantParamWrapperPtr_;
54 };
55
SetUpTestCase()56 void WantParamWrapperBaseTest::SetUpTestCase()
57 {}
58
TearDownTestCase(void)59 void WantParamWrapperBaseTest::TearDownTestCase(void)
60 {}
61
SetUp(void)62 void WantParamWrapperBaseTest::SetUp(void)
63 {
64 wantParams_ = {};
65 wantParams_.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
66 wantParamWrapperPtr_ = std::make_shared<WantParamWrapper>(wantParams_);
67 }
68
TearDown(void)69 void WantParamWrapperBaseTest::TearDown(void)
70 {}
71
72 /**
73 * @tc.number: Want_Param_Wrapper_0100
74 * @tc.name: GetValue
75 * @tc.desc: Verify the "GetValue" function.
76 */
77 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0100, Function | MediumTest | Level1)
78 {
79 WantParams wantParams;
80 ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
81
82 EXPECT_EQ(result, ERR_OK);
83
84 EXPECT_EQ(wantParams_ == wantParams, true);
85 }
86
87 /**
88 * @tc.number: Want_Param_Wrapper_0200
89 * @tc.name: GetValue
90 * @tc.desc: Verify the "GetValue" function.
91 */
92 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0200, Function | MediumTest | Level1)
93 {
94 WantParams wantParams;
95 ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
96
97 EXPECT_EQ(result, ERR_OK);
98
99 // make another empty WantParams
100 WantParams wantParamsEmpty = {};
101
102 EXPECT_EQ(wantParams_ == wantParamsEmpty, false);
103 }
104
105 /**
106 * @tc.number: Want_Param_Wrapper_0300
107 * @tc.name: Equals
108 * @tc.desc: Verify the "Equals" function.
109 */
110 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0300, Function | MediumTest | Level1)
111 {
112 WantParams wantParams;
113 wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
114 WantParamWrapper wantParamWrapper(wantParams);
115
116 bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
117
118 EXPECT_EQ(result, true);
119 }
120
121 /**
122 * @tc.number: Want_Param_Wrapper_0400
123 * @tc.name: Equals
124 * @tc.desc: Verify the "Equals" function.
125 */
126 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0400, Function | MediumTest | Level1)
127 {
128 WantParams wantParams;
129 WantParamWrapper wantParamWrapper(wantParams);
130
131 bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
132
133 EXPECT_EQ(result, false);
134 }
135
136 /**
137 * @tc.number: Want_Param_Wrapper_0500
138 * @tc.name: Box
139 * @tc.desc: Verify the "Box" function.
140 */
141 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0500, Function | MediumTest | Level1)
142 {
143 auto wantParamsPtr = WantParamWrapper::Box(wantParams_);
144
145 WantParams wantParams;
146 ErrCode result = wantParamsPtr->GetValue(wantParams);
147
148 EXPECT_EQ(result, ERR_OK);
149
150 EXPECT_EQ(wantParams_ == wantParams, true);
151 }
152
153 /**
154 * @tc.number: Want_Param_Wrapper_0600
155 * @tc.name: Box
156 * @tc.desc: Verify the "Box" function with am empty object.
157 */
158 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0600, Function | MediumTest | Level1)
159 {
160 auto wantParamsPtr = WantParamWrapper::Box({});
161
162 EXPECT_NE(wantParamsPtr, nullptr);
163
164 WantParams wantParams;
165 ErrCode result = wantParamsPtr->GetValue(wantParams);
166
167 EXPECT_EQ(result, ERR_OK);
168
169 // make another empty WantParams
170 WantParams wantParamsEmpty = {};
171
172 EXPECT_EQ(wantParams == wantParamsEmpty, true);
173 }
174
175 /**
176 * @tc.number: Want_Param_Wrapper_0700
177 * @tc.name: Unbox
178 * @tc.desc: Verify the "Unbox" function.
179 */
180 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0700, Function | MediumTest | Level1)
181 {
182 auto wantParamsPtr = WantParamWrapper::Box(wantParams_);
183
184 auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
185
186 EXPECT_EQ(wantParams_ == wantParams, true);
187 }
188
189 /**
190 * @tc.number: Want_Param_Wrapper_0800
191 * @tc.name: Unbox
192 * @tc.desc: Verify the "Unbox" function with a nullptr
193 */
194 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0800, Function | MediumTest | Level1)
195 {
196 auto wantParams = WantParamWrapper::Unbox(nullptr);
197
198 // make another empty WantParams
199 WantParams wantParamsEmpty = {};
200
201 EXPECT_EQ(wantParams == wantParamsEmpty, true);
202 }
203
204 /**
205 * @tc.number: Want_Param_Wrapper_0900
206 * @tc.name: ValidateStr
207 * @tc.desc: Verify the "ValidateStr" function.
208 */
209 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0900, Function | MediumTest | Level1)
210 {
211 bool result = WantParamWrapper::ValidateStr("{");
212
213 EXPECT_EQ(result, false);
214 }
215
216 /**
217 * @tc.number: Want_Param_Wrapper_1000
218 * @tc.name: ValidateStr
219 * @tc.desc: Verify the "ValidateStr" function.
220 */
221 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1000, Function | MediumTest | Level1)
222 {
223 bool result = WantParamWrapper::ValidateStr("}");
224
225 EXPECT_EQ(result, false);
226 }
227
228 /**
229 * @tc.number: Want_Param_Wrapper_1100
230 * @tc.name: ValidateStr
231 * @tc.desc: Verify the "ValidateStr" function.
232 */
233 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1100, Function | MediumTest | Level1)
234 {
235 bool result = WantParamWrapper::ValidateStr("}{");
236
237 EXPECT_EQ(result, false);
238 }
239
240 /**
241 * @tc.number: Want_Param_Wrapper_1200
242 * @tc.name: ValidateStr
243 * @tc.desc: Verify the "ValidateStr" function.
244 */
245 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1200, Function | MediumTest | Level1)
246 {
247 bool result = WantParamWrapper::ValidateStr("{\"\"}");
248
249 EXPECT_EQ(result, false);
250 }
251
252 /**
253 * @tc.number: Want_Param_Wrapper_1300
254 * @tc.name: Parse
255 * @tc.desc: Verify the "Parse" function.
256 */
257 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1300, Function | MediumTest | Level1)
258 {
259 auto wantParamsPtr = WantParamWrapper::Parse("");
260
261 auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
262
263 // make another empty WantParams
264 WantParams wantParamsEmpty = {};
265
266 EXPECT_EQ(wantParams == wantParamsEmpty, true);
267 }
268
269 /**
270 * @tc.number: Want_Param_Wrapper_1400
271 * @tc.name: Parse
272 * @tc.desc: Verify the "Parse" function.
273 */
274 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1400, Function | MediumTest | Level1)
275 {
276 auto wantParamsPtr = WantParamWrapper::Parse("{}");
277
278 auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
279
280 // make another empty WantParams
281 WantParams wantParamsEmpty = {};
282
283 EXPECT_EQ(wantParams == wantParamsEmpty, true);
284 }
285
286 /**
287 * @tc.number: Want_Param_Wrapper_1500
288 * @tc.name: ToString
289 * @tc.desc: Verify the "ToString" function.
290 */
291 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1500, Function | MediumTest | Level1)
292 {
293 auto wantParamsString = wantParamWrapperPtr_->ToString();
294
295 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
296 }
297
298 /**
299 * @tc.number: Want_Param_Wrapper_1600
300 * @tc.name: ToString
301 * @tc.desc: Verify the "ToString" function.
302 */
303 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1600, Function | MediumTest | Level1)
304 {
305 WantParams wantParams = {};
306 WantParamWrapper wantParamWrapper(wantParams);
307
308 auto wantParamsString = wantParamWrapper.ToString();
309
310 EXPECT_EQ(wantParamsString, "{}");
311 }
312
313 /**
314 * @tc.number: Want_Param_Wrapper_1700
315 * @tc.name: ToString
316 * @tc.desc: Verify the "ToString" function.
317 */
318 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1700, Function | MediumTest | Level1)
319 {
320 WantParams wantParams = {};
321 wantParams.SetParam(STRING_WANT_PARAMS_KEY_02, String::Box(STRING_WANT_PARAMS_VALUE_02));
322 wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, WantParamWrapper::Box(wantParams));
323 WantParamWrapper wantParamWrapper(wantParams);
324
325 auto wantParamsString = wantParamWrapper.ToString();
326
327 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_0201);
328 }
329
330 /**
331 * @tc.number: Want_Param_Wrapper_1800
332 * @tc.name: from ToString to Parse
333 * @tc.desc: Verify the "from ToString to Parse" function.
334 */
335 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1800, Function | MediumTest | Level1)
336 {
337 auto wantParamsString = wantParamWrapperPtr_->ToString();
338
339 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
340
341 auto wantParamsPtr = WantParamWrapper::Parse(wantParamsString);
342
343 auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
344
345 EXPECT_EQ(wantParams_ == wantParams, true);
346 }
347
348 /**
349 * @tc.number: Want_Param_Wrapper_1900
350 * @tc.name: ParseWantParams
351 * @tc.desc: Verify the "ParseWantParams" function.
352 */
353 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1900, Function | MediumTest | Level1)
354 {
355 std::string testStr = "{\"byteTest1\":{\"2\":\"\"},\"byteTest2\":{\"2\":\"127\"},\"byteTest3\":{\"2\":\"abc123\"},"
356 "\"doubleTest1\":{\"8\":\"\"},\"doubleTest2\":{\"8\":\"3.14\"},\"doubleTest3\":{\"8\":\"abc123\"},"
357 "\"floatTest1\":{\"7\":\"\"},\"floatTest2\":{\"7\":\"3.14\"},\"floatTest3\":{\"7\":\"abc123\"},"
358 "\"intTest1\":{\"5\":\"\"},\"intTest2\":{\"5\":\"2147483647\"},\"intTest3\":{\"5\":\"abc123\"},"
359 "\"longTest1\":{\"6\":\"\"},\"longTest2\":{\"6\":\"2147483647\"},\"longTest3\":{\"6\":\"abc123\"},"
360 "\"shortTest1\":{\"4\":\"\"},\"shortTest2\":{\"4\":\"32767\"},\"shortTest3\":{\"4\":\"abc123\"}}";
361 WantParams wantParams = WantParamWrapper::ParseWantParams(testStr);
362
363 auto byteTest1Value = wantParams.GetParam("byteTest1");
364 EXPECT_EQ(byteTest1Value, nullptr);
365 auto byteTest2Value = wantParams.GetParam("byteTest2");
366 EXPECT_NE(byteTest2Value, nullptr);
367 IByte *iByte = IByte::Query(byteTest2Value);
368 EXPECT_NE(iByte, nullptr);
369 byte byteVal = Byte::Unbox(iByte);
370 EXPECT_EQ(byteVal, INT8_MAX);
371 auto byteTest3Value = wantParams.GetParam("byteTest3");
372 EXPECT_EQ(byteTest3Value, nullptr);
373
374 auto shortTest1Value = wantParams.GetParam("shortTest1");
375 EXPECT_EQ(shortTest1Value, nullptr);
376 auto shortTest2Value = wantParams.GetParam("shortTest2");
377 EXPECT_NE(shortTest2Value, nullptr);
378 IShort *iShort = IShort::Query(shortTest2Value);
379 EXPECT_NE(iShort, nullptr);
380 short shortVal = Short::Unbox(iShort);
381 EXPECT_EQ(shortVal, INT16_MAX);
382 auto shortTest3Value = wantParams.GetParam("shortTest3");
383 EXPECT_EQ(shortTest3Value, nullptr);
384 }
385
386 /**
387 * @tc.number: Want_Param_Wrapper_2000
388 * @tc.name: ParseWantParams
389 * @tc.desc: Verify the "ParseWantParams" function.
390 */
391 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_2000, Function | MediumTest | Level1)
392 {
393 std::string testStr = "{\"byteTest1\":{\"2\":\"\"},\"byteTest2\":{\"2\":\"127\"},\"byteTest3\":{\"2\":\"abc123\"},"
394 "\"doubleTest1\":{\"8\":\"\"},\"doubleTest2\":{\"8\":\"3.14\"},\"doubleTest3\":{\"8\":\"abc123\"},"
395 "\"floatTest1\":{\"7\":\"\"},\"floatTest2\":{\"7\":\"3.14\"},\"floatTest3\":{\"7\":\"abc123\"},"
396 "\"intTest1\":{\"5\":\"\"},\"intTest2\":{\"5\":\"2147483647\"},\"intTest3\":{\"5\":\"abc123\"},"
397 "\"longTest1\":{\"6\":\"\"},\"longTest2\":{\"6\":\"2147483647\"},\"longTest3\":{\"6\":\"abc123\"},"
398 "\"shortTest1\":{\"4\":\"\"},\"shortTest2\":{\"4\":\"32767\"},\"shortTest3\":{\"4\":\"abc123\"}}";
399 WantParams wantParams = WantParamWrapper::ParseWantParams(testStr);
400
401 auto doubleTest1Value = wantParams.GetParam("doubleTest1");
402 EXPECT_EQ(doubleTest1Value, nullptr);
403 auto doubleTest2Value = wantParams.GetParam("doubleTest2");
404 EXPECT_NE(doubleTest2Value, nullptr);
405 IDouble *iDouble = IDouble::Query(doubleTest2Value);
406 EXPECT_NE(iDouble, nullptr);
407 double doubleVal = Double::Unbox(iDouble);
408 EXPECT_FLOAT_EQ(doubleVal, 3.14f);
409 auto doubleTest3Value = wantParams.GetParam("doubleTest3");
410 EXPECT_EQ(doubleTest3Value, nullptr);
411
412 auto floatTest1Value = wantParams.GetParam("floatTest1");
413 EXPECT_EQ(floatTest1Value, nullptr);
414 auto floatTest2Value = wantParams.GetParam("floatTest2");
415 EXPECT_NE(floatTest2Value, nullptr);
416 IFloat *iFloat = IFloat::Query(floatTest2Value);
417 EXPECT_NE(iFloat, nullptr);
418 float floatVal = Float::Unbox(iFloat);
419 EXPECT_FLOAT_EQ(floatVal, 3.14f);
420 auto floatTest3Value = wantParams.GetParam("floatTest3");
421 EXPECT_EQ(floatTest3Value, nullptr);
422 }
423
424 /**
425 * @tc.number: Want_Param_Wrapper_2100
426 * @tc.name: ParseWantParams
427 * @tc.desc: Verify the "ParseWantParams" function.
428 */
429 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_2100, Function | MediumTest | Level1)
430 {
431 std::string testStr = "{\"byteTest1\":{\"2\":\"\"},\"byteTest2\":{\"2\":\"127\"},\"byteTest3\":{\"2\":\"abc123\"},"
432 "\"doubleTest1\":{\"8\":\"\"},\"doubleTest2\":{\"8\":\"3.14\"},\"doubleTest3\":{\"8\":\"abc123\"},"
433 "\"floatTest1\":{\"7\":\"\"},\"floatTest2\":{\"7\":\"3.14\"},\"floatTest3\":{\"7\":\"abc123\"},"
434 "\"intTest1\":{\"5\":\"\"},\"intTest2\":{\"5\":\"2147483647\"},\"intTest3\":{\"5\":\"abc123\"},"
435 "\"longTest1\":{\"6\":\"\"},\"longTest2\":{\"6\":\"2147483647\"},\"longTest3\":{\"6\":\"abc123\"},"
436 "\"shortTest1\":{\"4\":\"\"},\"shortTest2\":{\"4\":\"32767\"},\"shortTest3\":{\"4\":\"abc123\"}}";
437 WantParams wantParams = WantParamWrapper::ParseWantParams(testStr);
438
439 auto intTest1Value = wantParams.GetParam("intTest1");
440 EXPECT_EQ(intTest1Value, nullptr);
441 auto intTest2Value = wantParams.GetParam("intTest2");
442 EXPECT_NE(intTest2Value, nullptr);
443 IInteger *iInteger = IInteger::Query(intTest2Value);
444 EXPECT_NE(iInteger, nullptr);
445 int intVal = Integer::Unbox(iInteger);
446 EXPECT_EQ(intVal, INT32_MAX);
447 auto intTest3Value = wantParams.GetParam("intTest3");
448 EXPECT_EQ(intTest3Value, nullptr);
449
450 auto longTest1Value = wantParams.GetParam("longTest1");
451 EXPECT_EQ(longTest1Value, nullptr);
452 auto longTest2Value = wantParams.GetParam("longTest2");
453 EXPECT_NE(longTest2Value, nullptr);
454 ILong *iLong = ILong::Query(longTest2Value);
455 EXPECT_NE(iLong, nullptr);
456 long longVal = Long::Unbox(iLong);
457 EXPECT_EQ(longVal, INT32_MAX);
458 auto longTest3Value = wantParams.GetParam("longTest3");
459 EXPECT_EQ(longTest3Value, nullptr);
460 }
461