1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium';
17import rpc from "@ohos.rpc";
18import deviceManager from '@ohos.distributedDeviceManager';
19import featureAbility from "@ohos.ability.featureAbility";
20import { UiDriver, BY } from '@ohos.UiTest';
21import abilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry';
22
23let connectId = null;
24let connectId1 = null;
25let dvList = [];
26let dvId = null;
27let abilityDelegator = abilityDelegatorRegistry.getAbilityDelegator();
28let dmInstance
29let localDeviceId
30export default function DmsFwkFaTest() {
31
32  describe('DmsFwkFaTest', function () {
33    async function getDeviceId() {
34      console.log('getDeviceId is begin')
35      try {
36        dmInstance = deviceManager.createDeviceManager('com.acts.example.dmsfwkstageservert');
37        console.log('get deviceManager is success')
38      } catch (error) {
39        console.log('get deviceManager is failed' + JSON.stringify(error))
40      }
41      localDeviceId = dmInstance.getLocalDeviceNetworkId();
42      console.info("local device id is: " + localDeviceId);
43      let deviceList = dmInstance.getAvailableDeviceListSync();
44      dvList = deviceList;
45      let deviceId = deviceList[0].networkId;
46      dvId = deviceId;
47      console.info("deviceid is: " + deviceId);
48      console.info("deviceList is: " + JSON.stringify(deviceList));
49    }
50
51    function sleep(ms) {
52      return new Promise(resolve => setTimeout(resolve, ms));
53    }
54
55    async function getPermission() {
56      console.info(`getPermission is start`);
57      let permissions = ['ohos.permission.DISTRIBUTED_DATASYNC'];
58      let context = featureAbility.getContext()
59      context.requestPermissionsFromUser(permissions, 666, (data) => {
60        console.info("request success" + JSON.stringify(data));
61      })
62    }
63
64    async function driveFn() {
65      try {
66        let driver = await UiDriver.create()
67        console.info(` come in driveFn`)
68        console.info(`driver is ${JSON.stringify(driver)}`)
69        await sleep(1000);
70        let button = await driver.findComponent(BY.text('允许'));
71        console.info(`button is ${JSON.stringify(button)}`);
72        await sleep(1000);
73        await button.click();
74        await sleep(1000);
75      } catch (err) {
76        console.info('err is ' + err);
77        return;
78      }
79    }
80
81    async function driveClick() {
82      try {
83        let driver = await UiDriver.create();
84        console.info(`come in driveFn`);
85        console.info(`driver is ${JSON.stringify(driver)}`);
86        await sleep(1000);
87        let button = await driver.findComponent(BY.text('知道了'));
88        console.info(`button is ${JSON.stringify(button)}`);
89        await sleep(1000);
90        await button.click();
91      } catch (err) {
92        console.info('err is ' + err);
93        return;
94      }
95    }
96
97    beforeAll(async function (done) {
98      console.info('beforeAll called dms')
99      getDeviceId()
100      await getPermission();
101      await sleep(1000);
102      await driveFn();
103      await sleep(1000);
104      await getDeviceId()
105      await sleep(1000);
106      done()
107    })
108
109    beforeEach(async function (done) {
110      console.info(('beforeEach called'))
111      done()
112    })
113
114    afterEach(async function (done) {
115      console.info('afterEach called')
116      done();
117    })
118
119    afterAll(async function (done) {
120      console.info('afterAll called')
121      await driveClick();
122      sleep(5000);
123      done()
124    })
125
126    /*
127    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800
128    * @tc.name    StartRemoteAbilityForResult remote MainAbility is success
129    * @tc.desc    Function test
130    * @tc.level   0
131    */
132    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800", 0, async function (done) {
133      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 is start---------------");
134      try {
135        featureAbility.startAbilityForResult({
136          "want": {
137            deviceId: dvId,
138            bundleName: "com.acts.example.dmsfwkstageserver",
139            abilityName: "MainAbility2",
140            parameters: {
141              startReason: "terminateSelfWithResult"
142            }
143          }
144        }).then((data) => {
145          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 data is' + data.resultCode);
146          expect(data.resultCode).assertEqual(100);
147          done();
148        }).catch((err) => {
149          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 is failed ' + err.code);
150          expect().assertFail();
151          done();
152        })
153      } catch (err) {
154        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 catch' + err.code);
155        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 catch' + err.message);
156        expect().assertFail();
157        done();
158      }
159      await sleep(1000);
160      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2800 is end---------------");
161    });
162
163    /*
164    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600
165    * @tc.name    StartRemoteAbilityForResult deviceId is null
166    * @tc.desc    Function test
167    * @tc.level   0
168    */
169    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600", 0, async function (done) {
170      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 is start---------------");
171      try {
172        featureAbility.startAbilityForResult({
173          "want": {
174            deviceId: '',
175            bundleName: "com.acts.example.dmsfwkstageserver",
176            abilityName: "MainAbility2",
177            parameters: {
178              startReason: "terminateSelfWithResult"
179            }
180          }
181        }).then((data) => {
182          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 data is' + data.resultCode);
183          expect().assertFail();
184          done();
185        }).catch((err) => {
186          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 is failed ' + err.code);
187          expect(err.code).assertEqual(1)
188          done();
189        })
190      } catch (err) {
191        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 catch' + err.code);
192        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 catch' + err.message);
193        expect().assertFail();
194        done();
195      }
196      await sleep(1000);
197      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2600 is end---------------");
198    });
199
200    /*
201    * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900
202    * @tc.name    StartRemoteAbilityForResult deviceId is Does not exist
203    * @tc.desc    Function test
204    * @tc.level   0
205    */
206    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900", 0, async function (done) {
207      console.info("---------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 is start---------------");
208      try {
209        featureAbility.startAbilityForResult({
210          "want": {
211            bundleName: "com.acts.example.dmsfwkstageserver",
212            abilityName: "MainAbility2",
213            parameters: {
214              startReason: "terminateSelfWithResult"
215            }
216          }
217        }).then((data) => {
218          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 data is' + data.resultCode);
219          expect().assertFail();
220          done();
221        }).catch((err) => {
222          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 is failed ' + err.code);
223          expect(err.code).assertEqual(1)
224          done();
225        })
226      } catch (err) {
227        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 catch' + err.code);
228        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 catch' + err.message);
229        expect().assertFail();
230        done();
231      }
232      await sleep(1000);
233      console.info("---------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 is end---------------");
234    });
235
236    /*
237    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500
238    * @tc.name    StartRemoteAbilityForResult deviceId is undefined
239    * @tc.desc    Function test
240    * @tc.level   0
241    */
242    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500", 0, async function (done) {
243      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 is start---------------");
244      try {
245        featureAbility.startAbilityForResult({
246          "want": {
247            deviceId: undefined,
248            bundleName: "com.acts.example.dmsfwkstageserver",
249            abilityName: "MainAbility2",
250            parameters: {
251              startReason: "terminateSelfWithResult"
252            }
253          }
254        }).then((data) => {
255          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 data is' + data.resultCode);
256          expect().assertFail();
257          done();
258        }).catch((err) => {
259          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 is failed ' + err.code);
260          expect(err.code).assertEqual(1)
261          done();
262        })
263      } catch (err) {
264        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 catch' + err.code);
265        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 catch' + err.message);
266        expect().assertFail();
267        done();
268      }
269      await sleep(1000);
270      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2500 is end---------------");
271    });
272
273    /*
274    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700
275    * @tc.name    StartRemoteAbilityForResult deviceId is err
276    * @tc.desc    Function test
277    * @tc.level   0
278    */
279    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700", 0, async function (done) {
280      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 is start---------------");
281      try {
282        featureAbility.startAbilityForResult({
283          "want": {
284            deviceId: '12345678+./xts',
285            bundleName: "com.acts.example.dmsfwkstageserver",
286            abilityName: "MainAbility2",
287            parameters: {
288              startReason: "terminateSelfWithResult"
289            }
290          }
291        }).then((data) => {
292          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 data is' + data.resultCode);
293          expect().assertFail();
294          done();
295        }).catch((err) => {
296          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 is failed ' + err.code);
297          expect(err.code).assertEqual(9)
298          done();
299        })
300      } catch (err) {
301        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 catch' + err.code);
302        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 catch' + err.message);
303        expect().assertFail();
304        done();
305      }
306      await sleep(1000);
307      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2700 is end---------------");
308    });
309
310    /*
311    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300
312    * @tc.name    StartRemoteAbilityForResult bundleName is null
313    * @tc.desc    Function test
314    * @tc.level   0
315    */
316    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300", 0, async function (done) {
317      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 is start---------------");
318      try {
319        featureAbility.startAbilityForResult({
320          "want": {
321            deviceId: dvId,
322            bundleName: "",
323            abilityName: "MainAbility2",
324            parameters: {
325              startReason: "terminateSelfWithResult"
326            }
327          }
328        }).then((data) => {
329          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 data is' + data.resultCode);
330          expect().assertFail();
331          done();
332        }).catch((err) => {
333          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 is failed ' + err.code);
334          expect(err.code).assertEqual(1)
335          done();
336        })
337      } catch (err) {
338        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 catch' + err.code);
339        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 catch' + err.message);
340        expect().assertFail();
341        done();
342      }
343      await sleep(1000);
344      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2300 is end---------------");
345    });
346
347    /*
348    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600
349    * @tc.name    StartRemoteAbilityForResult bundleName is Does not exist
350    * @tc.desc    Function test
351    * @tc.level   0
352    */
353    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600", 0, async function (done) {
354      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 is start---------------");
355      try {
356        featureAbility.startAbilityForResult({
357          "want": {
358            deviceId: dvId,
359            abilityName: "MainAbility2",
360            parameters: {
361              startReason: "terminateSelfWithResult"
362            }
363          }
364        }).then((data) => {
365          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 data is' + data.resultCode);
366          expect().assertFail();
367          done();
368        }).catch((err) => {
369          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 is failed ' + err.code);
370          expect(err.code).assertEqual(1)
371          done();
372        })
373      } catch (err) {
374        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 catch' + err.code);
375        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 catch' + err.message);
376        expect().assertFail();
377        done();
378      }
379      await sleep(1000);
380      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1600 is end---------------");
381    });
382
383    /*
384    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200
385    * @tc.name    StartRemoteAbilityForResult bundleName is undefined
386    * @tc.desc    Function test
387    * @tc.level   0
388    */
389    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200", 0, async function (done) {
390      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 is start---------------");
391      try {
392        featureAbility.startAbilityForResult({
393          "want": {
394            deviceId: dvId,
395            bundleName: undefined,
396            abilityName: "MainAbility2",
397            parameters: {
398              startReason: "terminateSelfWithResult"
399            }
400          }
401        }).then((data) => {
402          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 data is' + data.resultCode);
403          expect().assertFail();
404          done();
405        }).catch((err) => {
406          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 is failed ' + err.code);
407          expect(err.code).assertEqual(1)
408          done();
409        })
410      } catch (err) {
411        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 catch' + err.code);
412        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 catch' + err.message);
413        expect().assertFail();
414        done();
415      }
416      await sleep(1000);
417      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2200 is end---------------");
418    });
419
420    /*
421    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400
422    * @tc.name    StartRemoteAbilityForResult bundleName is err
423    * @tc.desc    Function test
424    * @tc.level   0
425    */
426    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400", 0, async function (done) {
427      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 is start---------------");
428      try {
429        featureAbility.startAbilityForResult({
430          "want": {
431            deviceId: dvId,
432            bundleName: "com.acts.example",
433            abilityName: "MainAbility2",
434            parameters: {
435              startReason: "terminateSelfWithResult"
436            }
437          }
438        }).then((data) => {
439          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 data is' + data.resultCode);
440          expect().assertFail();
441          done();
442        }).catch((err) => {
443          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 is failed ' + err.code);
444          expect(err.code).assertEqual(9)
445          done();
446        })
447      } catch (err) {
448        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 catch' + err.code);
449        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 catch' + err.message);
450        expect().assertFail();
451        done();
452      }
453      await sleep(1000);
454      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2400 is end---------------");
455    });
456
457    /*
458    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000
459    * @tc.name    StartRemoteAbilityForResult abilityName is null
460    * @tc.desc    Function test
461    * @tc.level   0
462    */
463    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000", 0, async function (done) {
464      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 is start---------------");
465      try {
466        featureAbility.startAbilityForResult({
467          "want": {
468            deviceId: dvId,
469            bundleName: "com.acts.example.dmsfwkstageserver",
470            abilityName: "",
471            parameters: {
472              startReason: "terminateSelfWithResult"
473            }
474          }
475        }).then((data) => {
476          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 data is' + data.resultCode);
477          expect().assertFail();
478          done();
479        }).catch((err) => {
480          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 is failed ' + err.code);
481          expect(err.code).assertEqual(1)
482          done();
483        })
484      } catch (err) {
485        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 catch' + err.code);
486        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 catch' + err.message);
487        expect().assertFail();
488        done();
489      }
490      await sleep(1000);
491      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2000 is end---------------");
492    });
493
494    /*
495    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500
496    * @tc.name    StartRemoteAbilityForResult without abilityName
497    * @tc.desc    Function test
498    * @tc.level   0
499    */
500    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500", 0, async function (done) {
501      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 is start---------------");
502      try {
503        featureAbility.startAbilityForResult({
504          "want": {
505            deviceId: dvId,
506            bundleName: "com.acts.example.dmsfwkstageserver",
507            // abilityName: "MainAbility2",
508            parameters: {
509              startReason: "terminateSelfWithResult"
510            }
511          }
512        }).then((data) => {
513          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 data is' + data.resultCode);
514          expect().assertFail();
515          done();
516        }).catch((err) => {
517          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 is failed ' + err.code);
518          expect(err.code).assertEqual(1)
519          done();
520        })
521      } catch (err) {
522        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 catch' + err.code);
523        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 catch' + err.message);
524        expect().assertFail();
525        done();
526      }
527      await sleep(1000);
528      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1500 is end---------------");
529    });
530
531    /*
532    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900
533    * @tc.name    StartRemoteAbilityForResult abilityName is undefined
534    * @tc.desc    Function test
535    * @tc.level   0
536    */
537    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900", 0, async function (done) {
538      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 is start---------------");
539      try {
540        featureAbility.startAbilityForResult({
541          "want": {
542            deviceId: dvId,
543            bundleName: 'com.acts.example.dmsfwkstageserver',
544            abilityName: undefined,
545            parameters: {
546              startReason: "terminateSelfWithResult"
547            }
548          }
549        }).then((data) => {
550          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 data is' + data.resultCode);
551          expect().assertFail();
552          done();
553        }).catch((err) => {
554          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 is failed ' + err.code);
555          expect(err.code).assertEqual(1)
556          done();
557        })
558      } catch (err) {
559        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 catch' + err.code);
560        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 catch' + err.message);
561        expect().assertFail();
562        done();
563      }
564      await sleep(1000);
565      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1900 is end---------------");
566    });
567
568    /*
569    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100
570    * @tc.name    StartRemoteAbilityForResult abilityName is err
571    * @tc.desc    Function test
572    * @tc.level   0
573    */
574    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100", 0, async function (done) {
575      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 is start---------------");
576      try {
577        featureAbility.startAbilityForResult({
578          "want": {
579            deviceId: dvId,
580            bundleName: "com.acts.example.dmsfwkstageserver",
581            abilityName: "123456",
582            parameters: {
583              startReason: "terminateSelfWithResult"
584            }
585          }
586        }).then((data) => {
587          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 data is' + data.resultCode);
588          expect().assertFail();
589          done();
590        }).catch((err) => {
591          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 is failed ' + err.code);
592          expect(err.code).assertEqual(9)
593          done();
594        })
595      } catch (err) {
596        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 catch' + err.code);
597        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 catch' + err.message);
598        expect().assertFail();
599        done();
600      }
601      await sleep(1000);
602      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_2100 is end---------------");
603    });
604
605    /*
606    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800
607    * @tc.name    StartRemoteAbilityForResult want is null
608    * @tc.desc    Function test
609    * @tc.level   0
610    */
611    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800", 0, async function (done) {
612      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 is start---------------");
613      try {
614        featureAbility.startAbilityForResult({
615          "want": {
616          }
617        }).then((data) => {
618          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 data is' + data.resultCode);
619          expect().assertFail();
620          done();
621        }).catch((err) => {
622          console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 is failed ' + err.code);
623          expect(err.code).assertEqual(1)
624          done();
625        })
626      } catch (err) {
627        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 catch' + err.code);
628        console.info('SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 catch' + err.message);
629        expect().assertFail();
630        done();
631      }
632      await sleep(1000);
633      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1800 is end---------------");
634    });
635
636    /*
637    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1400
638    * @tc.name    StartRemoteAbilityForResult remote MainAbility is success
639    * @tc.desc    Function test
640    * @tc.level   0
641    */
642    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1400", 0, async function (done) {
643      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1400 is start---------------");
644      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1400';
645      let wantValue = {
646        deviceId: dvId,
647        bundleName: "com.acts.example.dmsfwkstageserver",
648        abilityName: "MainAbility2",
649        parameters: {
650          startReason: "terminateSelfWithResult"
651        }
652      }
653      featureAbility.startAbilityForResult({
654        want: wantValue
655      }, (error, data) => {
656        try {
657          if (error && error.code !== 0) {
658            console.error(TAG + ' fail, error: ' + error.code);
659            expect().assertFail();
660          } else {
661            console.log(TAG + ' success, data: ' + JSON.stringify(data));
662            expect(data.resultCode).assertEqual(100);
663          }
664        } catch (error) {
665          console.info(TAG + ":error = " + error);
666          expect().assertFail();
667        }
668        done();
669      });
670      await sleep(1000);
671      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_1400 is end---------------");
672    });
673
674    /*
675    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0100
676    * @tc.name    StartRemoteAbilityForResult remote MainAbility is whitout abilityName
677    * @tc.desc    Function test
678    * @tc.level   0
679    */
680    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0100", 0, async function (done) {
681      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0100 is start---------------");
682      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0100';
683      let wantValue = {
684        deviceId: dvId,
685        bundleName: "com.acts.example.dmsfwkstageserver",
686        parameters: {
687          startReason: "terminateSelfWithResult"
688        }
689      }
690      featureAbility.startAbilityForResult({
691        want: wantValue
692      }, (error) => {
693        if (error && error.code !== 0) {
694          console.error(TAG + ' fail, error: ' + error.code);
695          expect(error.code).assertEqual(1);
696          done();
697        } else {
698          console.log(TAG + ' StartAbilityForResult_callback success');
699          expect().assertFail()
700          done();
701        }
702      });
703      await sleep(1000);
704      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0100 is end---------------");
705    });
706
707    /*
708    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0200
709    * @tc.name    StartRemoteAbilityForResult remote MainAbility is whitout bundleName
710    * @tc.desc    Function test
711    * @tc.level   0
712    */
713    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0200", 0, async function (done) {
714      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0200 is start---------------");
715      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0200';
716      let wantValue = {
717        deviceId: dvId,
718        abilityName: "MainAbility2",
719        parameters: {
720          startReason: "terminateSelfWithResult"
721        }
722      }
723      featureAbility.startAbilityForResult({
724        want: wantValue
725      }, (error) => {
726        if (error && error.code !== 0) {
727          console.error(TAG + ' fail, error: ' + error.code);
728          expect(error.code).assertEqual(1);
729          done();
730        } else {
731          console.log(TAG + ' StartAbilityForResult_callback success');
732          expect().assertFail()
733          done();
734        }
735      });
736      await sleep(1000);
737      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0200 is end---------------");
738    });
739
740    /*
741    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0300
742    * @tc.name    StartRemoteAbilityForResult remote MainAbility is whitout deviceId
743    * @tc.desc    Function test
744    * @tc.level   0
745    */
746    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0300", 0, async function (done) {
747      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0300 is start---------------");
748      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0300';
749      let wantValue = {
750        bundleName: "com.acts.example.dmsfwkstageserver",
751        abilityName: "MainAbility2",
752        parameters: {
753          startReason: "terminateSelfWithResult"
754        }
755      }
756      featureAbility.startAbilityForResult({
757        want: wantValue
758      }, (error) => {
759        if (error && error.code !== 0) {
760          console.error(TAG + ' fail, error: ' + error.code);
761          expect(error.code).assertEqual(1);
762          done();
763        } else {
764          console.log(TAG + ' StartAbilityForResult_callback success');
765          expect().assertFail()
766          done();
767        }
768      });
769      done();
770      await sleep(1000);
771      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0300 is end---------------");
772    });
773
774    /*
775    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0400
776    * @tc.name    StartRemoteAbilityForResult remote MainAbility want is null
777    * @tc.desc    Function test
778    * @tc.level   0
779    */
780    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0400", 0, async function (done) {
781      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0400 is start---------------");
782      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0400';
783      let wantValue = {
784      }
785      featureAbility.startAbilityForResult({
786        want: wantValue
787      }, (error) => {
788        if (error && error.code !== 0) {
789          console.error(TAG + ' fail, error: ' + error.code);
790          expect(error.code).assertEqual(1);
791        } else {
792          console.log(TAG + ' StartAbilityForResult_callback success');
793          expect().assertFail()
794        }
795      });
796      done();
797      await sleep(1000);
798      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0400 is end---------------");
799    });
800
801    /*
802    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0500
803    * @tc.name    StartRemoteAbilityForResult remote MainAbility abilityName is undefined
804    * @tc.desc    Function test
805    * @tc.level   0
806    */
807    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0500", 0, async function (done) {
808      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0500 is start---------------");
809      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0500';
810      let wantValue = {
811        deviceId: dvId,
812        bundleName: "com.acts.example.dmsfwkstageserver",
813        abilityName: undefined,
814        parameters: {
815          startReason: "terminateSelfWithResult"
816        }
817      }
818      featureAbility.startAbilityForResult({
819        want: wantValue
820      }, (error) => {
821        if (error && error.code !== 0) {
822          console.error(TAG + ' fail, error: ' + error.code);
823          expect(error.code).assertEqual(1);
824        } else {
825          console.log(TAG + ' StartAbilityForResult_callback success');
826          expect().assertFail()
827        }
828      });
829      done();
830      await sleep(1000);
831      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0500 is end---------------");
832    });
833
834    /*
835    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0600
836    * @tc.name    StartRemoteAbilityForResult remote MainAbility abilityName is null
837    * @tc.desc    Function test
838    * @tc.level   0
839    */
840    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0600", 0, async function (done) {
841      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0600 is start---------------");
842      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0600';
843      let wantValue = {
844        deviceId: dvId,
845        bundleName: "com.acts.example.dmsfwkstageserver",
846        abilityName: null,
847        parameters: {
848          startReason: "terminateSelfWithResult"
849        }
850      }
851      featureAbility.startAbilityForResult({
852        want: wantValue
853      }, (error) => {
854        if (error && error.code !== 0) {
855          console.error(TAG + ' fail, error: ' + error.code);
856          expect(error.code).assertEqual(1);
857        } else {
858          console.log(TAG + ' StartAbilityForResult_callback success');
859          expect().assertFail()
860        }
861      });
862      done();
863      await sleep(1000);
864      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0600 is end---------------");
865    });
866
867    /*
868    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0700
869    * @tc.name    StartRemoteAbilityForResult remote MainAbility abilityName is err
870    * @tc.desc    Function test
871    * @tc.level   0
872    */
873    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0700", 0, async function (done) {
874      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0700 is start---------------");
875      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0700';
876      let wantValue = {
877        deviceId: dvId,
878        bundleName: "com.acts.example.dmsfwkstageserver",
879        abilityName: 's1234wersds',
880        parameters: {
881          startReason: "terminateSelfWithResult"
882        }
883      }
884      featureAbility.startAbilityForResult({
885        want: wantValue
886      }, (error) => {
887        if (error && error.code !== 0) {
888          console.error(TAG + ' fail, error: ' + error.code);
889          expect(error.code).assertEqual(9);
890        } else {
891          console.log(TAG + ' StartAbilityForResult_callback success');
892          expect().assertFail()
893        }
894      });
895      done();
896      await sleep(1000);
897      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0700 is end---------------");
898    });
899
900    /*
901    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0800
902    * @tc.name    StartRemoteAbilityForResult remote MainAbility bundleName is undefined
903    * @tc.desc    Function test
904    * @tc.level   0
905    */
906    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0800", 0, async function (done) {
907      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0800 is start---------------");
908      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0800';
909      let wantValue = {
910        deviceId: dvId,
911        bundleName: undefined,
912        abilityName: "MainAbility2",
913        parameters: {
914          startReason: "terminateSelfWithResult"
915        }
916      }
917      featureAbility.startAbilityForResult({
918        want: wantValue
919      }, (error) => {
920        if (error && error.code !== 0) {
921          console.error(TAG + ' fail, error: ' + error.code);
922          expect(error.code).assertEqual(1);
923        } else {
924          console.log(TAG + ' StartAbilityForResult_callback success');
925          expect().assertFail()
926        }
927      });
928      done();
929      await sleep(1000);
930      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0800 is end---------------");
931    });
932
933    /*
934    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0900
935    * @tc.name    StartRemoteAbilityForResult remote MainAbility bundleName is null
936    * @tc.desc    Function test
937    * @tc.level   0
938    */
939    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0900", 0, async function (done) {
940      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0900 is start---------------");
941      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0900';
942      let wantValue = {
943        deviceId: dvId,
944        bundleName: undefined,
945        abilityName: "MainAbility2",
946        parameters: {
947          startReason: "terminateSelfWithResult"
948        }
949      }
950      featureAbility.startAbilityForResult({
951        want: wantValue
952      }, (error) => {
953        if (error && error.code !== 0) {
954          console.error(TAG + ' fail, error: ' + error.code);
955          expect(error.code).assertEqual(1);
956        } else {
957          console.log(TAG + ' StartAbilityForResult_callback success');
958          expect().assertFail()
959        }
960      });
961      done();
962      await sleep(1000);
963      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_0900 is end---------------");
964    });
965
966    /*
967    * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1000
968    * @tc.name    StartRemoteAbilityForResult remote MainAbility bundleName is err
969    * @tc.desc    Function test
970    * @tc.level   0
971    */
972    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1000", 0, async function (done) {
973      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1000 is start---------------");
974      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1000';
975      let wantValue = {
976        deviceId: dvId,
977        bundleName: "123456789x.",
978        abilityName: "MainAbility2",
979        parameters: {
980          startReason: "terminateSelfWithResult"
981        }
982      }
983      featureAbility.startAbilityForResult({
984        want: wantValue
985      }, (error) => {
986        if (error && error.code !== 0) {
987          console.error(TAG + ' fail, error: ' + error.code);
988          expect(error.code).assertEqual(9);
989        } else {
990          console.log(TAG + ' StartAbilityForResult_callback success');
991          expect().assertFail()
992        }
993      });
994      done();
995      await sleep(1000);
996      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1000 is end---------------");
997    });
998
999    /*
1000     * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1100
1001     * @tc.name    StartRemoteAbilityForResult remote MainAbility deviceId is undefined
1002     * @tc.desc    Function test
1003     * @tc.level   0
1004     */
1005    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1100", 0, async function (done) {
1006      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1100 is start---------------");
1007      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1100';
1008      let wantValue = {
1009        deviceId: undefined,
1010        bundleName: "com.acts.example.dmsfwkstageserver",
1011        abilityName: "MainAbility2",
1012        parameters: {
1013          startReason: "terminateSelfWithResult"
1014        }
1015      }
1016      featureAbility.startAbilityForResult({
1017        want: wantValue
1018      }, (error) => {
1019        if (error && error.code !== 0) {
1020          console.error(TAG + ' fail, error: ' + error.code);
1021          expect(error.code).assertEqual(1);
1022        } else {
1023          console.log(TAG + ' StartAbilityForResult_callback success');
1024          expect().assertFail()
1025        }
1026      });
1027      done();
1028      await sleep(1000);
1029      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1100 is end---------------");
1030    });
1031
1032    /*
1033     * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1200
1034     * @tc.name    StartRemoteAbilityForResult remote MainAbility deviceId is null
1035     * @tc.desc    Function test
1036     * @tc.level   0
1037     */
1038    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1200", 0, async function (done) {
1039      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1200 is start---------------");
1040      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1200';
1041      let wantValue = {
1042        deviceId: "",
1043        bundleName: "com.acts.example.dmsfwkstageserver",
1044        abilityName: "MainAbility2",
1045        parameters: {
1046          startReason: "terminateSelfWithResult"
1047        }
1048      }
1049      featureAbility.startAbilityForResult({
1050        want: wantValue
1051      }, (error) => {
1052        if (error && error.code !== 0) {
1053          console.error(TAG + ' fail, error: ' + error.code);
1054          expect(error.code).assertEqual(1);
1055        } else {
1056          console.log(TAG + ' StartAbilityForResult_callback success');
1057          expect().assertFail()
1058        }
1059      });
1060      done();
1061      await sleep(1000);
1062      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1200 is end---------------");
1063    });
1064
1065    /*
1066     * @tc.number  SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1300
1067     * @tc.name    StartRemoteAbilityForResult remote MainAbility deviceId is err
1068     * @tc.desc    Function test
1069     * @tc.level   0
1070     */
1071    it("SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1300", 0, async function (done) {
1072      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1300 is start---------------");
1073      let TAG = 'SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1300';
1074      let wantValue = {
1075        deviceId: "123456789c.",
1076        bundleName: "com.acts.example.dmsfwkstageserver",
1077        abilityName: "MainAbility2",
1078        parameters: {
1079          startReason: "terminateSelfWithResult"
1080        }
1081      }
1082      featureAbility.startAbilityForResult({
1083        want: wantValue
1084      }, (error) => {
1085        if (error && error.code !== 0) {
1086          console.error(TAG + ' fail, error: ' + error.code);
1087          expect(error.code).assertEqual(9);
1088        } else {
1089          console.log(TAG + ' StartAbilityForResult_callback success');
1090          expect().assertFail()
1091        }
1092      });
1093      done();
1094      await sleep(1000);
1095      console.info("---------------SUB_DMS_StandardOs_collaboration_Startability_StartAbilityForResult_callback_1300 is end---------------");
1096    });
1097
1098    /*
1099     * @tc.number  SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300
1100     * @tc.name    Connect the remote ServiceAbility.
1101     * @tc.desc    Function test
1102     * @tc.level   0
1103     */
1104    it("SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300", 0, async function (done) {
1105      console.info("-----------------SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300 start------------------------");
1106      let connectId;
1107      try {
1108        connectId = featureAbility.connectAbility({
1109          deviceId: dvId,
1110          bundleName: "com.acts.example.dmsfwkstageserver",
1111          abilityName: "ServiceAbility"
1112        }, {
1113          onConnect: (elementName, proxy) => {
1114            let option = new rpc.MessageOption();
1115            let data = new rpc.MessageParcel();
1116            let reply = new rpc.MessageParcel();
1117            data.writeInt(1);
1118            data.writeInt(99);
1119            proxy.sendRequest(1, data, reply, option).then((result) => {
1120              console.log('sendRequest success');
1121              let msg = result.reply.readInt();
1122              console.info(' SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300 msg: ' + msg)
1123              expect(msg == 100).assertTrue();
1124
1125            }).catch((e) => {
1126              console.log('sendRequest error:' + e);
1127              expect().assertFail();
1128
1129            });
1130          },
1131          onDisConnect: (elementName) => {
1132            console.info('SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300  onDisConnect: ' + JSON.stringify(elementName));
1133            expect().assertFail();
1134
1135          },
1136          onFailed: (code) => {
1137            console.info('SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300  onFailed: ' + code);
1138            expect().assertFail();
1139
1140          }
1141        });
1142      } catch (err) {
1143        console.info('SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300 catch: ' + err.code);
1144        console.info('SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300 catch: ' + err.message);
1145        expect().assertFail();
1146
1147      }
1148      await sleep(1000);
1149      done();
1150      console.info("-----------------SUB_DMS_StandardOs_collaboration_connetability_connectRemoteAbility_1300 end------------------------");
1151    });
1152
1153    /*
1154     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200
1155     * @tc.name    Connect the remote Service with null bundlename.
1156     * @tc.desc    Function test
1157     * @tc.level   0
1158     */
1159    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200", 0, async function (done) {
1160      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 start------------------------");
1161      let connectId;
1162      try {
1163        connectId = featureAbility.connectAbility({
1164          deviceId: dvId,
1165          bundleName: "",
1166          abilityName: "ServiceAbility"
1167        }, {
1168          onConnect: (elementName, proxy) => {
1169            let option = new rpc.MessageOption();
1170            let data = new rpc.MessageParcel();
1171            let reply = new rpc.MessageParcel();
1172            data.writeInt(1);
1173            data.writeInt(99);
1174            proxy.sendRequest(1, data, reply, option).then((result) => {
1175              console.log('sendRequest success');
1176              let msg = result.reply.readInt();
1177              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 msg: ' + msg)
1178              expect(msg == 100).assertFail();
1179              done();
1180            }).catch((e) => {
1181              console.log('sendRequest error:' + e);
1182              expect().assertFail();
1183              done();
1184            });
1185          },
1186          onDisConnect: (elementName) => {
1187            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200  onDisConnect: ' + JSON.stringify(elementName));
1188            expect().assertFail();
1189            done();
1190          },
1191          onFailed: (code) => {
1192            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200  onFailed: ' + code);
1193            expect(code).assertEqual(0);
1194            done();
1195          }
1196        });
1197      } catch (err) {
1198        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 catch: ' + err.code);
1199        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 catch: ' + err.message);
1200        expect().assertFail();
1201        done();
1202      }
1203      await sleep(1000);
1204      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 end------------------------");
1205    });
1206
1207    /*
1208     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900
1209     * @tc.name    Disconnect the remote ServiceAbility.
1210     * @tc.desc    Function test
1211     * @tc.level   0
1212     */
1213    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900", 0, async function (done) {
1214      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 start------------------------");
1215      let connectId;
1216      try {
1217        connectId = featureAbility.connectAbility({
1218          deviceId: dvId,
1219          bundleName: "com.acts.example.dmsfwkstageserver",
1220          abilityName: "ServiceAbility"
1221        }, {
1222          onConnect: (elementName, proxy) => {
1223            let option = new rpc.MessageOption();
1224            let data = new rpc.MessageParcel();
1225            let reply = new rpc.MessageParcel();
1226            data.writeInt(1);
1227            data.writeInt(99);
1228            proxy.sendRequest(1, data, reply, option).then((result) => {
1229              console.log('sendRequest success');
1230              let msg = result.reply.readInt();
1231              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 msg: ' + msg)
1232              expect(msg == 100).assertTrue();
1233            }).catch((e) => {
1234              console.log('sendRequest error:' + e);
1235              expect().assertFail();
1236              done();
1237            });
1238          },
1239          onDisConnect: (elementName) => {
1240            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900  onDisConnect: ' + JSON.stringify(elementName));
1241            expect().assertFail();
1242            done();
1243          },
1244          onFailed: (code) => {
1245            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900  onFailed: ' + code);
1246            expect().assertFail();
1247            done();
1248          }
1249        });
1250      } catch (err) {
1251        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 catch: ' + err.code);
1252        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 catch: ' + err.message);
1253        expect().assertFail();
1254        done();
1255      }
1256      featureAbility.disconnectAbility(connectId, (err, data) => {
1257        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 disconnectAbility err: ' + err.code);
1258        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 disconnectAbilityerr: ' + err.message);
1259        expect(err.code).assertEqual(0);
1260        done();
1261      })
1262      await sleep(1000);
1263      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_1900 end------------------------");
1264    });
1265
1266    /*
1267     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100
1268     * @tc.name    Connect the remote Service with Wrong ServiceAbility.
1269     * @tc.desc    Function test
1270     * @tc.level   0
1271     */
1272    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100", 0, async function (done) {
1273      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 start------------------------");
1274      let connectId;
1275      try {
1276        connectId = featureAbility.connectAbility({
1277          deviceId: dvId,
1278          bundleName: "com.acts.example.dmsfwkstageserver",
1279          abilityName: "WrongServiceAbility"
1280        }, {
1281          onConnect: (elementName, proxy) => {
1282            let option = new rpc.MessageOption();
1283            let data = new rpc.MessageParcel();
1284            let reply = new rpc.MessageParcel();
1285            data.writeInt(1);
1286            data.writeInt(99);
1287            proxy.sendRequest(1, data, reply, option).then((result) => {
1288              console.log('sendRequest success');
1289              let msg = result.reply.readInt();
1290              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 msg: ' + msg)
1291              expect(msg == 100).assertFail();
1292              done();
1293            }).catch((e) => {
1294              console.log('sendRequest error:' + e);
1295              expect().assertFail();
1296              done();
1297            });
1298          },
1299          onDisConnect: (elementName) => {
1300            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100  onDisConnect: ' + JSON.stringify(elementName));
1301            expect().assertFail();
1302            done();
1303          },
1304          onFailed: (code) => {
1305            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100  onFailed: ' + code);
1306            expect(code).assertEqual(0);
1307            done();
1308          }
1309        });
1310      } catch (err) {
1311        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 catch: ' + err.code);
1312        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 catch: ' + err.message);
1313        expect().assertFail();
1314        done();
1315      }
1316      await sleep(1000);
1317      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 end------------------------");
1318    });
1319
1320    /*
1321     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800
1322     * @tc.name    Connect the remote Service with Wrong deviceId.
1323     * @tc.desc    Function test
1324     * @tc.level   0
1325     */
1326    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800", 0, async function (done) {
1327      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800 start------------------------");
1328      let connectId;
1329      try {
1330        connectId = featureAbility.connectAbility({
1331          deviceId: "123456",
1332          bundleName: "com.acts.example.dmsfwkstageserver",
1333          abilityName: "ServiceAbility"
1334        }, {
1335          onConnect: (elementName, proxy) => {
1336            let option = new rpc.MessageOption();
1337            let data = new rpc.MessageParcel();
1338            let reply = new rpc.MessageParcel();
1339            data.writeInt(1);
1340            data.writeInt(99);
1341            proxy.sendRequest(1, data, reply, option).then((result) => {
1342              console.log('sendRequest success');
1343              let msg = result.reply.readInt();
1344              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800 msg: ' + msg)
1345              expect(msg == 100).assertFail();
1346              done();
1347            }).catch((e) => {
1348              console.log('sendRequest error:' + e);
1349              expect().assertFail();
1350              done();
1351            });
1352          },
1353          onDisConnect: (elementName) => {
1354            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800  onDisConnect: ' + JSON.stringify(elementName));
1355            expect().assertFail();
1356            done();
1357          },
1358          onFailed: (code) => {
1359            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800  onFailed: ' + code);
1360            expect(code).assertEqual(0);
1361            done();
1362          }
1363        });
1364      } catch (err) {
1365        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800 catch: ' + err.code);
1366        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800 catch: ' + err.message);
1367        expect().assertFail();
1368        done();
1369      }
1370      await sleep(1000);
1371      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0800 end------------------------");
1372    });
1373
1374    /*
1375     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600
1376     * @tc.name    Connect the remote Service with null ServiceAbility.
1377     * @tc.desc    Function test
1378     * @tc.level   0
1379     */
1380    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600", 0, async function (done) {
1381      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600 start------------------------");
1382      let connectId;
1383      try {
1384        connectId = featureAbility.connectAbility({
1385          deviceId: dvId,
1386          bundleName: "com.acts.example.dmsfwkstageserver",
1387          abilityName: ""
1388        }, {
1389          onConnect: (elementName, proxy) => {
1390            let option = new rpc.MessageOption();
1391            let data = new rpc.MessageParcel();
1392            let reply = new rpc.MessageParcel();
1393            data.writeInt(1);
1394            data.writeInt(99);
1395            proxy.sendRequest(1, data, reply, option).then((result) => {
1396              console.log('sendRequest success');
1397              let msg = result.reply.readInt();
1398              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600 msg: ' + msg)
1399              expect(msg == 100).assertFail();
1400              done();
1401            }).catch((e) => {
1402              console.log('sendRequest error:' + e);
1403              expect().assertFail();
1404              done();
1405            });
1406          },
1407          onDisConnect: (elementName) => {
1408            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600  onDisConnect: ' + JSON.stringify(elementName));
1409            expect().assertFail();
1410            done();
1411          },
1412          onFailed: (code) => {
1413            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600  onFailed: ' + code);
1414            expect(code).assertEqual(0);
1415            done();
1416          }
1417        });
1418      } catch (err) {
1419        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600 catch: ' + err.code);
1420        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600 catch: ' + err.message);
1421        expect().assertFail();
1422        done();
1423      }
1424      await sleep(1000);
1425      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2600 end------------------------");
1426    });
1427
1428    /*
1429     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200
1430     * @tc.name    Connect the remote Service without bundleName.
1431     * @tc.desc    Function test
1432     * @tc.level   0
1433     */
1434    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200", 0, async function (done) {
1435      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 start------------------------");
1436      let connectId;
1437      try {
1438        connectId = featureAbility.connectAbility({
1439          deviceId: dvId,
1440          abilityName: "ServiceAbility"
1441        }, {
1442          onConnect: (elementName, proxy) => {
1443            let option = new rpc.MessageOption();
1444            let data = new rpc.MessageParcel();
1445            let reply = new rpc.MessageParcel();
1446            data.writeInt(1);
1447            data.writeInt(99);
1448            proxy.sendRequest(1, data, reply, option).then((result) => {
1449              console.log('sendRequest success');
1450              let msg = result.reply.readInt();
1451              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 msg: ' + msg)
1452              expect(msg == 100).assertFail();
1453              done();
1454            }).catch((e) => {
1455              console.log('sendRequest error:' + e);
1456              expect().assertFail();
1457              done();
1458            });
1459          },
1460          onDisConnect: (elementName) => {
1461            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200  onDisConnect: ' + JSON.stringify(elementName));
1462            expect().assertFail();
1463            done();
1464          },
1465          onFailed: (code) => {
1466            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200  onFailed: ' + code);
1467            expect(code).assertEqual(0);
1468            done();
1469          }
1470        });
1471      } catch (err) {
1472        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 catch: ' + err.code);
1473        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 catch: ' + err.message);
1474        expect().assertFail();
1475        done();
1476      }
1477      await sleep(1000);
1478      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0200 end------------------------");
1479    });
1480
1481    /*
1482     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700
1483     * @tc.name    Connect the remote Service with wrong bundleName.
1484     * @tc.desc    Function test
1485     * @tc.level   0
1486     */
1487    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700", 0, async function (done) {
1488      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700 start------------------------");
1489      let connectId;
1490      try {
1491        connectId = featureAbility.connectAbility({
1492          deviceId: dvId,
1493          bundleName: "com.acts.example.Wrongdmsfwkstageserver",
1494          abilityName: "ServiceAbility"
1495        }, {
1496          onConnect: (elementName, proxy) => {
1497            let option = new rpc.MessageOption();
1498            let data = new rpc.MessageParcel();
1499            let reply = new rpc.MessageParcel();
1500            data.writeInt(1);
1501            data.writeInt(99);
1502            proxy.sendRequest(1, data, reply, option).then((result) => {
1503              console.log('sendRequest success');
1504              let msg = result.reply.readInt();
1505              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700 msg: ' + msg)
1506              expect(msg == 100).assertFail();
1507              done();
1508            }).catch((e) => {
1509              console.log('sendRequest error:' + e);
1510              expect().assertFail();
1511              done();
1512            });
1513          },
1514          onDisConnect: (elementName) => {
1515            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700  onDisConnect: ' + JSON.stringify(elementName));
1516            expect().assertFail();
1517            done();
1518          },
1519          onFailed: (code) => {
1520            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700  onFailed: ' + code);
1521            expect(code).assertEqual(0);
1522            done();
1523          }
1524        });
1525      } catch (err) {
1526        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700 catch: ' + err.code);
1527        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700 catch: ' + err.message);
1528        expect().assertFail();
1529        done();
1530      }
1531      await sleep(1000);
1532      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0700 end------------------------");
1533    });
1534
1535    /*
1536     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700
1537     * @tc.name    Connect the remote Service with bundleName is undefined.
1538     * @tc.desc    Function test
1539     * @tc.level   0
1540     */
1541    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700", 0, async function (done) {
1542      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700 start------------------------");
1543      let connectId;
1544      try {
1545        connectId = featureAbility.connectAbility({
1546          deviceId: dvId,
1547          bundleName: undefined,
1548          abilityName: "ServiceAbility"
1549        }, {
1550          onConnect: (elementName, proxy) => {
1551            let option = new rpc.MessageOption();
1552            let data = new rpc.MessageParcel();
1553            let reply = new rpc.MessageParcel();
1554            data.writeInt(1);
1555            data.writeInt(99);
1556            proxy.sendRequest(1, data, reply, option).then((result) => {
1557              console.log('sendRequest success');
1558              let msg = result.reply.readInt();
1559              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700 msg: ' + msg)
1560              expect(msg == 100).assertFail();
1561              done();
1562            }).catch((e) => {
1563              console.log('sendRequest error:' + e);
1564              expect().assertFail();
1565              done();
1566            });
1567          },
1568          onDisConnect: (elementName) => {
1569            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700  onDisConnect: ' + JSON.stringify(elementName));
1570            expect().assertFail();
1571            done();
1572          },
1573          onFailed: (code) => {
1574            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700  onFailed: ' + code);
1575            expect(code).assertEqual(0);
1576            done();
1577          }
1578        });
1579      } catch (err) {
1580        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700 catch: ' + err.code);
1581        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700 catch: ' + err.message);
1582        expect().assertFail();
1583        done();
1584      }
1585      await sleep(1000);
1586      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2700 end------------------------");
1587    });
1588
1589    /*
1590     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100
1591     * @tc.name    Connect the remote Service without abilityName.
1592     * @tc.desc    Function test
1593     * @tc.level   0
1594     */
1595    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100", 0, async function (done) {
1596      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 start------------------------");
1597      let connectId;
1598      try {
1599        connectId = featureAbility.connectAbility({
1600          deviceId: dvId,
1601          bundleName: "com.acts.example.dmsfwkstageserver"
1602        }, {
1603          onConnect: (elementName, proxy) => {
1604            let option = new rpc.MessageOption();
1605            let data = new rpc.MessageParcel();
1606            let reply = new rpc.MessageParcel();
1607            data.writeInt(1);
1608            data.writeInt(99);
1609            proxy.sendRequest(1, data, reply, option).then((result) => {
1610              console.log('sendRequest success');
1611              let msg = result.reply.readInt();
1612              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 msg: ' + msg)
1613              expect(msg == 100).assertFail();
1614              done();
1615            }).catch((e) => {
1616              console.log('sendRequest error:' + e);
1617              expect().assertFail();
1618              done();
1619            });
1620          },
1621          onDisConnect: (elementName) => {
1622            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100  onDisConnect: ' + JSON.stringify(elementName));
1623            expect().assertFail();
1624            done();
1625          },
1626          onFailed: (code) => {
1627            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100  onFailed: ' + code);
1628            expect(code).assertEqual(0);
1629            done();
1630          }
1631        });
1632      } catch (err) {
1633        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 catch: ' + err.code);
1634        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 catch: ' + err.message);
1635        expect().assertFail();
1636        done();
1637      }
1638      await sleep(1000);
1639      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0100 end------------------------");
1640    });
1641
1642    /*
1643     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800
1644     * @tc.name    Connect the remote Service with abilityName is undefined.
1645     * @tc.desc    Function test
1646     * @tc.level   0
1647     */
1648    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800", 0, async function (done) {
1649      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800 start------------------------");
1650      let connectId;
1651      try {
1652        connectId = featureAbility.connectAbility({
1653          deviceId: dvId,
1654          bundleName: "com.acts.example.dmsfwkstageserver",
1655          abilityName: undefined
1656        }, {
1657          onConnect: (elementName, proxy) => {
1658            let option = new rpc.MessageOption();
1659            let data = new rpc.MessageParcel();
1660            let reply = new rpc.MessageParcel();
1661            data.writeInt(1);
1662            data.writeInt(99);
1663            proxy.sendRequest(1, data, reply, option).then((result) => {
1664              console.log('sendRequest success');
1665              let msg = result.reply.readInt();
1666              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800 msg: ' + msg)
1667              expect(msg == 100).assertFail();
1668              done();
1669            }).catch((e) => {
1670              console.log('sendRequest error:' + e);
1671              expect().assertFail();
1672              done();
1673            });
1674          },
1675          onDisConnect: (elementName) => {
1676            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800  onDisConnect: ' + JSON.stringify(elementName));
1677            expect().assertFail();
1678            done();
1679          },
1680          onFailed: (code) => {
1681            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800  onFailed: ' + code);
1682            expect(code).assertEqual(0);
1683            done();
1684          }
1685        });
1686      } catch (err) {
1687        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800 catch: ' + err.code);
1688        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800 catch: ' + err.message);
1689        expect().assertFail();
1690        done();
1691      }
1692      await sleep(1000);
1693      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2800 end------------------------");
1694    });
1695
1696    /*
1697    * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900
1698    * @tc.name    Connect the remote Service with deviceid is undefined.
1699    * @tc.desc    Function test
1700    * @tc.level   0
1701    */
1702    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900", 0, async function (done) {
1703      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900 start------------------------");
1704      let connectId;
1705      try {
1706        connectId = featureAbility.connectAbility({
1707          deviceId: undefined,
1708          bundleName: "com.acts.example.dmsfwkstageserver",
1709          abilityName: "ServiceAbility"
1710        }, {
1711          onConnect: (elementName, proxy) => {
1712            let option = new rpc.MessageOption();
1713            let data = new rpc.MessageParcel();
1714            let reply = new rpc.MessageParcel();
1715            data.writeInt(1);
1716            data.writeInt(99);
1717            proxy.sendRequest(1, data, reply, option).then((result) => {
1718              console.log('sendRequest success');
1719              let msg = result.reply.readInt();
1720              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900 msg: ' + msg)
1721              expect(msg == 100).assertFail();
1722              done();
1723            }).catch((e) => {
1724              console.log('sendRequest error:' + e);
1725              expect().assertFail();
1726              done();
1727            });
1728          },
1729          onDisConnect: (elementName) => {
1730            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900  onDisConnect: ' + JSON.stringify(elementName));
1731            expect().assertFail();
1732            done();
1733          },
1734          onFailed: (code) => {
1735            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900  onFailed: ' + code);
1736            expect(code).assertEqual(0);
1737            done();
1738          }
1739        });
1740      } catch (err) {
1741        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900 catch: ' + err.code);
1742        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900 catch: ' + err.message);
1743        expect().assertFail();
1744        done();
1745      }
1746      await sleep(1000);
1747      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_2900 end------------------------");
1748    });
1749
1750    /*
1751    * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300
1752    * @tc.name    Connect the remote Service without deviceid.
1753    * @tc.desc    Function test
1754    * @tc.level   0
1755    */
1756    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300", 0, async function (done) {
1757      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300 start------------------------");
1758      let connectId;
1759      try {
1760        connectId = featureAbility.connectAbility({
1761          bundleName: "com.acts.example.dmsfwkstageserver",
1762          abilityName: "ServiceAbility"
1763        }, {
1764          onConnect: (elementName, proxy) => {
1765            let option = new rpc.MessageOption();
1766            let data = new rpc.MessageParcel();
1767            let reply = new rpc.MessageParcel();
1768            data.writeInt(1);
1769            data.writeInt(99);
1770            proxy.sendRequest(1, data, reply, option).then((result) => {
1771              console.log('sendRequest success');
1772              let msg = result.reply.readInt();
1773              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300 msg: ' + msg)
1774              expect(msg == 100).assertFail();
1775              done();
1776            }).catch((e) => {
1777              console.log('sendRequest error:' + e);
1778              expect().assertFail();
1779              done();
1780            });
1781          },
1782          onDisConnect: (elementName) => {
1783            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300  onDisConnect: ' + JSON.stringify(elementName));
1784            expect().assertFail();
1785            done();
1786          },
1787          onFailed: (code) => {
1788            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300  onFailed: ' + code);
1789            expect(code).assertEqual(0);
1790            done();
1791          }
1792        });
1793      } catch (err) {
1794        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300 catch: ' + err.code);
1795        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300 catch: ' + err.message);
1796        expect().assertFail();
1797        done();
1798      }
1799      await sleep(1000);
1800      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0300 end------------------------");
1801    });
1802
1803    /*
1804     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400
1805     * @tc.name    Connect the remote ServiceAbility deviceId is localDeviceId.
1806     * @tc.desc    Function test
1807     * @tc.level   0
1808     */
1809    it("SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400", 0, async function (done) {
1810      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 start------------------------");
1811      let connectId;
1812      try {
1813        connectId = featureAbility.connectAbility({
1814          deviceId: localDeviceId,
1815          bundleName: "com.acts.example.dmsfwkstageserver",
1816          abilityName: "ServiceAbility"
1817        }, {
1818          onConnect: (elementName, proxy) => {
1819            let option = new rpc.MessageOption();
1820            let data = new rpc.MessageParcel();
1821            let reply = new rpc.MessageParcel();
1822            data.writeInt(1);
1823            data.writeInt(99);
1824            proxy.sendRequest(1, data, reply, option).then((result) => {
1825              console.log('sendRequest success');
1826              let msg = result.reply.readInt();
1827              console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 msg: ' + msg)
1828              expect(msg == 100).assertFail();
1829              done();
1830            }).catch((e) => {
1831              console.log('sendRequest error:' + e);
1832              expect().assertFail();
1833              done();
1834            });
1835          },
1836          onDisConnect: (elementName) => {
1837            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 onDisConnect: ' + JSON.stringify(elementName));
1838            expect().assertFail();
1839            done();
1840          },
1841          onFailed: (code) => {
1842            console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 onFailed: ' + code);
1843            expect(code == 0).assertTrue();
1844            done();
1845          }
1846        });
1847      } catch (err) {
1848        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 catch: ' + err.code);
1849        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 catch: ' + err.message);
1850        expect().assertFail();
1851        done();
1852      }
1853      done()
1854      await sleep(1000);
1855      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0400 end------------------------");
1856    });
1857
1858    /*
1859     * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500
1860     * @tc.name    Connect the remote ServiceAbility Twices.
1861     * @tc.desc    Function test
1862     * @tc.level   0
1863     */
1864    it('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500', 0, async function (done) {
1865      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 start------------------------");
1866      let request = {
1867        deviceId: dvId,
1868        bundleName: "com.acts.example.dmsfwkstageserver",
1869        abilityName: "ServiceAbility"
1870      };
1871      let options = {
1872        onConnect: (elementName, proxy) => {
1873          let option = new rpc.MessageOption();
1874          let data = new rpc.MessageParcel();
1875          let reply = new rpc.MessageParcel();
1876          data.writeInt(1);
1877          data.writeInt(99);
1878          proxy.sendRequest(1, data, reply, option).then((result) => {
1879            console.log('sendRequest success');
1880            let msg = result.reply.readInt();
1881            console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 msg: ' + msg)
1882            expect(msg == 100).assertTrue();
1883            done();
1884          }).catch((e) => {
1885            console.log('sendRequest error:' + e);
1886            expect().assertFail();
1887            done();
1888          });
1889        },
1890        onDisConnect: (elementName) => {
1891          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500  onDisConnect: ' + JSON.stringify(elementName));
1892          expect().assertFail();
1893          done();
1894        },
1895        onFailed: (code) => {
1896          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500  onFailed: ' + code);
1897          expect().assertFail();
1898          done();
1899        }
1900      };
1901      connectId = featureAbility.connectAbility(request, options);
1902      await sleep(1000)
1903      let request1 = {
1904        deviceId: dvId,
1905        bundleName: "com.acts.example.dmsfwkstageserver",
1906        abilityName: "ServiceAbility"
1907      };
1908      let options1 = {
1909        onConnect: (elementName, proxy) => {
1910          let option = new rpc.MessageOption();
1911          let data = new rpc.MessageParcel();
1912          let reply = new rpc.MessageParcel();
1913          data.writeInt(1);
1914          data.writeInt(99);
1915          proxy.sendRequest(1, data, reply, option).then((result) => {
1916            console.log('sendRequest success');
1917            let msg = result.reply.readInt();
1918            console.info(' SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 msg1: ' + msg)
1919            expect(msg == 100).assertTrue();
1920            done();
1921          }).catch((e) => {
1922            console.log('sendRequest error:' + e);
1923            expect().assertFail();
1924            done();
1925          });
1926        },
1927        onDisConnect: (elementName) => {
1928          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500  onDisConnect: ' + JSON.stringify(elementName));
1929          expect().assertFail();
1930          done();
1931        },
1932        onFailed: (code) => {
1933          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500  onFailed: ' + code);
1934          expect().assertFail();
1935          done();
1936        }
1937      };
1938      connectId1 = featureAbility.connectAbility(request1, options1);
1939      await sleep(1000)
1940      featureAbility.disconnectAbility(connectId, (err, data) => {
1941        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 disconnectAbility err: ' + err.code);
1942        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 disconnectAbilityerr: ' + err.message);
1943        expect(err.code).assertEqual(0);
1944        done();
1945      });
1946      await sleep(1000)
1947      featureAbility.disconnectAbility(connectId1, (err, data) => {
1948        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 disconnectAbility err: ' + err.code);
1949        console.info('SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 disconnectAbilityerr: ' + err.message);
1950        expect(err.code).assertEqual(0);
1951        done();
1952      });
1953      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_connectRemoteAbility_0500 end------------------------");
1954    })
1955
1956    /*
1957    * @tc.number  SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600
1958    * @tc.name    Connect the remote ServiceAbility Twices.
1959    * @tc.desc    Function test
1960    * @tc.level   0
1961    */
1962    it('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600', 0, async function (done) {
1963      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 start------------------------");
1964      if (connectId && connectId1 == null) {
1965        console.log('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 disconnectAbility is failed')
1966      } else {
1967        featureAbility.disconnectAbility(connectId, (err) => {
1968          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 disconnectAbility err: ' + err.code);
1969          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 disconnectAbilityerr: ' + err.message);
1970          expect(err.code).assertEqual(0);
1971          done();
1972        });
1973        await sleep(1000)
1974        featureAbility.disconnectAbility(connectId1, (err) => {
1975          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 disconnectAbility err: ' + err.code);
1976          console.info('SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 disconnectAbilityerr: ' + err.message);
1977          expect(err.code).assertEqual(0);
1978          done();
1979        });
1980      }
1981      console.info("-----------------SUB_DMS_StandardOs_collaboration_connectAbility_disconnectAbility_0600 end------------------------");
1982    })
1983
1984    /*
1985    * @tc.number  SUB_DMS_StandardOs_stability_StabilityTest_0100
1986    * @tc.name    Connect the remote ServiceAbility fot ten times.
1987    * @tc.desc    Function test
1988    * @tc.level   0
1989    */
1990    it("SUB_DMS_StandardOs_stability_StabilityTest_0100", 0, async function (done) {
1991      console.info("-----------------SUB_DMS_StandardOs_stability_StabilityTest_0100 start------------------------");
1992      let connectId;
1993      try {
1994        for (let i = 0; i < 10; i++) {
1995          connectId = featureAbility.connectAbility({
1996            deviceId: dvId,
1997            bundleName: "com.acts.example.dmsfwkstageserver",
1998            abilityName: "ServiceAbility"
1999          }, {
2000            onConnect: (elementName, proxy) => {
2001              let option = new rpc.MessageOption();
2002              let data = new rpc.MessageParcel();
2003              let reply = new rpc.MessageParcel();
2004              data.writeInt(1);
2005              data.writeInt(99);
2006              proxy.sendRequest(1, data, reply, option).then((result) => {
2007                console.log('sendRequest success');
2008                let msg = result.reply.readInt();
2009                console.info(' SUB_DMS_StandardOs_stability_StabilityTest_0100 msg: ' + msg)
2010                expect(msg == 100).assertTrue();
2011                done();
2012              }).catch((e) => {
2013                console.log('sendRequest error:' + e);
2014                expect().assertFail();
2015                done();
2016              });
2017            },
2018            onDisConnect: (elementName) => {
2019              console.info('SUB_DMS_StandardOs_stability_StabilityTest_0100  onDisConnect: ' + JSON.stringify(elementName));
2020              expect().assertFail();
2021              done();
2022            },
2023            onFailed: (code) => {
2024              console.info('SUB_DMS_StandardOs_stability_StabilityTest_0100  onFailed: ' + code);
2025              expect().assertFail();
2026              done();
2027            }
2028          });
2029          featureAbility.disconnectAbility(connectId, (err, data) => {
2030            console.info('SUB_DMS_StandardOs_stability_StabilityTest_0100 disconnectAbility err: ' + err.code);
2031            console.info('SUB_DMS_StandardOs_stability_StabilityTest_0100 disconnectAbilityerr: ' + err.message);
2032            expect(err.code).assertEqual(0);
2033            done();
2034          })
2035          console.info("SUB_DMS_StandardOs_stability_StabilityTest_0100 running at : " + i + ",here");
2036        }
2037      } catch (err) {
2038        console.info('SUB_DMS_StandardOs_stability_StabilityTest_0100 catch: ' + err.code);
2039        console.info('SUB_DMS_ConnectAbilitySUB_DMS_StandardOs_stability_StabilityTest_0100_0140 catch: ' + err.message);
2040        expect().assertFail();
2041        done();
2042      }
2043      await sleep(1000);
2044      console.info("-----------------SUB_DMS_StandardOs_stability_StabilityTest_0100 end------------------------");
2045    });
2046  })
2047}