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 #define protected public
20 #include "distributed_operation.h"
21 #include "distributed_operation_builder.h"
22 #undef private
23 #undef protected
24 #include "test_log.h"
25 
26 using namespace OHOS;
27 using namespace testing::ext;
28 using namespace OHOS::DistributedSchedule;
29 using OHOS::Parcel;
30 using Uri = OHOS::Uri;
31 class DistributedOperationBaseTest : public testing::Test {
32 public:
DistributedOperationBaseTest()33     DistributedOperationBaseTest()
34     {}
~DistributedOperationBaseTest()35     ~DistributedOperationBaseTest()
36     {}
37     static void SetUpTestCase(void);
38     static void TearDownTestCase(void);
39     void SetUp();
40     void TearDown();
41 
42     std::shared_ptr<DistributedOperationBuilder> operationbuilder_ = nullptr;
43     static sptr<DistributedOperation> distributedOperation_;
44 };
45 
46 sptr<DistributedOperation> DistributedOperationBaseTest::distributedOperation_;
47 
SetUpTestCase(void)48 void DistributedOperationBaseTest::SetUpTestCase(void)
49 {
50     distributedOperation_ = new DistributedOperation();
51 }
52 
TearDownTestCase(void)53 void DistributedOperationBaseTest::TearDownTestCase(void)
54 {}
55 
SetUp(void)56 void DistributedOperationBaseTest::SetUp(void)
57 {
58     operationbuilder_ = std::make_shared<DistributedOperationBuilder>();
59 }
60 
TearDown(void)61 void DistributedOperationBaseTest::TearDown(void)
62 {}
63 
64 /**
65  * @tc.number: DmsFwk_DistributedOperation_GetAbilityName_0100
66  * @tc.name: WithAbilityName/GetAbilityName.
67  * @tc.desc: Verify the function when the input string contains special characters.
68  */
69 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetAbilityName_0100, Function | MediumTest | Level3)
70 {
71     ASSERT_NE(operationbuilder_, nullptr);
72     std::string value = "enter";
73     GTEST_LOG_(INFO) << "DmsFwk_DistributedOperation_GetAbilityName_0100 start";
74 
75     operationbuilder_->WithAbilityName(value);
76     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
77     EXPECT_STREQ(value.c_str(), operation->GetAbilityName().c_str());
78 
79     GTEST_LOG_(INFO) << "DmsFwk_DistributedOperation_GetAbilityName_0100 end";
80 }
81 
82 /**
83  * @tc.number: DmsFwk_DistributedOperation_GetAbilityName_0200
84  * @tc.name: WithAbilityName/GetAbilityName.
85  * @tc.desc: Verify the function when the input string is empty.
86  */
87 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetAbilityName_0200, Function | MediumTest | Level3)
88 {
89     ASSERT_NE(operationbuilder_, nullptr);
90     std::string value = "";
91     operationbuilder_->WithAbilityName(value);
92     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
93     ASSERT_NE(operation, nullptr);
94     EXPECT_STREQ(value.c_str(), operation->GetAbilityName().c_str());
95 }
96 
97 /**
98  * @tc.number:  DmsFwk_DistributedOperation_GetBundleName_0100
99  * @tc.name: WithBundleName/GetBundleName
100  * @tc.desc: Verify the function when the input string contains special characters.
101  */
102 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetBundleName_0100, Function | MediumTest | Level3)
103 {
104     ASSERT_NE(operationbuilder_, nullptr);
105     std::string value = "value";
106     operationbuilder_->WithBundleName(value);
107     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
108     ASSERT_NE(operation, nullptr);
109     EXPECT_STREQ(value.c_str(), operation->GetBundleName().c_str());
110 }
111 
112 /**
113  * @tc.number: DmsFwk_DistributedOperation_GetBundleName_0200
114  * @tc.name: WithBundleName/GetBundleName
115  * @tc.desc: Verify the function when the input string is empty.
116  */
117 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetBundleName_0200, Function | MediumTest | Level3)
118 {
119     ASSERT_NE(operationbuilder_, nullptr);
120     std::string value = "";
121     operationbuilder_->WithBundleName(value);
122     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
123     ASSERT_NE(operation, nullptr);
124     EXPECT_STREQ(value.c_str(), operation->GetBundleName().c_str());
125 }
126 
127 /**
128  * @tc.number: DmsFwk_DistributedOperation_GetDeviceId_0100
129  * @tc.name: WithDeviceId/GetDeviceId
130  * @tc.desc: Verify the function when the input string contains special characters.
131  */
132 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetDeviceId_0100, Function | MediumTest | Level3)
133 {
134     ASSERT_NE(operationbuilder_, nullptr);
135     std::string value = "value";
136     operationbuilder_->WithDeviceId(value);
137     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
138     ASSERT_NE(operation, nullptr);
139     EXPECT_STREQ(value.c_str(), operation->GetDeviceId().c_str());
140 }
141 
142 /**
143  * @tc.number: DmsFwk_DistributedOperation_GetDeviceId_0200
144  * @tc.name: WithDeviceId/GetDeviceId
145  * @tc.desc: Verify the function when the input string is empty.
146  */
147 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetDeviceId_0200, Function | MediumTest | Level3)
148 {
149     ASSERT_NE(operationbuilder_, nullptr);
150     std::string value = "";
151     operationbuilder_->WithDeviceId(value);
152     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
153     ASSERT_NE(operation, nullptr);
154     EXPECT_STREQ(value.c_str(), operation->GetDeviceId().c_str());
155 }
156 
157 /**
158  * @tc.number: DmsFwk_DistributedOperation_GetAction_0100
159  * @tc.name: WithAction/GetAction
160  * @tc.desc: Verify the function when the input string contains special characters.
161  */
162 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetAction_0100, Function | MediumTest | Level3)
163 {
164     ASSERT_NE(operationbuilder_, nullptr);
165     std::string value = "value";
166     operationbuilder_->WithAction(value);
167     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
168     ASSERT_NE(operation, nullptr);
169     EXPECT_STREQ(value.c_str(), operation->GetAction().c_str());
170 }
171 
172 /**
173  * @tc.number: DmsFwk_DistributedOperation_GetAction_0200
174  * @tc.name: WithAction/GetAction
175  * @tc.desc: Verify the function when the input string is empty.
176  */
177 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetAction_0200, Function | MediumTest | Level3)
178 {
179     ASSERT_NE(operationbuilder_, nullptr);
180     std::string value = "";
181     operationbuilder_->WithAction(value);
182     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
183     ASSERT_NE(operation, nullptr);
184     EXPECT_STREQ(value.c_str(), operation->GetAction().c_str());
185 }
186 
187 /**
188  * @tc.number: DmsFwk_DistributedOperation_GetEntities_0100
189  * @tc.name: WithEntities/GetEntities
190  * @tc.desc: Verify the function when the input string contains special characters.
191  */
192 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetEntities_0100, Function | MediumTest | Level3)
193 {
194     ASSERT_NE(operationbuilder_, nullptr);
195     std::vector<std::string> value;
196     value.push_back("string1");
197     operationbuilder_->WithEntities(value);
198     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
199     ASSERT_NE(operation, nullptr);
200     std::vector<std::string> revValue = operation->GetEntities();
201 
202     if (value.size() > 0 && revValue.size() > 0) {
203         EXPECT_STREQ(value.at(0).c_str(), operation->GetEntities().at(0).c_str());
204     } else {
205         EXPECT_EQ(true, revValue.size() > 0);
206     }
207 }
208 
209 /**
210  * @tc.number: DmsFwk_DistributedOperation_GetEntities_0200
211  * @tc.name: WithEntities/GetEntities
212  * @tc.desc: Verify the function when the input string is empty.
213  */
214 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetEntities_0200, Function | MediumTest | Level3)
215 {
216     ASSERT_NE(operationbuilder_, nullptr);
217     std::vector<std::string> value;
218     operationbuilder_->WithEntities(value);
219     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
220     ASSERT_NE(operation, nullptr);
221     EXPECT_EQ(true, operation->GetEntities().size() == 0);
222 }
223 
224 /**
225  * @tc.number: DmsFwk_DistributedOperation_GetFlags_0100
226  * @tc.name: WithFlags/GetFlags
227  * @tc.desc: Verify the function when the input string contains special characters.
228  */
229 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetFlags_0100, Function | MediumTest | Level3)
230 {
231     ASSERT_NE(operationbuilder_, nullptr);
232     unsigned int value = 1;
233     operationbuilder_->WithFlags(value);
234     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
235     ASSERT_NE(operation, nullptr);
236     EXPECT_EQ(value, operation->GetFlags());
237 }
238 
239 /**
240  * @tc.number: DmsFwk_DistributedOperation_GetFlags_0200
241  * @tc.name: WithFlags/GetFlags
242  * @tc.desc: Verify the function when the input string is empty.
243  */
244 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetFlags_0200, Function | MediumTest | Level3)
245 {
246     ASSERT_NE(operationbuilder_, nullptr);
247     unsigned int value = 0;
248     operationbuilder_->WithFlags(value);
249     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
250     ASSERT_NE(operation, nullptr);
251     EXPECT_EQ(value, operation->GetFlags());
252 }
253 
254 /**
255  * @tc.number: DmsFwk_DistributedOperation_GetUri_0100
256  * @tc.name: WithUri/GetUri
257  * @tc.desc: Verify the function when the input string contains special characters.
258  */
259 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetUri_0100, Function | MediumTest | Level3)
260 {
261     ASSERT_NE(operationbuilder_, nullptr);
262     std::string value = "scheme://authority/path1/path2/path3?id = 1&name = mingming&old#fragment";
263     OHOS::Uri uri(value);
264     operationbuilder_->WithUri(uri);
265     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
266     ASSERT_NE(operation, nullptr);
267     EXPECT_EQ(uri, operation->GetUri());
268 }
269 
270 /**
271  * @tc.number: DmsFwk_DistributedOperation_GetUri_0200
272  * @tc.name: WithUri/GetUri
273  * @tc.desc: Verify the function when the input string is empty.
274  */
275 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_GetUri_0200, Function | MediumTest | Level3)
276 {
277     ASSERT_NE(operationbuilder_, nullptr);
278     std::string value = "";
279     OHOS::Uri uri(value);
280     operationbuilder_->WithUri(uri);
281     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
282     ASSERT_NE(operation, nullptr);
283     EXPECT_EQ(uri, operation->GetUri());
284 }
285 
286 /**
287  * @tc.number: DmsFwk_DistributedOperation_build_0100
288  * @tc.name: build
289  * @tc.desc: Verify that the parameters are correct.
290  */
291 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_build_0100, Function | MediumTest | Level3)
292 {
293     ASSERT_NE(operationbuilder_, nullptr);
294     std::string value = "value";
295     OHOS::Uri uri(value);
296     std::vector<std::string> columns;
297     columns.push_back("string1");
298     operationbuilder_->WithUri(uri);
299     operationbuilder_->WithAction(value);
300     operationbuilder_->WithEntities(columns);
301     operationbuilder_->WithDeviceId(value);
302     operationbuilder_->WithBundleName(value);
303     operationbuilder_->WithAbilityName(value);
304 
305     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
306     ASSERT_NE(operation, nullptr);
307     EXPECT_EQ(uri, operation->GetUri());
308     EXPECT_STREQ(value.c_str(), operation->GetAction().c_str());
309 
310     std::vector<std::string> revValue = operation->GetEntities();
311 
312     if (columns.size() > 0 && revValue.size() > 0) {
313         EXPECT_STREQ(columns.at(0).c_str(), operation->GetEntities().at(0).c_str());
314     } else {
315         EXPECT_EQ(true, revValue.size() > 0);
316     }
317     EXPECT_STREQ(value.c_str(), operation->GetDeviceId().c_str());
318     EXPECT_STREQ(value.c_str(), operation->GetBundleName().c_str());
319     EXPECT_STREQ(value.c_str(), operation->GetAbilityName().c_str());
320 }
321 
322 /**
323  * @tc.number: DmsFwk_DistributedOperation_Marshalling_0100
324  * @tc.name: Marshalling/Unmarshalling
325  * @tc.desc: Validation serialization.
326  */
327 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Marshalling_0100, Function | MediumTest | Level3)
328 {
329     ASSERT_NE(operationbuilder_, nullptr);
330     std::string value = "value";
331     OHOS::Uri uri(value);
332     std::vector<std::string> columns;
333     columns.push_back("string1");
334     operationbuilder_->WithUri(uri);
335     operationbuilder_->WithAction(value);
336     operationbuilder_->WithEntities(columns);
337     operationbuilder_->WithDeviceId(value);
338     operationbuilder_->WithBundleName(value);
339     operationbuilder_->WithAbilityName(value);
340 
341     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
342     ASSERT_NE(operation, nullptr);
343     Parcel in;
344     operation->Marshalling(in);
345 
346     DistributedOperation* pOperation = operation->Unmarshalling(in);
347     if (pOperation != nullptr) {
348         EXPECT_EQ(true, *pOperation == *(operation.get()));
349     } else {
350         EXPECT_EQ(true, pOperation != nullptr);
351     }
352 }
353 
354 /**
355  * @tc.number: DmsFwk_DistributedOperation_Operator_0100
356  * @tc.name: Operator
357  * @tc.desc: Verify string overload.
358  */
359 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0100, Function | MediumTest | Level3)
360 {
361     ASSERT_NE(operationbuilder_, nullptr);
362     DistributedOperation operation_;
363     std::string value = "value";
364     OHOS::Uri uri(value);
365     std::vector<std::string> columns;
366     columns.push_back("string1");
367     operationbuilder_->WithUri(uri);
368     operationbuilder_->WithAction(value);
369     operationbuilder_->WithEntities(columns);
370     operationbuilder_->WithDeviceId(value);
371     operationbuilder_->WithBundleName(value);
372     operationbuilder_->WithAbilityName(value);
373 
374     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
375     ASSERT_NE(operation, nullptr);
376     operation_ = *(operation.get());
377 
378     EXPECT_EQ(true, operation_ == *(operation.get()));
379 }
380 
381 /**
382  * @tc.number: DmsFwk_DistributedOperation_AddEntity_0100
383  * @tc.name: AddEntity
384  * @tc.desc: test AddEntity.
385  * @tc.require: I77HFZ
386  */
387 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_AddEntity_0100, Function | MediumTest | Level3)
388 {
389     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_AddEntity_0100 begin" << std::endl;
390     ASSERT_NE(distributedOperation_, nullptr);
391     std::string entity = "test";
392     distributedOperation_->entities_.emplace_back(entity);
393     distributedOperation_->AddEntity(entity);
394     distributedOperation_->entities_.clear();
395     EXPECT_TRUE(distributedOperation_->entities_.empty());
396     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_AddEntity_0100 end" << std::endl;
397 }
398 
399 /**
400  * @tc.number: DmsFwk_DistributedOperation_RemoveEntity_0100
401  * @tc.name: RemoveEntity
402  * @tc.desc: test RemoveEntity.
403  * @tc.require: I77HFZ
404  */
405 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_RemoveEntity_0100, Function | MediumTest | Level3)
406 {
407     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_RemoveEntity_0100 begin" << std::endl;
408     ASSERT_NE(distributedOperation_, nullptr);
409     std::string entity = "test";
410     distributedOperation_->entities_.clear();
411     distributedOperation_->RemoveEntity(entity);
412     distributedOperation_->entities_.clear();
413     EXPECT_TRUE(distributedOperation_->entities_.empty());
414     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_RemoveEntity_0100 end" << std::endl;
415 }
416 
417 /**
418  * @tc.number: DmsFwk_DistributedOperation_RemoveEntity_0200
419  * @tc.name: RemoveEntity
420  * @tc.desc: test RemoveEntity.
421  * @tc.require: I77HFZ
422  */
423 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_RemoveEntity_0200, Function | MediumTest | Level3)
424 {
425     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_RemoveEntity_0200 begin" << std::endl;
426     ASSERT_NE(distributedOperation_, nullptr);
427     std::string entity = "test";
428     distributedOperation_->entities_.emplace_back(entity);
429     std::string entity1 = "test1";
430     distributedOperation_->RemoveEntity(entity1);
431     distributedOperation_->entities_.clear();
432     EXPECT_TRUE(distributedOperation_->entities_.empty());
433     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_RemoveEntity_0200 end" << std::endl;
434 }
435 
436 /**
437  * @tc.number: DmsFwk_DistributedOperation_Operator_0200
438  * @tc.name: Operator
439  * @tc.desc: test Operator.
440  * @tc.require: I77HFZ
441  */
442 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0200, Function | MediumTest | Level3)
443 {
444     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0200 begin" << std::endl;
445     DistributedOperation operation1;
446     DistributedOperation operation2;
447     operation1.abilityName_ = "test";
448     EXPECT_FALSE(operation1 == operation2);
449     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0200 end" << std::endl;
450 }
451 
452 /**
453  * @tc.number: DmsFwk_DistributedOperation_Operator_0300
454  * @tc.name: Operator
455  * @tc.desc: test Operator.
456  * @tc.require: I77HFZ
457  */
458 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0300, Function | MediumTest | Level3)
459 {
460     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0300 begin" << std::endl;
461     DistributedOperation operation1;
462     DistributedOperation operation2;
463     operation1.action_ = "test";
464     EXPECT_FALSE(operation1 == operation2);
465     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0300 end" << std::endl;
466 }
467 
468 /**
469  * @tc.number: DmsFwk_DistributedOperation_Operator_0400
470  * @tc.name: Operator
471  * @tc.desc: test Operator.
472  * @tc.require: I77HFZ
473  */
474 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0400, Function | MediumTest | Level3)
475 {
476     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0400 begin" << std::endl;
477     DistributedOperation operation1;
478     DistributedOperation operation2;
479     operation1.bundleName_ = "test";
480     EXPECT_FALSE(operation1 == operation2);
481     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0400 end" << std::endl;
482 }
483 
484 /**
485  * @tc.number: DmsFwk_DistributedOperation_Operator_0500
486  * @tc.name: Operator
487  * @tc.desc: test Operator.
488  * @tc.require: I77HFZ
489  */
490 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0500, Function | MediumTest | Level3)
491 {
492     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0500 begin" << std::endl;
493     DistributedOperation operation1;
494     DistributedOperation operation2;
495     operation1.deviceId_ = "test";
496     EXPECT_FALSE(operation1 == operation2);
497     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0500 end" << std::endl;
498 }
499 
500 /**
501  * @tc.number: DmsFwk_DistributedOperation_Operator_0600
502  * @tc.name: Operator
503  * @tc.desc: test Operator.
504  * @tc.require: I77HFZ
505  */
506 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0600, Function | MediumTest | Level3)
507 {
508     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0600 begin" << std::endl;
509     DistributedOperation operation1;
510     DistributedOperation operation2;
511     operation1.moduleName_ = "test";
512     EXPECT_FALSE(operation1 == operation2);
513     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0600 end" << std::endl;
514 }
515 
516 /**
517  * @tc.number: DmsFwk_DistributedOperation_Operator_0700
518  * @tc.name: Operator
519  * @tc.desc: test Operator.
520  * @tc.require: I77HFZ
521  */
522 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0700, Function | MediumTest | Level3)
523 {
524     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0700 begin" << std::endl;
525     DistributedOperation operation1;
526     DistributedOperation operation2;
527     std::string entity = "test";
528     operation1.entities_.emplace_back(entity);
529     EXPECT_FALSE(operation1 == operation2);
530     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0700 end" << std::endl;
531 }
532 
533 /**
534  * @tc.number: DmsFwk_DistributedOperation_Operator_0800
535  * @tc.name: Operator
536  * @tc.desc: test Operator.
537  * @tc.require: I77HFZ
538  */
539 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0800, Function | MediumTest | Level3)
540 {
541     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0800 begin" << std::endl;
542     DistributedOperation operation1;
543     DistributedOperation operation2;
544     std::string entity = "test";
545     operation1.entities_.emplace_back(entity);
546     std::string entity1 = "test1";
547     operation2.entities_.emplace_back(entity1);
548     EXPECT_FALSE(operation1 == operation2);
549     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0800 end" << std::endl;
550 }
551 
552 /**
553  * @tc.number: DmsFwk_DistributedOperation_Operator_0900
554  * @tc.name: Operator
555  * @tc.desc: test Operator.
556  * @tc.require: I77HFZ
557  */
558 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_0900, Function | MediumTest | Level3)
559 {
560     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0900 begin" << std::endl;
561     DistributedOperation operation1;
562     DistributedOperation operation2;
563     operation1.flags_ = 1;
564     EXPECT_FALSE(operation1 == operation2);
565     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_0900 end" << std::endl;
566 }
567 
568 /**
569  * @tc.number: DmsFwk_DistributedOperation_Operator_1000
570  * @tc.name: Operator
571  * @tc.desc: test Operator.
572  * @tc.require: I77HFZ
573  */
574 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Operator_1000, Function | MediumTest | Level3)
575 {
576     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_1000 begin" << std::endl;
577     DistributedOperation operation1;
578     DistributedOperation operation2;
579     std::string value = "test";
580     OHOS::Uri uri(value);
581     operation1.uri_ = uri;
582     EXPECT_FALSE(operation1 == operation2);
583     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Operator_1000 end" << std::endl;
584 }
585 
586 /**
587  * @tc.number: DmsFwk_DistributedOperation_Marshalling_0200
588  * @tc.name: Marshalling
589  * @tc.desc: test Marshalling.
590  * @tc.require: I77HFZ
591  */
592 HWTEST_F(DistributedOperationBaseTest, DmsFwk_DistributedOperation_Marshalling_0200, Function | MediumTest | Level3)
593 {
594     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Marshalling_0200 begin" << std::endl;
595     ASSERT_NE(operationbuilder_, nullptr);
596     std::string value = "";
597     OHOS::Uri uri(value);
598     std::vector<std::string> columns;
599     columns.push_back("string1");
600     operationbuilder_->WithUri(uri);
601     operationbuilder_->WithAction(value);
602     operationbuilder_->WithEntities(columns);
603     operationbuilder_->WithDeviceId(value);
604     operationbuilder_->WithBundleName(value);
605     operationbuilder_->WithAbilityName(value);
606 
607     std::shared_ptr<DistributedOperation> operation = operationbuilder_->build();
608     Parcel in;
609     bool ret = operation->Marshalling(in);
610     EXPECT_TRUE(ret);
611     DTEST_LOG << "DistributedWantParamsBaseTest DmsFwk_DistributedOperation_Marshalling_0200 begin" << std::endl;
612 }