1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #define private public
19 #include "want_params_wrapper.h"
20 #undef protected
21 #include "string_wrapper.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace AAFwk;
26 
27 namespace {
28 const std::string STRING_WANT_PARAMS_KEY_01 = "key01";
29 const std::string STRING_WANT_PARAMS_VALUE_01 = "value01";
30 const std::string STRING_WANT_PARAMS_STRING_01 = "{\"key01\":{\"9\":\"value01\"}}";
31 
32 const std::string STRING_WANT_PARAMS_KEY_02 = "key02";
33 const std::string STRING_WANT_PARAMS_VALUE_02 = "value02";
34 const std::string STRING_WANT_PARAMS_STRING_0201 =
35     "{\"key01\":{\"101\":{\"key02\":{\"9\":\"value02\"}}},\"key02\":{\"9\":\"value02\"}}";
36 }  // namespace
37 
38 class WantParamWrapperBaseTest : public testing::Test {
39 public:
40     static void SetUpTestCase(void);
41     static void TearDownTestCase(void);
42     void SetUp() override;
43     void TearDown() override;
44 
45     WantParams wantParams_;
46     std::shared_ptr<WantParamWrapper> wantParamWrapperPtr_;
47 };
48 
SetUpTestCase()49 void WantParamWrapperBaseTest::SetUpTestCase()
50 {}
51 
TearDownTestCase(void)52 void WantParamWrapperBaseTest::TearDownTestCase(void)
53 {}
54 
SetUp(void)55 void WantParamWrapperBaseTest::SetUp(void)
56 {
57     wantParams_ = {};
58     wantParams_.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
59     wantParamWrapperPtr_ = std::make_shared<WantParamWrapper>(wantParams_);
60 }
61 
TearDown(void)62 void WantParamWrapperBaseTest::TearDown(void)
63 {}
64 
65 /**
66  * @tc.number: Want_Param_Wrapper_0100
67  * @tc.name: GetValue
68  * @tc.desc: Verify the "GetValue" function.
69  */
70 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0100, Function | MediumTest | Level1)
71 {
72     WantParams wantParams;
73     ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
74 
75     EXPECT_EQ(result, ERR_OK);
76 
77     EXPECT_EQ(wantParams_ == wantParams, true);
78 }
79 
80 /**
81  * @tc.number: Want_Param_Wrapper_0200
82  * @tc.name: GetValue
83  * @tc.desc: Verify the "GetValue" function.
84  */
85 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0200, Function | MediumTest | Level1)
86 {
87     WantParams wantParams;
88     ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
89 
90     EXPECT_EQ(result, ERR_OK);
91 
92     // make another empty WantParams
93     WantParams wantParamsEmpty = {};
94 
95     EXPECT_EQ(wantParams_ == wantParamsEmpty, false);
96 }
97 
98 /**
99  * @tc.number: Want_Param_Wrapper_0300
100  * @tc.name: Equals
101  * @tc.desc: Verify the "Equals" function.
102  */
103 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0300, Function | MediumTest | Level1)
104 {
105     WantParams wantParams;
106     wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
107     WantParamWrapper wantParamWrapper(wantParams);
108 
109     bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
110 
111     EXPECT_EQ(result, true);
112 }
113 
114 /**
115  * @tc.number: Want_Param_Wrapper_0400
116  * @tc.name: Equals
117  * @tc.desc: Verify the "Equals" function.
118  */
119 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0400, Function | MediumTest | Level1)
120 {
121     WantParams wantParams;
122     WantParamWrapper wantParamWrapper(wantParams);
123 
124     bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
125 
126     EXPECT_EQ(result, false);
127 }
128 
129 /**
130  * @tc.number: Want_Param_Wrapper_0500
131  * @tc.name: Box
132  * @tc.desc: Verify the "Box" function.
133  */
134 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0500, Function | MediumTest | Level1)
135 {
136     auto wantParamsPtr = WantParamWrapper::Box(wantParams_);
137 
138     WantParams wantParams;
139     ErrCode result = wantParamsPtr->GetValue(wantParams);
140 
141     EXPECT_EQ(result, ERR_OK);
142 
143     EXPECT_EQ(wantParams_ == wantParams, true);
144 }
145 
146 /**
147  * @tc.number: Want_Param_Wrapper_0600
148  * @tc.name: Box
149  * @tc.desc: Verify the "Box" function with am empty object.
150  */
151 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0600, Function | MediumTest | Level1)
152 {
153     auto wantParamsPtr = WantParamWrapper::Box({});
154 
155     EXPECT_NE(wantParamsPtr, nullptr);
156 
157     WantParams wantParams;
158     ErrCode result = wantParamsPtr->GetValue(wantParams);
159 
160     EXPECT_EQ(result, ERR_OK);
161 
162     // make another empty WantParams
163     WantParams wantParamsEmpty = {};
164 
165     EXPECT_EQ(wantParams == wantParamsEmpty, true);
166 }
167 
168 /**
169  * @tc.number: Want_Param_Wrapper_0700
170  * @tc.name: Unbox
171  * @tc.desc: Verify the "Unbox" function.
172  */
173 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0700, Function | MediumTest | Level1)
174 {
175     auto wantParamsPtr = WantParamWrapper::Box(wantParams_);
176 
177     auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
178 
179     EXPECT_EQ(wantParams_ == wantParams, true);
180 }
181 
182 /**
183  * @tc.number: Want_Param_Wrapper_0800
184  * @tc.name: Unbox
185  * @tc.desc: Verify the "Unbox" function with a nullptr
186  */
187 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0800, Function | MediumTest | Level1)
188 {
189     auto wantParams = WantParamWrapper::Unbox(nullptr);
190 
191     // make another empty WantParams
192     WantParams wantParamsEmpty = {};
193 
194     EXPECT_EQ(wantParams == wantParamsEmpty, true);
195 }
196 
197 /**
198  * @tc.number: Want_Param_Wrapper_0900
199  * @tc.name: ValidateStr
200  * @tc.desc: Verify the "ValidateStr" function.
201  */
202 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_0900, Function | MediumTest | Level1)
203 {
204     bool result = WantParamWrapper::ValidateStr("{");
205 
206     EXPECT_EQ(result, false);
207 }
208 
209 /**
210  * @tc.number: Want_Param_Wrapper_1000
211  * @tc.name: ValidateStr
212  * @tc.desc: Verify the "ValidateStr" function.
213  */
214 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1000, Function | MediumTest | Level1)
215 {
216     bool result = WantParamWrapper::ValidateStr("}");
217 
218     EXPECT_EQ(result, false);
219 }
220 
221 /**
222  * @tc.number: Want_Param_Wrapper_1100
223  * @tc.name: ValidateStr
224  * @tc.desc: Verify the "ValidateStr" function.
225  */
226 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1100, Function | MediumTest | Level1)
227 {
228     bool result = WantParamWrapper::ValidateStr("}{");
229 
230     EXPECT_EQ(result, false);
231 }
232 
233 /**
234  * @tc.number: Want_Param_Wrapper_1200
235  * @tc.name: ValidateStr
236  * @tc.desc: Verify the "ValidateStr" function.
237  */
238 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1200, Function | MediumTest | Level1)
239 {
240     bool result = WantParamWrapper::ValidateStr("{\"\"}");
241 
242     EXPECT_EQ(result, false);
243 }
244 
245 /**
246  * @tc.number: Want_Param_Wrapper_1300
247  * @tc.name: Parse
248  * @tc.desc: Verify the "Parse" function.
249  */
250 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1300, Function | MediumTest | Level1)
251 {
252     auto wantParamsPtr = WantParamWrapper::Parse("");
253 
254     auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
255 
256     // make another empty WantParams
257     WantParams wantParamsEmpty = {};
258 
259     EXPECT_EQ(wantParams == wantParamsEmpty, true);
260 }
261 
262 /**
263  * @tc.number: Want_Param_Wrapper_1400
264  * @tc.name: Parse
265  * @tc.desc: Verify the "Parse" function.
266  */
267 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1400, Function | MediumTest | Level1)
268 {
269     auto wantParamsPtr = WantParamWrapper::Parse("{}");
270 
271     auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
272 
273     // make another empty WantParams
274     WantParams wantParamsEmpty = {};
275 
276     EXPECT_EQ(wantParams == wantParamsEmpty, true);
277 }
278 
279 /**
280  * @tc.number: Want_Param_Wrapper_1500
281  * @tc.name: ToString
282  * @tc.desc: Verify the "ToString" function.
283  */
284 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1500, Function | MediumTest | Level1)
285 {
286     auto wantParamsString = wantParamWrapperPtr_->ToString();
287 
288     EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
289 }
290 
291 /**
292  * @tc.number: Want_Param_Wrapper_1600
293  * @tc.name: ToString
294  * @tc.desc: Verify the "ToString" function.
295  */
296 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1600, Function | MediumTest | Level1)
297 {
298     WantParams wantParams = {};
299     WantParamWrapper wantParamWrapper(wantParams);
300 
301     auto wantParamsString = wantParamWrapper.ToString();
302 
303     EXPECT_EQ(wantParamsString, "{}");
304 }
305 
306 /**
307  * @tc.number: Want_Param_Wrapper_1700
308  * @tc.name: ToString
309  * @tc.desc: Verify the "ToString" function.
310  */
311 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1700, Function | MediumTest | Level1)
312 {
313     WantParams wantParams = {};
314     wantParams.SetParam(STRING_WANT_PARAMS_KEY_02, String::Box(STRING_WANT_PARAMS_VALUE_02));
315     wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, WantParamWrapper::Box(wantParams));
316     WantParamWrapper wantParamWrapper(wantParams);
317 
318     auto wantParamsString = wantParamWrapper.ToString();
319 
320     EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_0201);
321 }
322 
323 /**
324  * @tc.number: Want_Param_Wrapper_1800
325  * @tc.name: from ToString to Parse
326  * @tc.desc: Verify the "from ToString to Parse" function.
327  */
328 HWTEST_F(WantParamWrapperBaseTest, Want_Param_Wrapper_1800, Function | MediumTest | Level1)
329 {
330     auto wantParamsString = wantParamWrapperPtr_->ToString();
331 
332     EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
333 
334     auto wantParamsPtr = WantParamWrapper::Parse(wantParamsString);
335 
336     auto wantParams = WantParamWrapper::Unbox(wantParamsPtr);
337 
338     EXPECT_EQ(wantParams_ == wantParams, true);
339 }
340