1 /*
2 * Copyright (c) 2025 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 "dsched_collab_event_test.h"
17
18 #include "distributed_sched_utils.h"
19 #include "dms_constant.h"
20 #include "dsched_collab_state.h"
21 #include "dtbschedmgr_log.h"
22 #include "test_log.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedSchedule {
29 const char* EXTRO_INFO_JSON_KEY_ACCESS_TOKEN = "accessTokenID";
30 const char* DMS_VERSION_ID = "dmsVersion";
31
SetUpTestCase()32 void CollabEventTest::SetUpTestCase()
33 {
34 DTEST_LOG << "CollabEventTest::SetUpTestCase" << std::endl;
35 }
36
TearDownTestCase()37 void CollabEventTest::TearDownTestCase()
38 {
39 DTEST_LOG << "CollabEventTest::TearDownTestCase" << std::endl;
40 }
41
TearDown()42 void CollabEventTest::TearDown()
43 {
44 DTEST_LOG << "CollabEventTest::TearDown" << std::endl;
45 }
46
SetUp()47 void CollabEventTest::SetUp()
48 {
49 DTEST_LOG << "CollabEventTest::SetUp" << std::endl;
50 }
51
52 /**
53 * @tc.name: BaseCmd_Test_001
54 * @tc.desc: call BaseCmd
55 * @tc.type: FUNC
56 * @tc.require: I6SJQ6
57 */
58 HWTEST_F(CollabEventTest, BaseCmd_Test_001, TestSize.Level3)
59 {
60 DTEST_LOG << "BaseCmd BaseCmd_Test_001 begin" << std::endl;
61 BaseCmd cmd;
62 cmd.collabVersion_ = 0;
63 cmd.dmsVersion_ = 0;
64 cmd.command_ = 0;
65 cmd.srcCollabSessionId_ = 0;
66 cmd.appVersion_ = 0;
67 cmd.collabToken_ = "collabToken_";
68 cmd.srcDeviceId_ = "srcDeviceId_";
69 cmd.srcBundleName_ = "srcBundleName_";
70 cmd.srcAbilityName_ = "srcAbilityName_";
71 cmd.srcModuleName_ = "srcModuleName_";
72 cmd.srcServerId_ = "srcServerId_";
73 cmd.sinkDeviceId_ = "sinkDeviceId_";
74 cmd.sinkBundleName_ = "sinkBundleName_";
75 cmd.sinkAbilityName_ = "sinkAbilityName_";
76 cmd.sinkModuleName_ = "sinkModuleName_";
77 cmd.sinkServerId_ = "sinkServerId_";
78
79 std::string jsonStr;
80 auto ret = cmd.Marshal(jsonStr);
81 EXPECT_EQ(ret, ERR_OK);
82
83 ret = cmd.Unmarshal(jsonStr);
84 EXPECT_EQ(ret, ERR_OK);
85 DTEST_LOG << "BaseCmd BaseCmd_Test_001 end" << std::endl;
86 }
87
88 /**
89 * @tc.name: BaseCmd_Unmarshal_Test_001
90 * @tc.desc: call Unmarshal
91 * @tc.type: FUNC
92 * @tc.require: I6SJQ6
93 */
94 HWTEST_F(CollabEventTest, BaseCmd_Unmarshal_Test_001, TestSize.Level3)
95 {
96 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_001 begin" << std::endl;
97 std::string jsonStr = "test";
98 BaseCmd cmd;
99 auto ret = cmd.Unmarshal(jsonStr);
100 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
101
102 cJSON *rootValue = cJSON_CreateObject();
103 ASSERT_NE(rootValue, nullptr);
104 cJSON_AddNumberToObject(rootValue, "Command", 0);
105 cJSON_AddNumberToObject(rootValue, "CollabVersion", 0);
106 cJSON_AddNumberToObject(rootValue, "DmsVersion", 0);
107
108 char *data = cJSON_Print(rootValue);
109 ASSERT_NE(data, nullptr);
110 jsonStr = std::string(data);
111 ret = cmd.Unmarshal(jsonStr);
112 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
113 cJSON_free(data);
114
115 cJSON_AddStringToObject(rootValue, "CollabSessionId", "");
116 data = cJSON_Print(rootValue);
117 ASSERT_NE(data, nullptr);
118 jsonStr = std::string(data);
119 ret = cmd.Unmarshal(jsonStr);
120 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
121 cJSON_free(data);
122
123 cJSON_ReplaceItemInObject(rootValue, "CollabSessionId", cJSON_CreateString("test"));
124 data = cJSON_Print(rootValue);
125 ASSERT_NE(data, nullptr);
126 jsonStr = std::string(data);
127 ret = cmd.Unmarshal(jsonStr);
128 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
129 cJSON_Delete(rootValue);
130 cJSON_free(data);
131 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_001 end" << std::endl;
132 }
133
134 /**
135 * @tc.name: BaseCmd_Unmarshal_Test_002
136 * @tc.desc: call Unmarshal
137 * @tc.type: FUNC
138 * @tc.require: I6SJQ6
139 */
140 HWTEST_F(CollabEventTest, BaseCmd_Unmarshal_Test_002, TestSize.Level3)
141 {
142 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_002 begin" << std::endl;
143 std::string jsonStr;
144 cJSON *rootValue = cJSON_CreateObject();
145 ASSERT_NE(rootValue, nullptr);
146 cJSON_AddNumberToObject(rootValue, "Command", 0);
147 cJSON_AddNumberToObject(rootValue, "CollabVersion", 0);
148 cJSON_AddNumberToObject(rootValue, "DmsVersion", 0);
149 cJSON_AddNumberToObject(rootValue, "CollabSessionId", 0);
150
151 char *data = cJSON_Print(rootValue);
152 ASSERT_NE(data, nullptr);
153 jsonStr = std::string(data);
154 BaseCmd cmd;
155 auto ret = cmd.Unmarshal(jsonStr);
156 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
157 cJSON_free(data);
158
159 cJSON_AddNumberToObject(rootValue, "CollabToken", 0);
160 data = cJSON_Print(rootValue);
161 ASSERT_NE(data, nullptr);
162 jsonStr = std::string(data);
163 ret = cmd.Unmarshal(jsonStr);
164 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
165 cJSON_Delete(rootValue);
166 cJSON_free(data);
167 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_002 end" << std::endl;
168 }
169
170 /**
171 * @tc.name: BaseCmd_Unmarshal_Test_003
172 * @tc.desc: call Unmarshal
173 * @tc.type: FUNC
174 * @tc.require: I6SJQ6
175 */
176 HWTEST_F(CollabEventTest, BaseCmd_Unmarshal_Test_003, TestSize.Level3)
177 {
178 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_003 begin" << std::endl;
179 std::string jsonStr;
180 cJSON *rootValue = cJSON_CreateObject();
181 ASSERT_NE(rootValue, nullptr);
182 cJSON_AddNumberToObject(rootValue, "Command", 0);
183 cJSON_AddNumberToObject(rootValue, "CollabVersion", 0);
184 cJSON_AddNumberToObject(rootValue, "DmsVersion", 0);
185 cJSON_AddNumberToObject(rootValue, "CollabSessionId", 0);
186 cJSON_AddStringToObject(rootValue, "CollabToken", "collabToken");
187 cJSON_AddStringToObject(rootValue, "SrcDeviceId", "srcDeviceId");
188 cJSON_AddStringToObject(rootValue, "SrcBundleName", "srcBundleName");
189 cJSON_AddStringToObject(rootValue, "SrcAbilityName", "srcAbilityName");
190 cJSON_AddStringToObject(rootValue, "SrcModuleName", "srcModuleName");
191 cJSON_AddStringToObject(rootValue, "SrcServiceId", "srcServerId");
192 cJSON_AddStringToObject(rootValue, "SinkDeviceId", "sinkDeviceId");
193 cJSON_AddStringToObject(rootValue, "SinkBundleName", "sinkBundleName");
194 cJSON_AddStringToObject(rootValue, "SinkAbilityName", "sinkAbilityName");
195 cJSON_AddStringToObject(rootValue, "SinkModuleName", "sinkModuleName");
196 cJSON_AddStringToObject(rootValue, "SinkServiceId", "sinkServerId");
197
198 char *data = cJSON_Print(rootValue);
199 ASSERT_NE(data, nullptr);
200 jsonStr = std::string(data);
201 BaseCmd cmd;
202 auto ret = cmd.Unmarshal(jsonStr);
203 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
204 cJSON_free(data);
205
206 cJSON_AddStringToObject(rootValue, "NeedSendBigData", "test");
207 data = cJSON_Print(rootValue);
208 ASSERT_NE(data, nullptr);
209 jsonStr = std::string(data);
210 ret = cmd.Unmarshal(jsonStr);
211 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
212 cJSON_Delete(rootValue);
213 cJSON_free(data);
214 DTEST_LOG << "BaseCmd BaseCmd_Unmarshal_Test_003 end" << std::endl;
215 }
216
217 /**
218 * @tc.name: SinkStartCmd_Test_001
219 * @tc.desc: call SinkStartCmd
220 * @tc.type: FUNC
221 * @tc.require: I6SJQ6
222 */
223 HWTEST_F(CollabEventTest, SinkStartCmd_Test_001, TestSize.Level3)
224 {
225 DTEST_LOG << "SinkStartCmd SinkStartCmd_Test_001 begin" << std::endl;
226 SinkStartCmd cmd;
227 cmd.collabVersion_ = 0;
228 cmd.dmsVersion_ = 0;
229 cmd.command_ = 0;
230 cmd.srcCollabSessionId_ = 0;
231 cmd.appVersion_ = 0;
232 cmd.collabToken_ = "collabToken_";
233 cmd.srcDeviceId_ = "srcDeviceId_";
234 cmd.srcBundleName_ = "srcBundleName_";
235 cmd.srcAbilityName_ = "srcAbilityName_";
236 cmd.srcModuleName_ = "srcModuleName_";
237 cmd.srcServerId_ = "srcServerId_";
238 cmd.sinkDeviceId_ = "sinkDeviceId_";
239 cmd.sinkBundleName_ = "sinkBundleName_";
240 cmd.sinkAbilityName_ = "sinkAbilityName_";
241 cmd.sinkModuleName_ = "sinkModuleName_";
242 cmd.sinkServerId_ = "sinkServerId_";
243
244 CallerInfo callerInfo;
245 cmd.callerInfo_ = callerInfo;
246 IDistributedSched::AccountInfo accountInfo;
247 cmd.accountInfo_ = accountInfo;
248 AAFwk::WantParams params;
249 cmd.startParams_ = params;
250 cmd.messageParams_ = params;
251
252 std::string jsonStr;
253 auto ret = cmd.Marshal(jsonStr);
254 EXPECT_EQ(ret, ERR_OK);
255
256 ret = cmd.Unmarshal(jsonStr);
257 EXPECT_EQ(ret, ERR_OK);
258 DTEST_LOG << "SinkStartCmd SinkStartCmd_Test_001 end" << std::endl;
259 }
260
261 /**
262 * @tc.name: SinkStartCmd_Unmarshal_Test_001
263 * @tc.desc: call Unmarshal
264 * @tc.type: FUNC
265 * @tc.require: I6SJQ6
266 */
267 HWTEST_F(CollabEventTest, SinkStartCmd_Unmarshal_Test_001, TestSize.Level3)
268 {
269 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_001 begin" << std::endl;
270 std::string jsonStr = "test";
271 SinkStartCmd cmd;
272 auto ret = cmd.Unmarshal(jsonStr);
273 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
274 cJSON *rootValue = cJSON_CreateObject();
275 ASSERT_NE(rootValue, nullptr);
276 cJSON_AddNumberToObject(rootValue, "AppVersion", 0);
277 char *data = cJSON_Print(rootValue);
278 ASSERT_NE(data, nullptr);
279 jsonStr = std::string(data);
280 ret = cmd.Unmarshal(jsonStr);
281 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
282 cJSON_free(data);
283
284 cJSON_AddNumberToObject(rootValue, "BaseCmd", 0);
285 data = cJSON_Print(rootValue);
286 ASSERT_NE(data, nullptr);
287 jsonStr = std::string(data);
288 ret = cmd.Unmarshal(jsonStr);
289 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
290 cJSON_free(data);
291
292 cJSON_DeleteItemFromObject(rootValue, "BaseCmd");
293 cJSON_AddStringToObject(rootValue, "BaseCmd", "test");
294 data = cJSON_Print(rootValue);
295 ASSERT_NE(data, nullptr);
296 jsonStr = std::string(data);
297 ret = cmd.Unmarshal(jsonStr);
298 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
299 cJSON_Delete(rootValue);
300 cJSON_free(data);
301 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_001 end" << std::endl;
302 }
303
304 /**
305 * @tc.name: SinkStartCmd_Unmarshal_Test_002
306 * @tc.desc: call Unmarshal
307 * @tc.type: FUNC
308 * @tc.require: I6SJQ6
309 */
310 HWTEST_F(CollabEventTest, SinkStartCmd_Unmarshal_Test_002, TestSize.Level3)
311 {
312 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 begin" << std::endl;
313 std::string jsonStr;
314 cJSON *rootValue = cJSON_CreateObject();
315 ASSERT_NE(rootValue, nullptr);
316
317 std::string baseJsonStr;
318 BaseCmd cmd;
319 if (cmd.Marshal(baseJsonStr) != ERR_OK) {
320 cJSON_Delete(rootValue);
321 ASSERT_TRUE(false);
322 }
323
324 cJSON_AddStringToObject(rootValue, "BaseCmd", baseJsonStr.c_str());
325
326 jsonStr = std::string(cJSON_Print(rootValue));
327 SinkStartCmd sinkCmd;
328 auto ret = sinkCmd.Unmarshal(jsonStr);
329 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
330
331 cJSON_AddStringToObject(rootValue, "AppVersion", "test");
332 char *data = cJSON_Print(rootValue);
333 ASSERT_NE(data, nullptr);
334 jsonStr = std::string(data);
335 ret = sinkCmd.Unmarshal(jsonStr);
336 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
337 cJSON_free(data);
338 cJSON_Delete(rootValue);
339 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 end" << std::endl;
340 }
341
342 /**
343 * @tc.name: SinkStartCmd_UnmarshalOptParams_Test_001
344 * @tc.desc: call UnmarshalOptParams
345 * @tc.type: FUNC
346 * @tc.require: I6SJQ6
347 */
348 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalOptParams_Test_001, TestSize.Level3)
349 {
350 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 begin" << std::endl;
351 std::string jsonStr;
352 cJSON *rootValue = cJSON_CreateObject();
353 ASSERT_NE(rootValue, nullptr);
354 SinkStartCmd sinkCmd;
355 auto ret = sinkCmd.UnmarshalOptParams(rootValue);
356 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
357
358 cJSON_AddNumberToObject(rootValue, "StartParams", 0);
359 ret = sinkCmd.UnmarshalOptParams(rootValue);
360 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
361
362 cJSON_DeleteItemFromObject(rootValue, "StartParams");
363 cJSON_AddStringToObject(rootValue, "StartParams", "test");
364 ret = sinkCmd.UnmarshalOptParams(rootValue);
365 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
366 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 end" << std::endl;
367 }
368
369 /**
370 * @tc.name: SinkStartCmd_UnmarshalOptParams_Test_002
371 * @tc.desc: call UnmarshalOptParams
372 * @tc.type: FUNC
373 * @tc.require: I6SJQ6
374 */
375 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalOptParams_Test_002, TestSize.Level3)
376 {
377 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 begin" << std::endl;
378 std::string jsonStr;
379 cJSON *rootValue = cJSON_CreateObject();
380 ASSERT_NE(rootValue, nullptr);
381 SinkStartCmd sinkCmd;
382 Parcel parcel;
383 if (!sinkCmd.startParams_.Marshalling(parcel)) {
384 cJSON_Delete(rootValue);
385 ASSERT_TRUE(false);
386 }
387 std::string startParamsStr = ParcelToBase64Str(parcel);
388 cJSON_AddStringToObject(rootValue, "StartParams", startParamsStr.c_str());
389 if (!sinkCmd.messageParams_.Marshalling(parcel)) {
390 cJSON_Delete(rootValue);
391 ASSERT_TRUE(false);
392 }
393
394 auto ret = sinkCmd.UnmarshalOptParams(rootValue);
395 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
396
397 cJSON_AddNumberToObject(rootValue, "WantParams", 0);
398 ret = sinkCmd.UnmarshalOptParams(rootValue);
399 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
400
401 cJSON_DeleteItemFromObject(rootValue, "WantParams");
402 cJSON_AddStringToObject(rootValue, "WantParams", "test");
403 ret = sinkCmd.UnmarshalOptParams(rootValue);
404 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
405 DTEST_LOG << "SinkStartCmd_Unmarshal_Test_002 end" << std::endl;
406 }
407
408 /**
409 * @tc.name: SinkStartCmd_UnmarshalPartParcel_Test_002
410 * @tc.desc: call UnmarshalPartParcel
411 * @tc.type: FUNC
412 * @tc.require: I6SJQ6
413 */
414 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalPartParcel_Test_001, TestSize.Level3)
415 {
416 DTEST_LOG << "SinkStartCmd_UnmarshalPartParcel_Test_001 begin" << std::endl;
417 std::string jsonStr;
418 cJSON *rootValue = cJSON_CreateObject();
419 ASSERT_NE(rootValue, nullptr);
420 SinkStartCmd sinkCmd;
421 auto ret = sinkCmd.UnmarshalPartParcel(rootValue);
422 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
423
424 Parcel parcel;
425 if (!sinkCmd.startParams_.Marshalling(parcel)) {
426 cJSON_Delete(rootValue);
427 ASSERT_TRUE(false);
428 }
429 std::string startParamsStr = ParcelToBase64Str(parcel);
430 cJSON_AddStringToObject(rootValue, "StartParams", startParamsStr.c_str());
431 if (!sinkCmd.messageParams_.Marshalling(parcel)) {
432 cJSON_Delete(rootValue);
433 ASSERT_TRUE(false);
434 }
435
436 std::string wantParamsStr = ParcelToBase64Str(parcel);
437 cJSON_AddStringToObject(rootValue, "WantParams", wantParamsStr.c_str());
438 std::string callerInfoStr;
439 if (sinkCmd.MarshalCallerInfo(callerInfoStr) != ERR_OK) {
440 cJSON_Delete(rootValue);
441 ASSERT_TRUE(false);
442 }
443
444 ret = sinkCmd.UnmarshalPartParcel(rootValue);
445 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
446
447 cJSON_AddNumberToObject(rootValue, "CallerInfo", 0);
448 ret = sinkCmd.UnmarshalPartParcel(rootValue);
449 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
450
451 cJSON_DeleteItemFromObject(rootValue, "CallerInfo");
452 cJSON_AddStringToObject(rootValue, "CallerInfo", "test");
453 ret = sinkCmd.UnmarshalPartParcel(rootValue);
454 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
455 DTEST_LOG << "SinkStartCmd_UnmarshalPartParcel_Test_001 end" << std::endl;
456 }
457
458 /**
459 * @tc.name: SinkStartCmd_UnmarshalPartParcel_Test_002
460 * @tc.desc: call UnmarshalPartParcel
461 * @tc.type: FUNC
462 * @tc.require: I6SJQ6
463 */
464 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalPartParcel_Test_002, TestSize.Level3)
465 {
466 DTEST_LOG << "SinkStartCmd_UnmarshalPartParcel_Test_002 begin" << std::endl;
467 std::string jsonStr;
468 cJSON *rootValue = cJSON_CreateObject();
469 ASSERT_NE(rootValue, nullptr);
470 SinkStartCmd sinkCmd;
471 Parcel parcel;
472 if (!sinkCmd.startParams_.Marshalling(parcel)) {
473 cJSON_Delete(rootValue);
474 ASSERT_TRUE(false);
475 }
476 std::string startParamsStr = ParcelToBase64Str(parcel);
477 cJSON_AddStringToObject(rootValue, "StartParams", startParamsStr.c_str());
478 if (!sinkCmd.messageParams_.Marshalling(parcel)) {
479 cJSON_Delete(rootValue);
480 ASSERT_TRUE(false);
481 }
482
483 std::string wantParamsStr = ParcelToBase64Str(parcel);
484 cJSON_AddStringToObject(rootValue, "WantParams", wantParamsStr.c_str());
485 std::string callerInfoStr;
486 if (sinkCmd.MarshalCallerInfo(callerInfoStr) != ERR_OK) {
487 cJSON_Delete(rootValue);
488 ASSERT_TRUE(false);
489 }
490
491 cJSON_AddStringToObject(rootValue, "CallerInfo", callerInfoStr.c_str());
492 auto ret = sinkCmd.UnmarshalPartParcel(rootValue);
493 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
494
495 cJSON_AddNumberToObject(rootValue, "AccountInfo", 0);
496 ret = sinkCmd.UnmarshalPartParcel(rootValue);
497 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
498
499 cJSON_DeleteItemFromObject(rootValue, "AccountInfo");
500 cJSON_AddStringToObject(rootValue, "AccountInfo", "test");
501 ret = sinkCmd.UnmarshalPartParcel(rootValue);
502 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
503 DTEST_LOG << "SinkStartCmd_UnmarshalPartParcel_Test_002 end" << std::endl;
504 }
505
506 /**
507 * @tc.name: SinkStartCmd_UnmarshalCallerInfo_Test_001
508 * @tc.desc: call UnmarshalCallerInfo
509 * @tc.type: FUNC
510 * @tc.require: I6SJQ6
511 */
512 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfo_Test_001, TestSize.Level3)
513 {
514 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_001 begin" << std::endl;
515 std::string jsonStr = "test";
516 SinkStartCmd cmd;
517 auto ret = cmd.UnmarshalCallerInfo(jsonStr);
518 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
519
520 cJSON *rootValue = cJSON_CreateObject();
521 ASSERT_NE(rootValue, nullptr);
522 cJSON_AddNumberToObject(rootValue, "Uid", 0);
523 cJSON_AddNumberToObject(rootValue, "Pid", 0);
524
525 char *data = cJSON_Print(rootValue);
526 ASSERT_NE(data, nullptr);
527 jsonStr = std::string(data);
528 ret = cmd.UnmarshalCallerInfo(jsonStr);
529 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
530 cJSON_free(data);
531
532 cJSON_AddNumberToObject(rootValue, "SourceDeviceId", 0);
533 data = cJSON_Print(rootValue);
534 ASSERT_NE(data, nullptr);
535 jsonStr = std::string(data);
536 ret = cmd.UnmarshalCallerInfo(jsonStr);
537 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
538 cJSON_free(data);
539
540 cJSON_DeleteItemFromObject(rootValue, "SourceDeviceId");
541 cJSON_AddStringToObject(rootValue, "SourceDeviceId", "");
542 data = cJSON_Print(rootValue);
543 ASSERT_NE(data, nullptr);
544 jsonStr = std::string(data);
545 ret = cmd.UnmarshalCallerInfo(jsonStr);
546 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
547 cJSON_Delete(rootValue);
548 cJSON_free(data);
549 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_001 end" << std::endl;
550 }
551
552 /**
553 * @tc.name: SinkStartCmd_UnmarshalCallerInfo_Test_002
554 * @tc.desc: call UnmarshalCallerInfo
555 * @tc.type: FUNC
556 * @tc.require: I6SJQ6
557 */
558 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfo_Test_002, TestSize.Level3)
559 {
560 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_002 begin" << std::endl;
561 cJSON *rootValue = cJSON_CreateObject();
562 ASSERT_NE(rootValue, nullptr);
563 cJSON_AddStringToObject(rootValue, "SourceDeviceId", "SourceDeviceId");
564 cJSON_AddNumberToObject(rootValue, "Duid", 0);
565 cJSON_AddStringToObject(rootValue, "CallerAppId", "CallerAppId");
566
567 char *data = cJSON_Print(rootValue);
568 if (data == nullptr) {
569 cJSON_Delete(rootValue);
570 ASSERT_TRUE(false);
571 }
572 std::string jsonStr = std::string(data);
573 SinkStartCmd cmd;
574 auto ret = cmd.UnmarshalCallerInfo(jsonStr);
575 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
576 cJSON_free(data);
577
578 cJSON_AddStringToObject(rootValue, "Uid", "test");
579 data = cJSON_Print(rootValue);
580 if (data == nullptr) {
581 cJSON_Delete(rootValue);
582 ASSERT_TRUE(false);
583 }
584 jsonStr = std::string(data);
585 ret = cmd.UnmarshalCallerInfo(jsonStr);
586 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
587 cJSON_free(data);
588
589 cJSON_DeleteItemFromObject(rootValue, "Uid");
590 cJSON_AddNumberToObject(rootValue, "Uid", 0);
591 cJSON_AddNumberToObject(rootValue, "Pid", 0);
592 cJSON_AddNumberToObject(rootValue, "CallerType", 0);
593 data = cJSON_Print(rootValue);
594 if (data == nullptr) {
595 cJSON_Delete(rootValue);
596 ASSERT_TRUE(false);
597 }
598 jsonStr = std::string(data);
599 ret = cmd.UnmarshalCallerInfo(jsonStr);
600 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
601 cJSON_Delete(rootValue);
602 cJSON_free(data);
603 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_002 end" << std::endl;
604 }
605
606 /**
607 * @tc.name: SinkStartCmd_UnmarshalCallerInfo_Test_003
608 * @tc.desc: call UnmarshalCallerInfo
609 * @tc.type: FUNC
610 * @tc.require: I6SJQ6
611 */
612 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfo_Test_003, TestSize.Level3)
613 {
614 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_003 begin" << std::endl;
615 cJSON *rootValue = cJSON_CreateObject();
616 ASSERT_NE(rootValue, nullptr);
617 cJSON_AddStringToObject(rootValue, "SourceDeviceId", "SourceDeviceId");
618 cJSON_AddNumberToObject(rootValue, "Duid", 0);
619 cJSON_AddStringToObject(rootValue, "CallerAppId", "CallerAppId");
620
621 char *data = cJSON_Print(rootValue);
622 ASSERT_NE(data, nullptr);
623 std::string jsonStr = std::string(data);
624 SinkStartCmd cmd;
625 auto ret = cmd.UnmarshalCallerInfo(jsonStr);
626 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
627 cJSON_free(data);
628
629 cJSON_AddStringToObject(rootValue, "Uid", "test");
630 data = cJSON_Print(rootValue);
631 if (data == nullptr) {
632 cJSON_Delete(rootValue);
633 ASSERT_TRUE(false);
634 }
635 jsonStr = std::string(data);
636 ret = cmd.UnmarshalCallerInfo(jsonStr);
637 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
638 cJSON_free(data);
639
640 cJSON_DeleteItemFromObject(rootValue, "Uid");
641 cJSON_AddNumberToObject(rootValue, "Uid", 0);
642 cJSON_AddNumberToObject(rootValue, "Pid", 0);
643 cJSON_AddNumberToObject(rootValue, "CallerType", 0);
644 data = cJSON_Print(rootValue);
645 if (data == nullptr) {
646 cJSON_Delete(rootValue);
647 ASSERT_TRUE(false);
648 }
649 jsonStr = std::string(data);
650 ret = cmd.UnmarshalCallerInfo(jsonStr);
651 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
652 cJSON_Delete(rootValue);
653 cJSON_free(data);
654 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfo_Test_003 end" << std::endl;
655 }
656
657 /**
658 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_001
659 * @tc.desc: call UnmarshalAccountInfo
660 * @tc.type: FUNC
661 * @tc.require: I6SJQ6
662 */
663 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_001, TestSize.Level3)
664 {
665 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_001 begin" << std::endl;
666 std::string jsonStr = "test";
667 SinkStartCmd cmd;
668 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
669 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
670
671 cJSON *rootValue = cJSON_CreateObject();
672 ASSERT_NE(rootValue, nullptr);
673
674 char *data = cJSON_Print(rootValue);
675 if (data == nullptr) {
676 cJSON_Delete(rootValue);
677 ASSERT_TRUE(false);
678 }
679 jsonStr = std::string(data);
680 ret = cmd.UnmarshalAccountInfo(jsonStr);
681 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
682 cJSON_free(data);
683
684 cJSON_AddStringToObject(rootValue, "AccountType", "test");
685 data = cJSON_Print(rootValue);
686 if (data == nullptr) {
687 cJSON_Delete(rootValue);
688 ASSERT_TRUE(false);
689 }
690 jsonStr = std::string(data);
691 ret = cmd.UnmarshalCallerInfo(jsonStr);
692 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
693 cJSON_free(data);
694 cJSON_Delete(rootValue);
695 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_001 end" << std::endl;
696 }
697
698 /**
699 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_002
700 * @tc.desc: call UnmarshalAccountInfo
701 * @tc.type: FUNC
702 * @tc.require: I6SJQ6
703 */
704 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_002, TestSize.Level3)
705 {
706 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_002 begin" << std::endl;
707 cJSON *rootValue = cJSON_CreateObject();
708 ASSERT_NE(rootValue, nullptr);
709 cJSON_AddNumberToObject(rootValue, "AccountType", 0);
710 char *data = cJSON_Print(rootValue);
711 if (data == nullptr) {
712 cJSON_Delete(rootValue);
713 ASSERT_TRUE(false);
714 }
715 auto jsonStr = std::string(data);
716 SinkStartCmd cmd;
717 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
718 EXPECT_EQ(ret, ERR_OK);
719 cJSON_free(data);
720
721 cJSON_AddNumberToObject(rootValue, Constants::EXTRO_INFO_JSON_KEY_ACCOUNT_ID.c_str(), 0);
722 data = cJSON_Print(rootValue);
723 if (data == nullptr) {
724 cJSON_Delete(rootValue);
725 ASSERT_TRUE(false);
726 }
727 jsonStr = std::string(data);
728 ret = cmd.UnmarshalAccountInfo(jsonStr);
729 EXPECT_EQ(ret, ERR_OK);
730 cJSON_free(data);
731 cJSON_Delete(rootValue);
732 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_002 end" << std::endl;
733 }
734
735 /**
736 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_003
737 * @tc.desc: call UnmarshalAccountInfo
738 * @tc.type: FUNC
739 * @tc.require: I6SJQ6
740 */
741 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_003, TestSize.Level3)
742 {
743 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_003 begin" << std::endl;
744 cJSON *rootValue = cJSON_CreateObject();
745 ASSERT_NE(rootValue, nullptr);
746 cJSON_AddNumberToObject(rootValue, "AccountType", 0);
747 cJSON_AddStringToObject(rootValue, Constants::EXTRO_INFO_JSON_KEY_ACCOUNT_ID.c_str(),
748 "test");
749 char *data = cJSON_Print(rootValue);
750 if (data == nullptr) {
751 cJSON_Delete(rootValue);
752 ASSERT_TRUE(false);
753 }
754 auto jsonStr = std::string(data);
755 SinkStartCmd cmd;
756 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
757 EXPECT_EQ(ret, ERR_OK);
758 cJSON_free(data);
759
760 cJSON_AddStringToObject(rootValue, Constants::EXTRO_INFO_JSON_KEY_USERID_ID.c_str(),
761 "test");
762 data = cJSON_Print(rootValue);
763 if (data == nullptr) {
764 cJSON_Delete(rootValue);
765 ASSERT_TRUE(false);
766 }
767 jsonStr = std::string(data);
768 ret = cmd.UnmarshalAccountInfo(jsonStr);
769 EXPECT_EQ(ret, ERR_OK);
770 cJSON_free(data);
771 cJSON_Delete(rootValue);
772 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_003 end" << std::endl;
773 }
774
775 /**
776 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_004
777 * @tc.desc: call UnmarshalAccountInfo
778 * @tc.type: FUNC
779 * @tc.require: I6SJQ6
780 */
781 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_004, TestSize.Level3)
782 {
783 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_004 begin" << std::endl;
784 cJSON *rootValue = cJSON_CreateObject();
785 ASSERT_NE(rootValue, nullptr);
786 cJSON_AddNumberToObject(rootValue, "AccountType", 0);
787 cJSON *groupIdList = cJSON_CreateArray();
788 if (groupIdList == nullptr) {
789 cJSON_Delete(rootValue);
790 ASSERT_TRUE(false);
791 }
792
793 cJSON *groupId = cJSON_CreateNumber(0);
794 if (groupId == nullptr) {
795 cJSON_Delete(rootValue);
796 cJSON_Delete(groupIdList);
797 ASSERT_TRUE(false);
798 }
799 cJSON_AddItemToArray(groupIdList, groupId);
800 cJSON_AddItemToObject(rootValue, "groupIdList", groupIdList);
801 char *data = cJSON_Print(rootValue);
802 if (data == nullptr) {
803 cJSON_Delete(rootValue);
804 ASSERT_TRUE(false);
805 }
806 auto jsonStr = std::string(data);
807 SinkStartCmd cmd;
808 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
809 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
810 cJSON_free(data);
811 cJSON_Delete(rootValue);
812 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_004 end" << std::endl;
813 }
814
815 /**
816 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_005
817 * @tc.desc: call UnmarshalAccountInfo
818 * @tc.type: FUNC
819 * @tc.require: I6SJQ6
820 */
821 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_005, TestSize.Level3)
822 {
823 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_005 begin" << std::endl;
824 cJSON *rootValue = cJSON_CreateObject();
825 ASSERT_NE(rootValue, nullptr);
826 cJSON_AddNumberToObject(rootValue, "AccountType", 0);
827 cJSON_AddNumberToObject(rootValue, "groupIdList", 0);
828 char *data = cJSON_Print(rootValue);
829 if (data == nullptr) {
830 cJSON_Delete(rootValue);
831 ASSERT_TRUE(false);
832 }
833 auto jsonStr = std::string(data);
834 SinkStartCmd cmd;
835 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
836 EXPECT_EQ(ret, ERR_OK);
837 cJSON_free(data);
838
839 cJSON_DeleteItemFromObject(rootValue, "groupIdList");
840 cJSON *groupIdList = cJSON_CreateArray();
841 if (groupIdList == nullptr) {
842 cJSON_Delete(rootValue);
843 ASSERT_TRUE(false);
844 }
845
846 cJSON *groupId = cJSON_CreateNumber(0);
847 if (groupId == nullptr) {
848 cJSON_Delete(rootValue);
849 cJSON_Delete(groupId);
850 ASSERT_TRUE(false);
851 }
852 cJSON_AddItemToArray(groupIdList, groupId);
853 cJSON_AddItemToObject(rootValue, "groupIdList", groupIdList);
854 data = cJSON_Print(rootValue);
855 if (data == nullptr) {
856 cJSON_Delete(rootValue);
857 ASSERT_TRUE(false);
858 }
859 jsonStr = std::string(data);
860 ret = cmd.UnmarshalAccountInfo(jsonStr);
861 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
862 cJSON_free(data);
863 cJSON_Delete(rootValue);
864 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_005 end" << std::endl;
865 }
866
867 /**
868 * @tc.name: SinkStartCmd_UnmarshalAccountInfo_Test_006
869 * @tc.desc: call UnmarshalAccountInfo
870 * @tc.type: FUNC
871 * @tc.require: I6SJQ6
872 */
873 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalAccountInfo_Test_006, TestSize.Level3)
874 {
875 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_006 begin" << std::endl;
876 cJSON *rootValue = cJSON_CreateObject();
877 ASSERT_NE(rootValue, nullptr);
878 cJSON_AddNumberToObject(rootValue, "AccountType", 0);
879 cJSON *groupIdList = cJSON_CreateArray();
880 if (groupIdList == nullptr) {
881 cJSON_Delete(rootValue);
882 ASSERT_TRUE(false);
883 }
884
885 cJSON *groupId = cJSON_CreateString("test");
886 if (groupId == nullptr) {
887 cJSON_Delete(rootValue);
888 cJSON_Delete(groupId);
889 ASSERT_TRUE(false);
890 }
891 cJSON_AddItemToArray(groupIdList, groupId);
892 cJSON_AddItemToObject(rootValue, "groupIdList", groupIdList);
893 auto data = cJSON_Print(rootValue);
894 if (data == nullptr) {
895 cJSON_Delete(rootValue);
896 ASSERT_TRUE(false);
897 }
898 auto jsonStr = std::string(data);
899 SinkStartCmd cmd;
900 auto ret = cmd.UnmarshalAccountInfo(jsonStr);
901 EXPECT_EQ(ret, ERR_OK);
902 cJSON_free(data);
903 cJSON_Delete(rootValue);
904 DTEST_LOG << "SinkStartCmd_UnmarshalAccountInfo_Test_006 end" << std::endl;
905 }
906
CreateNumberAry(cJSON ** rootValue,int32_t size)907 void CreateNumberAry(cJSON **rootValue, int32_t size)
908 {
909 if (rootValue == nullptr || *rootValue == nullptr) {
910 return;
911 }
912
913 cJSON *bundleNames = cJSON_CreateArray();
914 if (bundleNames == nullptr) {
915 return;
916 }
917 for (auto i = 0; i < size; i++) {
918 cJSON *bundleName = cJSON_CreateNumber(i);
919 if (bundleName == nullptr) {
920 cJSON_Delete(bundleNames);
921 return;
922 }
923 cJSON_AddItemToArray(bundleNames, bundleName);
924 }
925 cJSON_AddItemToObject(*rootValue, "BundleNames", bundleNames);
926 }
927
CreateStringAry(cJSON ** rootValue,int32_t size)928 void CreateStringAry(cJSON **rootValue, int32_t size)
929 {
930 if (rootValue == nullptr || *rootValue == nullptr) {
931 return;
932 }
933
934 cJSON *bundleNames = cJSON_CreateArray();
935 if (bundleNames == nullptr) {
936 return;
937 }
938 for (auto i = 0; i < size; i++) {
939 std::string test = "test" + std::to_string(i);
940 cJSON *bundleName = cJSON_CreateString(test.c_str());
941 if (bundleName == nullptr) {
942 cJSON_Delete(bundleNames);
943 return;
944 }
945 cJSON_AddItemToArray(bundleNames, bundleName);
946 }
947 cJSON_AddItemToObject(*rootValue, "BundleNames", bundleNames);
948 }
949
950 /**
951 * @tc.name: SinkStartCmd_UnmarshalCallerInfoExtra_Test_001
952 * @tc.desc: call UnmarshalCallerInfoExtra
953 * @tc.type: FUNC
954 * @tc.require: I6SJQ6
955 */
956 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfoExtra_Test_001, TestSize.Level3)
957 {
958 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_001 begin" << std::endl;
959 std::string jsonStr = "test";
960 SinkStartCmd cmd;
961 auto ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
962 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
963
964 cJSON *rootValue = cJSON_CreateObject();
965 ASSERT_NE(rootValue, nullptr);
966
967 char *data = cJSON_Print(rootValue);
968 if (data == nullptr) {
969 cJSON_Delete(rootValue);
970 ASSERT_TRUE(false);
971 }
972
973 jsonStr = std::string(data);
974 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
975 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
976 cJSON_free(data);
977 int32_t size = 2;
978 CreateNumberAry(&rootValue, size);
979 data = cJSON_Print(rootValue);
980 if (data == nullptr) {
981 cJSON_Delete(rootValue);
982 ASSERT_TRUE(false);
983 }
984
985 jsonStr = std::string(data);
986 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
987 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
988 cJSON_free(data);
989 cJSON_Delete(rootValue);
990 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_001 end" << std::endl;
991 }
992
993 /**
994 * @tc.name: SinkStartCmd_UnmarshalCallerInfoExtra_Test_002
995 * @tc.desc: call UnmarshalCallerInfoExtra
996 * @tc.type: FUNC
997 * @tc.require: I6SJQ6
998 */
999 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfoExtra_Test_002, TestSize.Level3)
1000 {
1001 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_002 begin" << std::endl;
1002 cJSON *rootValue = cJSON_CreateObject();
1003 ASSERT_NE(rootValue, nullptr);
1004 int32_t size = 2;
1005 CreateStringAry(&rootValue, size);
1006 auto data = cJSON_Print(rootValue);
1007 if (data == nullptr) {
1008 cJSON_Delete(rootValue);
1009 ASSERT_TRUE(false);
1010 }
1011
1012 SinkStartCmd cmd;
1013 auto jsonStr = std::string(data);
1014 auto ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1015 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1016 cJSON_free(data);
1017
1018 cJSON_AddNumberToObject(rootValue, "ExtraInfo", 0);
1019 data = cJSON_Print(rootValue);
1020 if (data == nullptr) {
1021 cJSON_Delete(rootValue);
1022 ASSERT_TRUE(false);
1023 }
1024
1025 jsonStr = std::string(data);
1026 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1027 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1028 cJSON_free(data);
1029
1030 cJSON_DeleteItemFromObject(rootValue, "ExtraInfo");
1031 cJSON_AddStringToObject(rootValue, "ExtraInfo", "test");
1032 data = cJSON_Print(rootValue);
1033 if (data == nullptr) {
1034 cJSON_Delete(rootValue);
1035 ASSERT_TRUE(false);
1036 }
1037
1038 jsonStr = std::string(data);
1039 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1040 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1041 cJSON_free(data);
1042 cJSON_Delete(rootValue);
1043 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_002 end" << std::endl;
1044 }
1045
1046 /**
1047 * @tc.name: SinkStartCmd_UnmarshalCallerInfoExtra_Test_003
1048 * @tc.desc: call UnmarshalCallerInfoExtra
1049 * @tc.type: FUNC
1050 * @tc.require: I6SJQ6
1051 */
1052 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfoExtra_Test_003, TestSize.Level3)
1053 {
1054 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_003 begin" << std::endl;
1055 cJSON *rootValue = cJSON_CreateObject();
1056 ASSERT_NE(rootValue, nullptr);
1057 int32_t size = 2;
1058 CreateStringAry(&rootValue, size);
1059 auto data = cJSON_Print(rootValue);
1060 if (data == nullptr) {
1061 cJSON_Delete(rootValue);
1062 ASSERT_TRUE(false);
1063 }
1064
1065 auto jsonStr = std::string(data);
1066 cJSON_AddStringToObject(rootValue, "ExtraInfo", jsonStr.c_str());
1067 cJSON_free(data);
1068 data = cJSON_Print(rootValue);
1069 if (data == nullptr) {
1070 cJSON_Delete(rootValue);
1071 ASSERT_TRUE(false);
1072 }
1073
1074 jsonStr = std::string(data);
1075 SinkStartCmd cmd;
1076 auto ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1077 EXPECT_EQ(ret, ERR_OK);
1078 cJSON_free(data);
1079
1080 cJSON_AddStringToObject(rootValue, EXTRO_INFO_JSON_KEY_ACCESS_TOKEN, "test");
1081 data = cJSON_Print(rootValue);
1082 if (data == nullptr) {
1083 cJSON_Delete(rootValue);
1084 ASSERT_TRUE(false);
1085 }
1086
1087 jsonStr = std::string(data);
1088 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1089 EXPECT_EQ(ret, ERR_OK);
1090 cJSON_free(data);
1091 cJSON_Delete(rootValue);
1092 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_003 end" << std::endl;
1093 }
1094
1095 /**
1096 * @tc.name: SinkStartCmd_UnmarshalCallerInfoExtra_Test_004
1097 * @tc.desc: call UnmarshalCallerInfoExtra
1098 * @tc.type: FUNC
1099 * @tc.require: I6SJQ6
1100 */
1101 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfoExtra_Test_004, TestSize.Level3)
1102 {
1103 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_004 begin" << std::endl;
1104 cJSON *rootValue = cJSON_CreateObject();
1105 ASSERT_NE(rootValue, nullptr);
1106 int32_t size = 2;
1107 CreateStringAry(&rootValue, size);
1108 auto data = cJSON_Print(rootValue);
1109 if (data == nullptr) {
1110 cJSON_Delete(rootValue);
1111 ASSERT_TRUE(false);
1112 }
1113
1114 auto jsonStr = std::string(data);
1115 cJSON_AddStringToObject(rootValue, "ExtraInfo", jsonStr.c_str());
1116 cJSON_AddNumberToObject(rootValue, EXTRO_INFO_JSON_KEY_ACCESS_TOKEN, 0);
1117 cJSON_free(data);
1118 data = cJSON_Print(rootValue);
1119 if (data == nullptr) {
1120 cJSON_Delete(rootValue);
1121 ASSERT_TRUE(false);
1122 }
1123
1124 jsonStr = std::string(data);
1125 SinkStartCmd cmd;
1126 auto ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1127 EXPECT_EQ(ret, ERR_OK);
1128 cJSON_free(data);
1129
1130 cJSON_AddNumberToObject(rootValue, DMS_VERSION_ID, 0);
1131 data = cJSON_Print(rootValue);
1132 if (data == nullptr) {
1133 cJSON_Delete(rootValue);
1134 ASSERT_TRUE(false);
1135 }
1136
1137 jsonStr = std::string(data);
1138 ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1139 EXPECT_EQ(ret, ERR_OK);
1140 cJSON_free(data);
1141 cJSON_Delete(rootValue);
1142 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_004 end" << std::endl;
1143 }
1144
1145 /**
1146 * @tc.name: SinkStartCmd_UnmarshalCallerInfoExtra_Test_005
1147 * @tc.desc: call UnmarshalCallerInfoExtra
1148 * @tc.type: FUNC
1149 * @tc.require: I6SJQ6
1150 */
1151 HWTEST_F(CollabEventTest, SinkStartCmd_UnmarshalCallerInfoExtra_Test_005, TestSize.Level3)
1152 {
1153 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_005 begin" << std::endl;
1154 cJSON *rootValue = cJSON_CreateObject();
1155 ASSERT_NE(rootValue, nullptr);
1156 int32_t size = 2;
1157 CreateStringAry(&rootValue, size);
1158 auto data = cJSON_Print(rootValue);
1159 if (data == nullptr) {
1160 cJSON_Delete(rootValue);
1161 ASSERT_TRUE(false);
1162 }
1163
1164 auto jsonStr = std::string(data);
1165 cJSON_AddStringToObject(rootValue, "ExtraInfo", jsonStr.c_str());
1166 cJSON_AddNumberToObject(rootValue, EXTRO_INFO_JSON_KEY_ACCESS_TOKEN, 0);
1167 cJSON_AddStringToObject(rootValue, DMS_VERSION_ID, "test");
1168 cJSON_free(data);
1169 data = cJSON_Print(rootValue);
1170 if (data == nullptr) {
1171 cJSON_Delete(rootValue);
1172 ASSERT_TRUE(false);
1173 }
1174
1175 jsonStr = std::string(data);
1176 SinkStartCmd cmd;
1177 auto ret = cmd.UnmarshalCallerInfoExtra(jsonStr);
1178 EXPECT_EQ(ret, ERR_OK);
1179 cJSON_free(data);
1180 cJSON_Delete(rootValue);
1181 DTEST_LOG << "SinkStartCmd_UnmarshalCallerInfoExtra_Test_005 end" << std::endl;
1182 }
1183
1184 /**
1185 * @tc.name: NotifyResultCmd_Test_001
1186 * @tc.desc: call NotifyResultCmd
1187 * @tc.type: FUNC
1188 * @tc.require: I6SJQ6
1189 */
1190 HWTEST_F(CollabEventTest, NotifyResultCmd_Test_001, TestSize.Level3)
1191 {
1192 DTEST_LOG << "SinkStartCmd NotifyResultCmd_Test_001 begin" << std::endl;
1193 NotifyResultCmd cmd;
1194 cmd.collabVersion_ = 0;
1195 cmd.dmsVersion_ = 0;
1196 cmd.command_ = 0;
1197 cmd.srcCollabSessionId_ = 0;
1198 cmd.appVersion_ = 0;
1199 cmd.collabToken_ = "collabToken_";
1200 cmd.srcDeviceId_ = "srcDeviceId_";
1201 cmd.srcBundleName_ = "srcBundleName_";
1202 cmd.srcAbilityName_ = "srcAbilityName_";
1203 cmd.srcModuleName_ = "srcModuleName_";
1204 cmd.srcServerId_ = "srcServerId_";
1205 cmd.sinkDeviceId_ = "sinkDeviceId_";
1206 cmd.sinkBundleName_ = "sinkBundleName_";
1207 cmd.sinkAbilityName_ = "sinkAbilityName_";
1208 cmd.sinkModuleName_ = "sinkModuleName_";
1209 cmd.sinkServerId_ = "sinkServerId_";
1210
1211 cmd.sinkSocketName_ = "sinkSocketName";
1212 cmd.abilityRejectReason_ = "abilityRejectReason";
1213
1214 std::string jsonStr;
1215 auto ret = cmd.Marshal(jsonStr);
1216 EXPECT_EQ(ret, ERR_OK);
1217
1218 ret = cmd.Unmarshal(jsonStr);
1219 EXPECT_EQ(ret, ERR_OK);
1220 DTEST_LOG << "SinkStartCmd NotifyResultCmd_Test_001 end" << std::endl;
1221 }
1222
1223 /**
1224 * @tc.name: NotifyResultCmd_Unmarshal_Test_001
1225 * @tc.desc: call Unmarshal
1226 * @tc.type: FUNC
1227 * @tc.require: I6SJQ6
1228 */
1229 HWTEST_F(CollabEventTest, NotifyResultCmd_Unmarshal_Test_001, TestSize.Level3)
1230 {
1231 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_001 begin" << std::endl;
1232 std::string jsonStr = "test";
1233 NotifyResultCmd cmd;
1234 auto ret = cmd.Unmarshal(jsonStr);
1235 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1236 cJSON *rootValue = cJSON_CreateObject();
1237 ASSERT_NE(rootValue, nullptr);
1238 char *data = cJSON_Print(rootValue);
1239 ASSERT_NE(data, nullptr);
1240 jsonStr = std::string(data);
1241 ret = cmd.Unmarshal(jsonStr);
1242 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1243 cJSON_free(data);
1244
1245 cJSON_AddNumberToObject(rootValue, "BaseCmd", 0);
1246 data = cJSON_Print(rootValue);
1247 ASSERT_NE(data, nullptr);
1248 jsonStr = std::string(data);
1249 ret = cmd.Unmarshal(jsonStr);
1250 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1251 cJSON_free(data);
1252
1253 cJSON_DeleteItemFromObject(rootValue, "BaseCmd");
1254 cJSON_AddStringToObject(rootValue, "BaseCmd", "test");
1255 data = cJSON_Print(rootValue);
1256 ASSERT_NE(data, nullptr);
1257 jsonStr = std::string(data);
1258 ret = cmd.Unmarshal(jsonStr);
1259 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1260 cJSON_Delete(rootValue);
1261 cJSON_free(data);
1262 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_001 end" << std::endl;
1263 }
1264
1265 /**
1266 * @tc.name: NotifyResultCmd_Unmarshal_Test_002
1267 * @tc.desc: call Unmarshal
1268 * @tc.type: FUNC
1269 * @tc.require: I6SJQ6
1270 */
1271 HWTEST_F(CollabEventTest, NotifyResultCmd_Unmarshal_Test_002, TestSize.Level3)
1272 {
1273 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_002 begin" << std::endl;
1274 std::string jsonStr;
1275 cJSON *rootValue = cJSON_CreateObject();
1276 ASSERT_NE(rootValue, nullptr);
1277
1278 std::string baseJsonStr;
1279 BaseCmd cmd;
1280 if (cmd.Marshal(baseJsonStr) != ERR_OK) {
1281 cJSON_Delete(rootValue);
1282 ASSERT_TRUE(false);
1283 }
1284
1285 cJSON_AddStringToObject(rootValue, "BaseCmd", baseJsonStr.c_str());
1286
1287 jsonStr = std::string(cJSON_Print(rootValue));
1288 NotifyResultCmd notifyCmd;
1289 auto ret = notifyCmd.Unmarshal(jsonStr);
1290 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1291
1292 cJSON_AddStringToObject(rootValue, "SinkCollabSessionId", "test");
1293 char *data = cJSON_Print(rootValue);
1294 ASSERT_NE(data, nullptr);
1295 jsonStr = std::string(data);
1296 ret = notifyCmd.Unmarshal(jsonStr);
1297 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1298 cJSON_free(data);
1299
1300 cJSON_DeleteItemFromObject(rootValue, "SinkCollabSessionId");
1301 cJSON_AddNumberToObject(rootValue, "SinkCollabSessionId", 0);
1302 data = cJSON_Print(rootValue);
1303 ASSERT_NE(data, nullptr);
1304 jsonStr = std::string(data);
1305 ret = notifyCmd.Unmarshal(jsonStr);
1306 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1307 cJSON_free(data);
1308
1309 cJSON_AddStringToObject(rootValue, "Result", "test");
1310 data = cJSON_Print(rootValue);
1311 ASSERT_NE(data, nullptr);
1312 jsonStr = std::string(data);
1313 ret = notifyCmd.Unmarshal(jsonStr);
1314 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1315 cJSON_free(data);
1316 cJSON_Delete(rootValue);
1317 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_002 end" << std::endl;
1318 }
1319
1320 /**
1321 * @tc.name: NotifyResultCmd_Unmarshal_Test_003
1322 * @tc.desc: call Unmarshal
1323 * @tc.type: FUNC
1324 * @tc.require: I6SJQ6
1325 */
1326 HWTEST_F(CollabEventTest, NotifyResultCmd_Unmarshal_Test_003, TestSize.Level3)
1327 {
1328 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_003 begin" << std::endl;
1329 std::string jsonStr;
1330 cJSON *rootValue = cJSON_CreateObject();
1331 ASSERT_NE(rootValue, nullptr);
1332
1333 std::string baseJsonStr;
1334 BaseCmd cmd;
1335 if (cmd.Marshal(baseJsonStr) != ERR_OK) {
1336 cJSON_Delete(rootValue);
1337 ASSERT_TRUE(false);
1338 }
1339
1340 cJSON_AddStringToObject(rootValue, "BaseCmd", baseJsonStr.c_str());
1341 cJSON_AddNumberToObject(rootValue, "SinkCollabSessionId", 0);
1342 cJSON_AddNumberToObject(rootValue, "Result", 0);
1343
1344 jsonStr = std::string(cJSON_Print(rootValue));
1345 NotifyResultCmd notifyCmd;
1346 auto ret = notifyCmd.Unmarshal(jsonStr);
1347 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1348
1349 cJSON_AddNumberToObject(rootValue, "SinkSocketName", 0);
1350 char *data = cJSON_Print(rootValue);
1351 ASSERT_NE(data, nullptr);
1352 jsonStr = std::string(data);
1353 ret = notifyCmd.Unmarshal(jsonStr);
1354 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1355 cJSON_free(data);
1356
1357 cJSON_DeleteItemFromObject(rootValue, "SinkSocketName");
1358 cJSON_AddStringToObject(rootValue, "SinkSocketName", "SinkSocketName");
1359 data = cJSON_Print(rootValue);
1360 ASSERT_NE(data, nullptr);
1361 jsonStr = std::string(data);
1362 ret = notifyCmd.Unmarshal(jsonStr);
1363 EXPECT_EQ(ret, ERR_OK);
1364 cJSON_free(data);
1365
1366 cJSON_AddNumberToObject(rootValue, "AbilityRejectReason", 0);
1367 data = cJSON_Print(rootValue);
1368 ASSERT_NE(data, nullptr);
1369 jsonStr = std::string(data);
1370 ret = notifyCmd.Unmarshal(jsonStr);
1371 EXPECT_EQ(ret, ERR_OK);
1372 cJSON_Delete(rootValue);
1373 cJSON_free(data);
1374 DTEST_LOG << "NotifyResultCmd_Unmarshal_Test_003 end" << std::endl;
1375 }
1376
1377 /**
1378 * @tc.name: DisconnectCmd_Test_001
1379 * @tc.desc: call DisconnectCmd
1380 * @tc.type: FUNC
1381 * @tc.require: I6SJQ6
1382 */
1383 HWTEST_F(CollabEventTest, DisconnectCmd_Test_001, TestSize.Level3)
1384 {
1385 DTEST_LOG << "DisconnectCmdTest DisconnectCmd_Test_001 begin" << std::endl;
1386 DisconnectCmd cmd;
1387 cmd.collabVersion_ = 0;
1388 cmd.dmsVersion_ = 0;
1389 cmd.command_ = 0;
1390 cmd.srcCollabSessionId_ = 0;
1391 cmd.appVersion_ = 0;
1392 cmd.collabToken_ = "collabToken_";
1393 cmd.srcDeviceId_ = "srcDeviceId_";
1394 cmd.srcBundleName_ = "srcBundleName_";
1395 cmd.srcAbilityName_ = "srcAbilityName_";
1396 cmd.srcModuleName_ = "srcModuleName_";
1397 cmd.srcServerId_ = "srcServerId_";
1398 cmd.sinkDeviceId_ = "sinkDeviceId_";
1399 cmd.sinkBundleName_ = "sinkBundleName_";
1400 cmd.sinkAbilityName_ = "sinkAbilityName_";
1401 cmd.sinkModuleName_ = "sinkModuleName_";
1402 cmd.sinkServerId_ = "sinkServerId_";
1403
1404 std::string jsonStr;
1405 auto ret = cmd.Marshal(jsonStr);
1406 EXPECT_EQ(ret, ERR_OK);
1407
1408 ret = cmd.Unmarshal(jsonStr);
1409 EXPECT_EQ(ret, ERR_OK);
1410 DTEST_LOG << "DisconnectCmdTest DisconnectCmd_Test_001 end" << std::endl;
1411 }
1412
1413 /**
1414 * @tc.name: DisconnectCmd_Unmarshal_Test_001
1415 * @tc.desc: call Unmarshal
1416 * @tc.type: FUNC
1417 * @tc.require: I6SJQ6
1418 */
1419 HWTEST_F(CollabEventTest, DisconnectCmd_Unmarshal_Test_001, TestSize.Level3)
1420 {
1421 DTEST_LOG << "DisconnectCmd_Unmarshal_Test_001 begin" << std::endl;
1422 std::string jsonStr = "test";
1423 DisconnectCmd cmd;
1424 auto ret = cmd.Unmarshal(jsonStr);
1425 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1426 cJSON *rootValue = cJSON_CreateObject();
1427 ASSERT_NE(rootValue, nullptr);
1428 char *data = cJSON_Print(rootValue);
1429 ASSERT_NE(data, nullptr);
1430 jsonStr = std::string(data);
1431 ret = cmd.Unmarshal(jsonStr);
1432 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1433 cJSON_free(data);
1434
1435 cJSON_AddNumberToObject(rootValue, "BaseCmd", 0);
1436 data = cJSON_Print(rootValue);
1437 ASSERT_NE(data, nullptr);
1438 jsonStr = std::string(data);
1439 ret = cmd.Unmarshal(jsonStr);
1440 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1441 cJSON_free(data);
1442
1443 cJSON_DeleteItemFromObject(rootValue, "BaseCmd");
1444 cJSON_AddStringToObject(rootValue, "BaseCmd", "test");
1445 data = cJSON_Print(rootValue);
1446 ASSERT_NE(data, nullptr);
1447 jsonStr = std::string(data);
1448 ret = cmd.Unmarshal(jsonStr);
1449 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1450 cJSON_Delete(rootValue);
1451 cJSON_free(data);
1452 DTEST_LOG << "DisconnectCmd_Unmarshal_Test_001 end" << std::endl;
1453 }
1454
1455 /**
1456 * @tc.name: GetSinkCollabVersionCmd_Marshal_Test_001
1457 * @tc.desc: call Marshal
1458 * @tc.type: FUNC
1459 * @tc.require: I6SJQ6
1460 */
1461 HWTEST_F(CollabEventTest, GetSinkCollabVersionCmd_Marshal_Test_001, TestSize.Level3)
1462 {
1463 DTEST_LOG << "GetSinkCollabVersionCmd_Marshal_Test_001 begin" << std::endl;
1464 std::string jsonStr;
1465 GetSinkCollabVersionCmd cmd;
1466 auto ret = cmd.Marshal(jsonStr);
1467 EXPECT_EQ(ret, ERR_OK);
1468
1469 ret = cmd.Unmarshal(jsonStr);
1470 EXPECT_EQ(ret, ERR_OK);
1471 DTEST_LOG << "GetSinkCollabVersionCmd_Marshal_Test_001 end" << std::endl;
1472 }
1473
1474 /**
1475 * @tc.name: GetSinkCollabVersionCmd_Unmarshal_Test_001
1476 * @tc.desc: call Unmarshal
1477 * @tc.type: FUNC
1478 * @tc.require: I6SJQ6
1479 */
1480 HWTEST_F(CollabEventTest, GetSinkCollabVersionCmd_Unmarshal_Test_001, TestSize.Level3)
1481 {
1482 DTEST_LOG << "GetSinkCollabVersionCmd_Unmarshal_Test_001 begin" << std::endl;
1483 std::string jsonStr = "test";
1484 GetSinkCollabVersionCmd cmd;
1485 auto ret = cmd.Unmarshal(jsonStr);
1486 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1487
1488 cJSON *rootValue = cJSON_CreateObject();
1489 ASSERT_NE(rootValue, nullptr);
1490 char *data = cJSON_Print(rootValue);
1491 if (data == nullptr) {
1492 cJSON_Delete(rootValue);
1493 ASSERT_TRUE(false);
1494 }
1495 jsonStr = std::string(data);
1496 ret = cmd.Unmarshal(jsonStr);
1497 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1498 cJSON_free(data);
1499
1500 cJSON_AddNumberToObject(rootValue, "BaseCmd", 0);
1501 data = cJSON_Print(rootValue);
1502 if (data == nullptr) {
1503 cJSON_Delete(rootValue);
1504 ASSERT_TRUE(false);
1505 }
1506 jsonStr = std::string(data);
1507 ret = cmd.Unmarshal(jsonStr);
1508 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1509 cJSON_free(data);
1510
1511 cJSON_DeleteItemFromObject(rootValue, "BaseCmd");
1512 cJSON_AddStringToObject(rootValue, "BaseCmd", "test");
1513 data = cJSON_Print(rootValue);
1514 if (data == nullptr) {
1515 cJSON_Delete(rootValue);
1516 ASSERT_TRUE(false);
1517 }
1518 jsonStr = std::string(data);
1519 ret = cmd.Unmarshal(jsonStr);
1520 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1521 cJSON_Delete(rootValue);
1522 cJSON_free(data);
1523 DTEST_LOG << "GetSinkCollabVersionCmd_Unmarshal_Test_001 end" << std::endl;
1524 }
1525
1526 /**
1527 * @tc.name: GetSinkCollabVersionCmd_Unmarshal_Test_002
1528 * @tc.desc: call Unmarshal
1529 * @tc.type: FUNC
1530 * @tc.require: I6SJQ6
1531 */
1532 HWTEST_F(CollabEventTest, GetSinkCollabVersionCmd_Unmarshal_Test_002, TestSize.Level3)
1533 {
1534 DTEST_LOG << "GetSinkCollabVersionCmd_Unmarshal_Test_002 begin" << std::endl;
1535 cJSON *rootValue = cJSON_CreateObject();
1536 ASSERT_NE(rootValue, nullptr);
1537 std::string baseJsonStr;
1538 BaseCmd baseCmd;
1539 if (baseCmd.Marshal(baseJsonStr) != ERR_OK) {
1540 cJSON_Delete(rootValue);
1541 ASSERT_TRUE(false);
1542 }
1543 cJSON_AddStringToObject(rootValue, "BaseCmd", baseJsonStr.c_str());
1544 auto data = cJSON_Print(rootValue);
1545 if (data == nullptr) {
1546 cJSON_Delete(rootValue);
1547 ASSERT_TRUE(false);
1548 }
1549 auto jsonStr = std::string(data);
1550 GetSinkCollabVersionCmd cmd;
1551 auto ret = cmd.Unmarshal(jsonStr);
1552 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1553 cJSON_free(data);
1554
1555 cJSON_AddStringToObject(rootValue, "SrcPid", "SrcPid");
1556 data = cJSON_Print(rootValue);
1557 if (data == nullptr) {
1558 cJSON_Delete(rootValue);
1559 ASSERT_TRUE(false);
1560 }
1561 jsonStr = std::string(data);
1562 ret = cmd.Unmarshal(jsonStr);
1563 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1564 cJSON_free(data);
1565 cJSON_Delete(rootValue);
1566 DTEST_LOG << "GetSinkCollabVersionCmd_Unmarshal_Test_002 end" << std::endl;
1567 }
1568 }
1569 }
1570