1 /*
2 * Copyright (c) 2023 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 "distributed_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 using namespace DistributedSchedule;
27
28 namespace {
29 const std::string STRING_WANT_PARAMS_KEY_01 = "key01";
30 const std::string STRING_WANT_PARAMS_VALUE_01 = "value01";
31 const std::string STRING_WANT_PARAMS_STRING_01 = "{\"key01\":{\"9\":\"value01\"}}";
32
33 const std::string STRING_WANT_PARAMS_KEY_02 = "key02";
34 const std::string STRING_WANT_PARAMS_VALUE_02 = "value02";
35 const std::string STRING_WANT_PARAMS_STRING_0201 =
36 "{\"key01\":{\"101\":{\"key02\":{\"9\":\"value02\"}}},\"key02\":{\"9\":\"value02\"}}";
37 } // namespace
38
39 class DistributedWantParamWrapperBaseTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp() override;
44 void TearDown() override;
45
46 DistributedWantParams wantParams_;
47 std::shared_ptr<DistributedWantParamWrapper> wantParamWrapperPtr_;
48 };
49
SetUpTestCase()50 void DistributedWantParamWrapperBaseTest::SetUpTestCase()
51 {}
52
TearDownTestCase(void)53 void DistributedWantParamWrapperBaseTest::TearDownTestCase(void)
54 {}
55
SetUp(void)56 void DistributedWantParamWrapperBaseTest::SetUp(void)
57 {
58 wantParams_ = {};
59 wantParams_.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
60 wantParamWrapperPtr_ = std::make_shared<DistributedWantParamWrapper>(wantParams_);
61 }
62
TearDown(void)63 void DistributedWantParamWrapperBaseTest::TearDown(void)
64 {}
65
66 /**
67 * @tc.number: Distributed_Want_Param_Wrapper_0100
68 * @tc.name: GetValue
69 * @tc.desc: Verify the "GetValue" function.
70 */
71 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0100, Function | MediumTest | Level3)
72 {
73 ASSERT_NE(wantParamWrapperPtr_, nullptr);
74 DistributedWantParams wantParams;
75 ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
76
77 EXPECT_EQ(result, ERR_OK);
78
79 EXPECT_EQ(wantParams_ == wantParams, true);
80 }
81
82 /**
83 * @tc.number: Distributed_Want_Param_Wrapper_0200
84 * @tc.name: GetValue
85 * @tc.desc: Verify the "GetValue" function.
86 */
87 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0200, Function | MediumTest | Level3)
88 {
89 ASSERT_NE(wantParamWrapperPtr_, nullptr);
90 DistributedWantParams wantParams;
91 ErrCode result = wantParamWrapperPtr_->GetValue(wantParams);
92
93 EXPECT_EQ(result, ERR_OK);
94
95 // make another empty WantParams
96 DistributedWantParams wantParamsEmpty = {};
97
98 EXPECT_EQ(wantParams_ == wantParamsEmpty, false);
99 }
100
101 /**
102 * @tc.number: Distributed_Want_Param_Wrapper_0300
103 * @tc.name: Equals
104 * @tc.desc: Verify the "Equals" function.
105 */
106 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0300, Function | MediumTest | Level3)
107 {
108 ASSERT_NE(wantParamWrapperPtr_, nullptr);
109 DistributedWantParams wantParams;
110 wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, String::Box(STRING_WANT_PARAMS_VALUE_01));
111 DistributedWantParamWrapper wantParamWrapper(wantParams);
112
113 bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
114
115 EXPECT_EQ(result, true);
116 }
117
118 /**
119 * @tc.number: Distributed_Want_Param_Wrapper_0400
120 * @tc.name: Equals
121 * @tc.desc: Verify the "Equals" function.
122 */
123 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0400, Function | MediumTest | Level3)
124 {
125 ASSERT_NE(wantParamWrapperPtr_, nullptr);
126 DistributedWantParams wantParams;
127 DistributedWantParamWrapper wantParamWrapper(wantParams);
128
129 bool result = wantParamWrapperPtr_->Equals(wantParamWrapper);
130
131 EXPECT_EQ(result, false);
132 }
133
134 /**
135 * @tc.number: Distributed_Want_Param_Wrapper_0500
136 * @tc.name: Box
137 * @tc.desc: Verify the "Box" function.
138 */
139 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0500, Function | MediumTest | Level3)
140 {
141 auto wantParamsPtr = DistributedWantParamWrapper::Box(wantParams_);
142
143 DistributedWantParams wantParams;
144 ErrCode result = wantParamsPtr->GetValue(wantParams);
145
146 EXPECT_EQ(result, ERR_OK);
147
148 EXPECT_EQ(wantParams_ == wantParams, true);
149 }
150
151 /**
152 * @tc.number: Distributed_Want_Param_Wrapper_0600
153 * @tc.name: Box
154 * @tc.desc: Verify the "Box" function with am empty object.
155 */
156 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0600, Function | MediumTest | Level3)
157 {
158 auto wantParamsPtr = DistributedWantParamWrapper::Box({});
159
160 EXPECT_NE(wantParamsPtr, nullptr);
161
162 DistributedWantParams wantParams;
163 ErrCode result = wantParamsPtr->GetValue(wantParams);
164
165 EXPECT_EQ(result, ERR_OK);
166
167 // make another empty WantParams
168 DistributedWantParams wantParamsEmpty = {};
169
170 EXPECT_EQ(wantParams == wantParamsEmpty, true);
171 }
172
173 /**
174 * @tc.number: Distributed_Want_Param_Wrapper_0700
175 * @tc.name: Unbox
176 * @tc.desc: Verify the "Unbox" function.
177 */
178 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0700, Function | MediumTest | Level3)
179 {
180 auto wantParamsPtr = DistributedWantParamWrapper::Box(wantParams_);
181
182 auto wantParams = DistributedWantParamWrapper::Unbox(wantParamsPtr);
183
184 EXPECT_EQ(wantParams_ == wantParams, true);
185 }
186
187 /**
188 * @tc.number: Distributed_Want_Param_Wrapper_0800
189 * @tc.name: Unbox
190 * @tc.desc: Verify the "Unbox" function with a nullptr
191 */
192 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0800, Function | MediumTest | Level3)
193 {
194 auto wantParams = DistributedWantParamWrapper::Unbox(nullptr);
195
196 // make another empty WantParams
197 DistributedWantParams wantParamsEmpty = {};
198
199 EXPECT_EQ(wantParams == wantParamsEmpty, true);
200 }
201
202 /**
203 * @tc.number: Distributed_Want_Param_Wrapper_0900
204 * @tc.name: ValidateStr
205 * @tc.desc: Verify the "ValidateStr" function.
206 */
207 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_0900, Function | MediumTest | Level3)
208 {
209 bool result = DistributedWantParamWrapper::ValidateStr("{");
210
211 EXPECT_EQ(result, false);
212 }
213
214 /**
215 * @tc.number: Distributed_Want_Param_Wrapper_1000
216 * @tc.name: ValidateStr
217 * @tc.desc: Verify the "ValidateStr" function.
218 */
219 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1000, Function | MediumTest | Level3)
220 {
221 bool result = DistributedWantParamWrapper::ValidateStr("}");
222
223 EXPECT_EQ(result, false);
224 }
225
226 /**
227 * @tc.number: Distributed_Want_Param_Wrapper_1100
228 * @tc.name: ValidateStr
229 * @tc.desc: Verify the "ValidateStr" function.
230 */
231 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1100, Function | MediumTest | Level3)
232 {
233 bool result = DistributedWantParamWrapper::ValidateStr("}{");
234
235 EXPECT_EQ(result, false);
236 }
237
238 /**
239 * @tc.number: Distributed_Want_Param_Wrapper_1200
240 * @tc.name: ValidateStr
241 * @tc.desc: Verify the "ValidateStr" function.
242 */
243 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1200, Function | MediumTest | Level3)
244 {
245 bool result = DistributedWantParamWrapper::ValidateStr("{\"\"}");
246
247 EXPECT_EQ(result, false);
248 }
249
250 /**
251 * @tc.number: Distributed_Want_Param_Wrapper_1300
252 * @tc.name: Parse
253 * @tc.desc: Verify the "Parse" function.
254 */
255 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1300, Function | MediumTest | Level3)
256 {
257 auto wantParamsPtr = DistributedWantParamWrapper::Parse("");
258
259 auto wantParams = DistributedWantParamWrapper::Unbox(wantParamsPtr);
260
261 // make another empty WantParams
262 DistributedWantParams wantParamsEmpty = {};
263
264 EXPECT_EQ(wantParams == wantParamsEmpty, true);
265 }
266
267 /**
268 * @tc.number: Distributed_Want_Param_Wrapper_1400
269 * @tc.name: Parse
270 * @tc.desc: Verify the "Parse" function.
271 */
272 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1400, Function | MediumTest | Level3)
273 {
274 auto wantParamsPtr = DistributedWantParamWrapper::Parse("{}");
275
276 auto wantParams = DistributedWantParamWrapper::Unbox(wantParamsPtr);
277
278 // make another empty WantParams
279 DistributedWantParams wantParamsEmpty = {};
280
281 EXPECT_EQ(wantParams == wantParamsEmpty, true);
282 }
283
284 /**
285 * @tc.number: Distributed_Want_Param_Wrapper_1500
286 * @tc.name: ToString
287 * @tc.desc: Verify the "ToString" function.
288 */
289 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1500, Function | MediumTest | Level3)
290 {
291 ASSERT_NE(wantParamWrapperPtr_, nullptr);
292 auto wantParamsString = wantParamWrapperPtr_->ToString();
293
294 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
295 }
296
297 /**
298 * @tc.number: Distributed_Want_Param_Wrapper_1600
299 * @tc.name: ToString
300 * @tc.desc: Verify the "ToString" function.
301 */
302 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1600, Function | MediumTest | Level3)
303 {
304 DistributedWantParams wantParams = {};
305 DistributedWantParamWrapper wantParamWrapper(wantParams);
306
307 auto wantParamsString = wantParamWrapper.ToString();
308
309 EXPECT_EQ(wantParamsString, "{}");
310 }
311
312 /**
313 * @tc.number: Distributed_Want_Param_Wrapper_1700
314 * @tc.name: ToString
315 * @tc.desc: Verify the "ToString" function.
316 */
317 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1700, Function | MediumTest | Level3)
318 {
319 DistributedWantParams wantParams = {};
320 wantParams.SetParam(STRING_WANT_PARAMS_KEY_02, String::Box(STRING_WANT_PARAMS_VALUE_02));
321 wantParams.SetParam(STRING_WANT_PARAMS_KEY_01, DistributedWantParamWrapper::Box(wantParams));
322 DistributedWantParamWrapper wantParamWrapper(wantParams);
323
324 auto wantParamsString = wantParamWrapper.ToString();
325
326 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_0201);
327 }
328
329 /**
330 * @tc.number: Distributed_Want_Param_Wrapper_1800
331 * @tc.name: from ToString to Parse
332 * @tc.desc: Verify the "from ToString to Parse" function.
333 */
334 HWTEST_F(DistributedWantParamWrapperBaseTest, Distributed_Want_Param_Wrapper_1800, Function | MediumTest | Level3)
335 {
336 ASSERT_NE(wantParamWrapperPtr_, nullptr);
337 auto wantParamsString = wantParamWrapperPtr_->ToString();
338
339 EXPECT_EQ(wantParamsString, STRING_WANT_PARAMS_STRING_01);
340
341 auto wantParamsPtr = DistributedWantParamWrapper::Parse(wantParamsString);
342
343 auto wantParams = DistributedWantParamWrapper::Unbox(wantParamsPtr);
344
345 EXPECT_EQ(wantParams_ == wantParams, true);
346 }
347