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