• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2024 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 */
15import { describe, it, expect, Level, Size, TestType } from '@ohos/hypium'
16import socket from "@ohos.net.socket";
17import { BusinessError, Callback } from '@ohos.base';
18
19
20function expectSuccess(): void {
21  try {
22    expect(true).assertTrue();
23  } catch (err) {
24    console.info(`${err} test failed`);
25  }
26
27}
28
29
30function expectFail(info: string = ''): void {
31  try {
32    expect(false).assertTrue();
33  } catch (err) {
34    console.info(`${info} test failed`);
35  }
36}
37
38
39function expectTrue(exp: boolean, info: string = ''): void {
40  try {
41    expect(exp).assertTrue();
42  } catch (err) {
43    console.info(`${info} test failed`);
44  }
45}
46
47function expectFalse(exp: boolean, info: string = ''): void {
48  try {
49    expect(exp).assertFalse();
50  } catch (err) {
51    console.info(`${info} test failed`);
52  }
53}
54
55function expectEqual(exp: string | number | boolean, assert: string | number | boolean, info: string = ''): void {
56  try {
57    expect(exp).assertEqual(assert);
58  } catch (err) {
59    console.info(`${info} test failed`);
60  }
61}
62
63
64export default function TCPSocketServerTest() {
65  describe('ActsTCPSocketServerTest', () => {
66
67    /* *
68    * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_ConstructTCPSocketServerInstance_0100
69    * @tc.name  : testNetworkMgrSocketTCPSocketServerConstructTCPSocketServerInstance0100
70    * @tc.desc  : Create a TCP Socket Server object; callback
71    * @tc.size  : MediumTest
72    * @tc.type  : Function
73    * @tc.level : level 0
74    */
75    it('testNetworkMgrSocketTCPSocketServerConstructTCPSocketServerInstance0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
76      let caseName: string = 'testNetworkMgrSocketTCPSocketServerConstructTCPSocketServerInstance0100';
77      try {
78        console.info(`${caseName} test start`);
79        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
80        console.info('testConstructTCPSocketInstance0100 success');
81        expect(tcpServer).assertInstanceOf('Object');
82        console.info(`${caseName} test end`);
83        done();
84      } catch (err) {
85        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
86        expectFail();
87        console.info(`${caseName} test end`);
88        done();
89      }
90    });
91
92    /* *
93    * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0100
94    * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0100
95    * @tc.desc  : Bind IP address and port,Only fill in the address for IPV4; callback
96    * @tc.size  : MediumTest
97    * @tc.type  : Function
98    * @tc.level : level 2
99    */
100    it('testNetworkMgrSocketTCPSocketServerListen0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
101      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0100';
102      try {
103        console.info(`${caseName} test start`);
104        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
105        expect(tcpServer).assertInstanceOf('Object');
106        let listenAddress: socket.NetAddress = {
107          address: '127.0.0.1'
108        };
109        tcpServer.listen(listenAddress, (err: BusinessError) => {
110          if (err) {
111            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
112            expectFail();
113          } else {
114            expectSuccess();
115            console.info(`${caseName} success`);
116          }
117          console.info(`${caseName} test end`);
118          done();
119        });
120      } catch (err) {
121        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
122        expectFail();
123        console.info(`${caseName} test end`);
124        done();
125      }
126    });
127
128    /* *
129     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0300
130     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0300
131     * @tc.desc  : Bind IP address and port,The address and protocol are both IPV6; callback
132     * @tc.size  : MediumTest
133     * @tc.type  : Function
134     * @tc.level : level 2
135     */
136    it('testNetworkMgrSocketTCPSocketServerListen0300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
137      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0300';
138      try {
139        console.info(`${caseName} test start`);
140        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
141        expect(tcpServer).assertInstanceOf('Object');
142        let listenAddress: socket.NetAddress = {
143          address: 'fe80::b3b:ecb5:77f:88dc%12',
144          family:2
145        };
146        tcpServer.listen(listenAddress, (err: BusinessError) => {
147          if (err) {
148            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
149            expectTrue(err.code===2303122);
150          } else {
151            console.info(`${caseName} success`);
152            expectFail();
153          }
154          console.info(`${caseName} test end`);
155          done();
156        });
157      } catch (err) {
158        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
159        expectFail();
160        console.info(`${caseName} test end`);
161        done();
162      }
163    });
164
165    /* *
166     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0500
167     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0500
168     * @tc.desc  : Bind IP address and port, bad address; callback
169     * @tc.size  : MediumTest
170     * @tc.type  : Function
171     * @tc.level : level 2
172     */
173    it('testNetworkMgrSocketTCPSocketServerListen0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
174      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0500';
175      try {
176        console.info(`${caseName} test start`);
177        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
178        expect(tcpServer).assertInstanceOf('Object');
179        let listenAddress: socket.NetAddress = {
180          address: '100.0.0.1',
181          port: 5001,
182          family: 1
183        };
184        tcpServer.listen(listenAddress, (err: BusinessError) => {
185          if (err) {
186            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
187            expectEqual(err.code, 2303199);
188          } else {
189            console.info(`${caseName} success`);
190            expectFail();
191          }
192          console.info(`${caseName} test end`);
193          done();
194        });
195      } catch (err) {
196        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
197        expectFail();
198        console.info(`${caseName} test end`);
199        done();
200      }
201    });
202
203    /* *
204     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0600
205     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0600
206     * @tc.desc  : Bind IP address and port,Port number is -1; callback
207     * @tc.size  : MediumTest
208     * @tc.type  : Function
209     * @tc.level : level 2
210     */
211    it('testNetworkMgrSocketTCPSocketServerListen0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
212      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0600';
213      try {
214        console.info(`${caseName} test start`);
215        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
216        expect(tcpServer).assertInstanceOf('Object');
217        let listenAddress: socket.NetAddress = {
218          address: '127.0.0.1',
219          port: -1,
220          family: 1
221        };
222        tcpServer.listen(listenAddress, (err: BusinessError) => {
223          if (err) {
224            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
225            expectFail();
226          } else {
227            console.info(`${caseName} success`);
228            expectSuccess();
229          }
230          console.info(`${caseName} test end`);
231          done();
232        });
233      } catch (err) {
234        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
235        expectFail();
236        console.info(`${caseName} test end`);
237        done();
238      }
239    });
240
241    /* *
242     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0700
243     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0700
244     * @tc.desc  : Bind IP address and port,Port number is 0; callback
245     * @tc.size  : MediumTest
246     * @tc.type  : Function
247     * @tc.level : level 2
248     */
249    it('testNetworkMgrSocketTCPSocketServerListen0700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
250      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0700';
251      try {
252        console.info(`${caseName} test start`);
253        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
254        expect(tcpServer).assertInstanceOf('Object');
255        let listenAddress: socket.NetAddress = {
256          address: '127.0.0.1',
257          port: 0,
258          family: 1
259        };
260        tcpServer.listen(listenAddress, (err: BusinessError) => {
261          if (err) {
262            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
263            expectFail();
264          } else {
265            console.info(`${caseName} success`);
266            expectSuccess();
267          }
268          console.info(`${caseName} test end`);
269          done();
270        });
271      } catch (err) {
272        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
273        expectFail();
274        console.info(`${caseName} test end`);
275        done();
276      }
277    });
278
279    /* *
280     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0800
281     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0800
282     * @tc.desc  : Bind IP address and port,Port number is 65535; callback
283     * @tc.size  : MediumTest
284     * @tc.type  : Function
285     * @tc.level : level 2
286     */
287    it('testNetworkMgrSocketTCPSocketServerListen0800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
288      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0800';
289      try {
290        console.info(`${caseName} test start`);
291        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
292        expect(tcpServer).assertInstanceOf('Object');
293        let listenAddress: socket.NetAddress = {
294          address: '127.0.0.1',
295          port: 65535,
296          family: 1
297        };
298        tcpServer.listen(listenAddress, (err: BusinessError) => {
299          if (err) {
300            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
301            expectFail();
302          } else {
303            console.info(`${caseName} success`);
304            expectSuccess();
305          }
306          console.info(`${caseName} test end`);
307          done();
308        });
309      } catch (err) {
310        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
311        expectFail();
312        console.info(`${caseName} test end`);
313        done();
314      }
315    });
316
317    /* *
318     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_0900
319     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen0900
320     * @tc.desc  : Bind IP address and port,Port number is 65536; callback
321     * @tc.size  : MediumTest
322     * @tc.type  : Function
323     * @tc.level : level 0
324     */
325    it('testNetworkMgrSocketTCPSocketServerListen0900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
326      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen0900';
327      try {
328        console.info(`${caseName} test start`);
329        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
330        expect(tcpServer).assertInstanceOf('Object');
331        let listenAddress: socket.NetAddress = {
332          address: '127.0.0.1',
333          port: 65536,
334          family: 1
335        };
336        tcpServer.listen(listenAddress, (err: BusinessError) => {
337          if (err) {
338            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
339            expectFail();
340          } else {
341            console.info(`${caseName} success`);
342            expectSuccess();
343          }
344          console.info(`${caseName} test end`);
345          done();
346        });
347      } catch (err) {
348        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
349        expectFail();
350        console.info(`${caseName} test end`);
351        done();
352      }
353    });
354
355    /* *
356     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1000
357     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1000
358     * @tc.desc  : Bind IP address and port,bad family; callback
359     * @tc.size  : MediumTest
360     * @tc.type  : Function
361     * @tc.level : level 0
362     */
363    it('testNetworkMgrSocketTCPSocketServerListen1000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
364      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1000';
365      try {
366        console.info(`${caseName} test start`);
367        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
368        expect(tcpServer).assertInstanceOf('Object');
369        let listenAddress: socket.NetAddress = {
370          address: '127.0.0.1',
371          port: 5002,
372          family: 4
373        };
374        tcpServer.listen(listenAddress, (err: BusinessError) => {
375          if (err) {
376            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
377            expectFail();
378          } else {
379            console.info(`${caseName} success`);
380            expectSuccess();
381          }
382          console.info(`${caseName} test end`);
383          done();
384        })
385      } catch (err) {
386        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
387        expectFail();
388        console.info(`${caseName} test end`);
389        done();
390      }
391    });
392
393    /* *
394     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1100
395     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1100
396     * @tc.desc  : Bind IP address and port, pass in null parameters; callback
397     * @tc.size  : MediumTest
398     * @tc.type  : Function
399     * @tc.level : level 0
400     */
401    it('testNetworkMgrSocketTCPSocketServerListen1100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
402      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1100';
403      try {
404        console.info(`${caseName} test start`);
405        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
406        expect(tcpServer).assertInstanceOf('Object');
407        tcpServer.listen(null, (err: BusinessError) => {
408          if (err) {
409            console.info(`${caseName} fail err:${err}`);
410            expectTrue(err.code == 401)
411          } else {
412            console.info(`${caseName} success`);
413            expectFail();
414          }
415          console.info(`${caseName} test end`);
416          done();
417        });
418      } catch (err) {
419        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
420        expectTrue(err.code == 401)
421        console.info(`${caseName} test end`);
422        done();
423      }
424    });
425
426    /* *
427     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1200
428     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1200
429     * @tc.desc  : Bind IP address and port, pass in undefined parameters; callback
430     * @tc.size  : MediumTest
431     * @tc.type  : Function
432     * @tc.level : level 2
433     */
434    it('testNetworkMgrSocketTCPSocketServerListen1200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
435      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1200';
436      try {
437        console.info(`${caseName} test start`);
438        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
439        expect(tcpServer).assertInstanceOf('Object');
440        tcpServer.listen(undefined, (err: BusinessError) => {
441          if (err) {
442            console.info(`${caseName} fail err:${err}`);
443            expectTrue(err.code == 401)
444          } else {
445            console.info(`${caseName} success`);
446            expectFail();
447          }
448          console.info(`${caseName} test end`);
449          done();
450        });
451      } catch (err) {
452        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
453        expectTrue(err.code == 401)
454        console.info(`${caseName} test end`);
455        done();
456      }
457    });
458
459    /* *
460     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1300
461     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1300
462     * @tc.desc  : Bind IP address and port,Only fill in the address for IPV4; promise
463     * @tc.size  : MediumTest
464     * @tc.type  : Function
465     * @tc.level : level 0
466     */
467    it('testNetworkMgrSocketTCPSocketServerListen1300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
468      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1300';
469      try {
470        console.info(`${caseName} test start`);
471        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
472        expect(tcpServer).assertInstanceOf('Object');
473        let listenAddress: socket.NetAddress = {
474          address: '127.0.0.1'
475        };
476        tcpServer.listen(listenAddress).then(() => {
477          console.info(`${caseName} success`);
478          expectSuccess();
479          done();
480        }).catch((err: BusinessError) => {
481          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
482          expectFail();
483          done();
484        }).finally(() => {
485          console.info(`${caseName} test end`);
486          done();
487        });
488      } catch (err) {
489        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
490        expectFail();
491        console.info(`${caseName} test end`);
492        done();
493      }
494    });
495
496    /* *
497     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1400
498     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1400
499     * @tc.desc  : Bind IP address and port,Only fill in the address for IPV6; promise
500     * @tc.size  : MediumTest
501     * @tc.type  : Function
502     * @tc.level : level 2
503     */
504    it('testNetworkMgrSocketTCPSocketServerListen1400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
505      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1400';
506      try {
507        console.info(`${caseName} test start`);
508        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
509        expect(tcpServer).assertInstanceOf('Object');
510        let listenAddress: socket.NetAddress = {
511          address: 'fe80::b3b:ecb5:77f:88dc%12'
512        };
513        tcpServer.listen(listenAddress).then(() => {
514          console.info(`${caseName} success`);
515          expectFail();
516          done();
517        }).catch((err: BusinessError) => {
518          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
519          expectSuccess();
520          done();
521        }).finally(() => {
522          console.info(`${caseName} test end`);
523          done();
524        });
525      } catch (err) {
526        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
527        expectFail();
528        console.info(`${caseName} test end`);
529        done();
530      }
531    });
532
533    /* *
534     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1500
535     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1500
536     * @tc.desc  : Bind IP address and port,The address and protocol are both IPV6; promise
537     * @tc.size  : MediumTest
538     * @tc.type  : Function
539     * @tc.level : level 0
540     */
541    it('testNetworkMgrSocketTCPSocketServerListen1500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
542      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1500';
543      try {
544        console.info(`${caseName} test start`);
545        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
546        expect(tcpServer).assertInstanceOf('Object');
547        let listenAddress: socket.NetAddress = {
548          address: 'fe80::b3b:ecb5:77f:88dc%12',
549          family:2
550        };
551        tcpServer.listen(listenAddress).then(() => {
552          console.info(`${caseName} success`);
553          expectFail();
554          done();
555        }).catch((err: BusinessError) => {
556          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
557          expectTrue(err.code===2303122);
558          done();
559        }).finally(() => {
560          console.info(`${caseName} test end`);
561          done();
562        });
563      } catch (err) {
564        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
565        expectFail();
566        console.info(`${caseName} test end`);
567        done();
568      }
569    });
570
571    /* *
572     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1600
573     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1600
574     * @tc.desc  : Bind IP address and port,Address and protocol inversion; promise
575     * @tc.size  : MediumTest
576     * @tc.type  : Function
577     * @tc.level : level 2
578     */
579    it('testNetworkMgrSocketTCPSocketServerListen1600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
580      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1600';
581      try {
582        console.info(`${caseName} test start`);
583        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
584        expect(tcpServer).assertInstanceOf('Object');
585        let listenAddress: socket.NetAddress = {
586          address: '127.0.0.1',
587          port: 5003,
588          family: 2
589        };
590        tcpServer.listen(listenAddress).then(() => {
591          console.info(`${caseName} success`);
592          expectFail();
593          done();
594        }).catch((err: BusinessError) => {
595          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
596          expectSuccess();
597          done();
598        }).finally(() => {
599          console.info(`${caseName} test end`);
600          done();
601        });
602      } catch (err) {
603        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
604        expectFail();
605        console.info(`${caseName} test end`);
606        done();
607      }
608    });
609
610    /* *
611     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1700
612     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1700
613     * @tc.desc  : Bind IP address and port, bad address; promise
614     * @tc.size  : MediumTest
615     * @tc.type  : Function
616     * @tc.level : level 2
617     */
618    it('testNetworkMgrSocketTCPSocketServerListen1700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
619      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1700';
620      try {
621        console.info(`${caseName} test start`);
622        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
623        expect(tcpServer).assertInstanceOf('Object');
624        let listenAddress: socket.NetAddress = {
625          address: '100.0.0.1',
626          port: 65535,
627          family: 1
628        };
629        tcpServer.listen(listenAddress).then(() => {
630          console.info(`${caseName} fail`);
631          expectFail();
632          done();
633        }).catch((err: BusinessError) => {
634          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
635          expectEqual(err.code, 2303199);
636          done();
637        }).finally(() => {
638          console.info(`${caseName} test end`);
639          done();
640        });
641      } catch (err) {
642        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
643        expectFail();
644        console.info(`${caseName} test end`);
645        done();
646      }
647    });
648
649    /* *
650     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1800
651     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1800
652     * @tc.desc  : Bind IP address and port,Port number is -1; promise
653     * @tc.size  : MediumTest
654     * @tc.type  : Function
655     * @tc.level : level 2
656     */
657    it('testNetworkMgrSocketTCPSocketServerListen1800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
658      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1800';
659      try {
660        console.info(`${caseName} test start`);
661        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
662        expect(tcpServer).assertInstanceOf('Object');
663        let listenAddress: socket.NetAddress = {
664          address: '127.0.0.1',
665          port: -1,
666          family: 1
667        };
668        tcpServer.listen(listenAddress).then(() => {
669          console.info(`${caseName} success`);
670          expectSuccess();
671          done();
672        }).catch((err: BusinessError) => {
673          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
674          expectFail();
675          done();
676        }).finally(() => {
677          console.info(`${caseName} test end`);
678          done();
679        });
680      } catch (err) {
681        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
682        expectFail();
683        console.info(`${caseName} test end`);
684        done();
685      }
686    });
687
688    /* *
689     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_1900
690     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen1900
691     * @tc.desc  : Bind IP address and port,Port number is 0; promise
692     * @tc.size  : MediumTest
693     * @tc.type  : Function
694     * @tc.level : level 2
695     */
696    it('testNetworkMgrSocketTCPSocketServerListen1900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
697      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen1900';
698      try {
699        console.info(`${caseName} test start`);
700        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
701        expect(tcpServer).assertInstanceOf('Object');
702        let listenAddress: socket.NetAddress = {
703          address: '127.0.0.1',
704          port: 0,
705          family: 1
706        };
707        tcpServer.listen(listenAddress).then(() => {
708          console.info(`${caseName} success`);
709          expectSuccess();
710          done();
711        }).catch((err: BusinessError) => {
712          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
713          expectFail();
714          done();
715        }).finally(() => {
716          console.info(`${caseName} test end`);
717          done();
718        });
719      } catch (err) {
720        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
721        expectFail();
722        console.info(`${caseName} test end`);
723        done();
724      }
725    });
726
727    /* *
728     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_2000
729     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen2000
730     * @tc.desc  : Bind IP address and port,Port number is 65535; promise
731     * @tc.size  : MediumTest
732     * @tc.type  : Function
733     * @tc.level : level 2
734     */
735    it('testNetworkMgrSocketTCPSocketServerListen2000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
736      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen2000';
737      try {
738        console.info(`${caseName} test start`);
739        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
740        expect(tcpServer).assertInstanceOf('Object');
741        let listenAddress: socket.NetAddress = {
742          address: '127.0.0.1',
743          port: 65535,
744          family: 1
745        };
746        tcpServer.listen(listenAddress).then(() => {
747          console.info(`${caseName} success`);
748          expectSuccess();
749          done();
750        }).catch((err: BusinessError) => {
751          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
752          expectFail();
753          done();
754        }).finally(() => {
755          console.info(`${caseName} test end`);
756          done();
757        });
758      } catch (err) {
759        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
760        expectFail();
761        console.info(`${caseName} test end`);
762        done();
763      }
764    });
765
766    /* *
767     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_2100
768     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen2100
769     * @tc.desc  : Bind IP address and port,Port number is 65536; promise
770     * @tc.size  : MediumTest
771     * @tc.type  : Function
772     * @tc.level : level 2
773     */
774    it('testNetworkMgrSocketTCPSocketServerListen2100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
775      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen2100';
776      try {
777        console.info(`${caseName} test start`);
778        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
779        expect(tcpServer).assertInstanceOf('Object');
780        let listenAddress: socket.NetAddress = {
781          address: '127.0.0.1',
782          port: 65536,
783          family: 1
784        };
785        tcpServer.listen(listenAddress).then(() => {
786          console.info(`${caseName} success`);
787          expectSuccess();
788          done();
789        }).catch((err: BusinessError) => {
790          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
791          expectFail();
792          done();
793        }).finally(() => {
794          console.info(`${caseName} test end`);
795          done();
796        });
797      } catch (err) {
798        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
799        expectFail();
800        console.info(`${caseName} test end`);
801        done();
802      }
803    });
804
805    /* *
806     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_2200
807     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen2200
808     * @tc.desc  : Bind IP address and port,bad family; promise
809     * @tc.size  : MediumTest
810     * @tc.type  : Function
811     * @tc.level : level 2
812     */
813    it('testNetworkMgrSocketTCPSocketServerListen2200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
814      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen2200';
815      try {
816        console.info(`${caseName} test start`);
817        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
818        expect(tcpServer).assertInstanceOf('Object');
819        let listenAddress: socket.NetAddress = {
820          address: '127.0.0.1',
821          port: 5010,
822          family: 4
823        };
824        tcpServer.listen(listenAddress).then(() => {
825          console.info(`${caseName} success`);
826          expectSuccess();
827          done();
828        }).catch((err: BusinessError) => {
829          console.info(`${caseName} fail err:${JSON.stringify(err)}`)
830          expectFail();
831          done();
832        }).finally(() => {
833          console.info(`${caseName} test end`);
834          done();
835        })
836      } catch (err) {
837        console.info(`${caseName} fail err:${JSON.stringify(err)}`)
838        expectFail();
839        console.info(`${caseName} test end`);
840        done();
841      }
842    });
843
844    /* *
845     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_2300
846     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen2300
847     * @tc.desc  : Bind IP address and port, pass in null parameters; promise
848     * @tc.size  : MediumTest
849     * @tc.type  : Function
850     * @tc.level : level 2
851     */
852    it('testNetworkMgrSocketTCPSocketServerListen2300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
853      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen2300';
854      try {
855        console.info(`${caseName} test start`);
856        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
857        expect(tcpServer).assertInstanceOf('Object');
858        tcpServer.listen(null).then(() => {
859          expectFail();
860          done();
861        }).catch((err: BusinessError) => {
862          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
863          expectTrue(err.code==401);
864          done();
865        }).finally(() => {
866          console.info(`${caseName} test end`);
867          done();
868        });
869      } catch (err) {
870        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
871        expectTrue(err.code==401);
872        console.info(`${caseName} test end`);
873        done();
874      }
875    });
876
877    /* *
878     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_Listen_2400
879     * @tc.name  : testNetworkMgrSocketTCPSocketServerListen2400
880     * @tc.desc  : Bind IP address and port, pass in undefined parameters; promise
881     * @tc.size  : MediumTest
882     * @tc.type  : Function
883     * @tc.level : level 2
884     */
885    it('testNetworkMgrSocketTCPSocketServerListen2400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
886      let caseName: string = 'testNetworkMgrSocketTCPSocketServerListen2400';
887      try {
888        console.info(`${caseName} test start`);
889        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
890        expect(tcpServer).assertInstanceOf('Object');
891        tcpServer.listen(undefined).then(() => {
892          expectFail();
893          done();
894        }).catch((err: BusinessError) => {
895          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
896          expectTrue(err.code==401);
897          done();
898        }).finally(() => {
899          console.info(`${caseName} test end`);
900          done();
901        });
902      } catch (err) {
903        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
904        expectTrue(err.code==401);
905        console.info(`${caseName} test end`);
906        done();
907      }
908    });
909
910    /* *
911     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0100
912     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0100
913     * @tc.desc  : Obtain TCPSocketService status without listening; callback
914     * @tc.size  : MediumTest
915     * @tc.type  : Function
916     * @tc.level : level 2
917     */
918    it('testNetworkMgrSocketTCPSocketServerGetState0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
919      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0100'
920      try {
921        console.info(`${caseName} test start`);
922        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
923        expect(tcpServer).assertInstanceOf('Object');
924        tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => {
925          if (err) {
926            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
927            expectFail();
928            done();
929          } else {
930            console.info(`${caseName} success data:${JSON.stringify(data)}`);
931            expectEqual(data.isBound, false);
932            expectEqual(data.isClose, false);
933            expectEqual(data.isConnected, false);
934            done();
935          }
936          console.info(`${caseName} test end`);
937          done();
938        });
939      } catch (err) {
940        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
941        expectFail();
942        console.info(`${caseName} test end`);
943        done();
944      }
945    });
946
947    /* *
948     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0300
949     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0300
950     * @tc.desc  : Obtain the TCP Socket Server status after connect; callback
951     * @tc.size  : MediumTest
952     * @tc.type  : Function
953     * @tc.level : level 2
954     */
955    it('testNetworkMgrSocketTCPSocketServerGetState0300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
956      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0300';
957      try {
958        console.info(`${caseName} test start`);
959        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
960        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
961        expect(tcpServer).assertInstanceOf('Object');
962        let listenAddress: socket.NetAddress = {
963          address: '127.0.0.1',
964          port: 5013,
965          family: 1
966        };
967        await tcpServer.listen(listenAddress);
968        let tcpConnectOptions: socket.TCPConnectOptions = {
969          address: listenAddress,
970          timeout: 2000
971        };
972        await tcp.connect(tcpConnectOptions);
973        tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => {
974          if (err) {
975            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
976            expectFail();
977            done();
978          } else {
979            console.info(`${caseName} success data:${JSON.stringify(data)}`);
980            expectEqual(data.isBound, true);
981            expectEqual(data.isClose, false);
982            expectEqual(data.isConnected, true);
983            done();
984          }
985          console.info(`${caseName} test end`);
986          done();
987        });
988      } catch (err) {
989        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
990        expectFail();
991        console.info(`${caseName} test end`);
992        done();
993      }
994    });
995
996    /* *
997     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0400
998     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0400
999     * @tc.desc  : Obtain TCPSocketService status without listening; promise
1000     * @tc.size  : MediumTest
1001     * @tc.type  : Function
1002     * @tc.level : level 2
1003     */
1004    it('testNetworkMgrSocketTCPSocketServerGetState0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1005      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0400'
1006      try {
1007        console.info(`${caseName} test start`);
1008        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1009        expect(tcpServer).assertInstanceOf('Object');
1010        tcpServer.getState().then((data: socket.SocketStateBase) => {
1011          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1012          expectEqual(data.isBound, false);
1013          expectEqual(data.isClose, false);
1014          expectEqual(data.isConnected, false);
1015          done();
1016        }).catch((err: BusinessError) => {
1017          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1018          expectFail();
1019          done();
1020        }).finally(() => {
1021          console.info(`${caseName} test end`);
1022          done();
1023        });
1024      } catch (err) {
1025        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1026        expectFail();
1027        console.info(`${caseName} test end`);
1028        done();
1029      }
1030    });
1031
1032    /* *
1033     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0500
1034     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0500
1035     * @tc.desc  : Obtain the TCP Socket Server status after listening; promise
1036     * @tc.size  : MediumTest
1037     * @tc.type  : Function
1038     * @tc.level : level 2
1039     */
1040    it('testNetworkMgrSocketTCPSocketServerGetState0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1041      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0500'
1042      try {
1043        console.info(`${caseName} test start`);
1044        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1045        expect(tcpServer).assertInstanceOf('Object');
1046        let listenAddress: socket.NetAddress = {
1047          address: '127.0.0.1',
1048          port: 5014,
1049          family: 1
1050        };
1051        await tcpServer.listen(listenAddress);
1052        tcpServer.getState().then((data: socket.SocketStateBase) => {
1053          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1054          expectEqual(data.isBound, true);
1055          expectEqual(data.isClose, false);
1056          expectEqual(data.isConnected, true);
1057          done();
1058        }).catch((err: BusinessError) => {
1059          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1060          expectFail();
1061          done();
1062        }).finally(() => {
1063          console.info(`${caseName} test end`);
1064          done();
1065        });
1066      } catch (err) {
1067        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1068        expectFail();
1069        console.info(`${caseName} test end`);
1070        done();
1071      }
1072    });
1073
1074    /* *
1075     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0600
1076     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0600
1077     * @tc.desc  : Obtain the TCP Socket Server status after connect; promise
1078     * @tc.size  : MediumTest
1079     * @tc.type  : Function
1080     * @tc.level : level 0
1081     */
1082    it('testNetworkMgrSocketTCPSocketServerGetState0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
1083      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0600';
1084      try {
1085        console.info(`${caseName} test start`);
1086        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
1087        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1088        expect(tcpServer).assertInstanceOf('Object');
1089        let listenAddress: socket.NetAddress = {
1090          address: '127.0.0.1',
1091          port: 5015,
1092          family: 1
1093        };
1094        await tcpServer.listen(listenAddress);
1095        let tcpConnectOptions: socket.TCPConnectOptions = {
1096          address: listenAddress,
1097          timeout: 2000
1098        };
1099        await tcp.connect(tcpConnectOptions);
1100        tcpServer.getState().then((data: socket.SocketStateBase) => {
1101          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1102          expectEqual(data.isBound, true);
1103          expectEqual(data.isClose, false);
1104          expectEqual(data.isConnected, true);
1105          done();
1106        }).catch((err: BusinessError) => {
1107          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1108          expectFail();
1109          done();
1110        }).finally(() => {
1111          console.info(`${caseName} test end`);
1112          done();
1113        });
1114      } catch (err) {
1115        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1116        expectFail();
1117        console.info(`${caseName} test end`);
1118        done();
1119      }
1120    });
1121
1122    /* *
1123     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0100
1124     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0100
1125     * @tc.desc  : Set other properties of the TCP Socket Server connection,before listen; callback
1126     * @tc.size  : MediumTest
1127     * @tc.type  : Function
1128     * @tc.level : level 2
1129     */
1130    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1131      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0100';
1132      try {
1133        console.info(`${caseName} test start`);
1134        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1135        expect(tcpServer).assertInstanceOf('Object');
1136        let tcpExtraOptions: socket.TCPExtraOptions = {
1137          keepAlive: true,
1138          OOBInline: true,
1139          TCPNoDelay: true,
1140          socketLinger: {
1141            on: true, linger: 10
1142          },
1143          receiveBufferSize: 1000,
1144          sendBufferSize: 1000,
1145          reuseAddress: true,
1146          socketTimeout: 3000
1147        };
1148        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1149          if (err) {
1150            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1151            expectTrue(err.code===2303109);
1152            done();
1153          } else {
1154            console.info(`${caseName} success`);
1155            expectFail();
1156            done();
1157          }
1158          console.info(`${caseName} test end`);
1159          done();
1160        });
1161      } catch (err) {
1162        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1163        expectFail();
1164        console.info(`${caseName} test end`);
1165        done();
1166      }
1167    });
1168
1169    /* *
1170     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0200
1171     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0200
1172     * @tc.desc  : Set other properties of the TCP Socket Server connection after listening; callback
1173     * @tc.size  : MediumTest
1174     * @tc.type  : Function
1175     * @tc.level : level 2
1176     */
1177    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1178      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0200';
1179      try {
1180        console.info(`${caseName} test start`);
1181        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1182        expect(tcpServer).assertInstanceOf('Object');
1183        let listenAddress: socket.NetAddress = {
1184          address: '127.0.0.1',
1185          port: 5016,
1186          family: 1
1187        };
1188        await tcpServer.listen(listenAddress);
1189        let tcpExtraOptions: socket.TCPExtraOptions = {
1190          keepAlive: true,
1191          OOBInline: true,
1192          TCPNoDelay: true,
1193          socketLinger: {
1194            on: true, linger: 10
1195          },
1196          receiveBufferSize: 1000,
1197          sendBufferSize: 1000,
1198          reuseAddress: true,
1199          socketTimeout: 3000
1200        };
1201        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1202          if (err) {
1203            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1204            expectFail();
1205          } else {
1206            console.info(`${caseName} success`);
1207            expectSuccess();
1208          }
1209          console.info(`${caseName} test end`);
1210          done();
1211        });
1212      } catch (err) {
1213        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1214        expectFail();
1215        console.info(`${caseName} test end`);
1216        done();
1217      }
1218    });
1219
1220    /* *
1221     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0300
1222     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0300
1223     * @tc.desc  : Set other properties of TCPSocketService connection in listen, input parameters are null;callback
1224     * @tc.size  : MediumTest
1225     * @tc.type  : Function
1226     * @tc.level : level 2
1227     */
1228    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1229      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0300';
1230      try {
1231        console.info(`${caseName} test start`);
1232        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1233        expect(tcpServer).assertInstanceOf('Object');
1234        let listenAddress: socket.NetAddress = {
1235          address: '127.0.0.1',
1236          port: 5017,
1237          family: 1
1238        };
1239        await tcpServer.listen(listenAddress);
1240        tcpServer.setExtraOptions(null, (err: BusinessError) => {
1241          if (err) {
1242            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1243            expectTrue(err.code==401);
1244          } else {
1245            console.info(`${caseName} success`);
1246            expectFail();
1247          }
1248          console.info(`${caseName} test end`);
1249          done();
1250        });
1251      } catch (err) {
1252        console.info(`${caseName}_catch fail ${JSON.stringify(err)}`);
1253        expectTrue(err.code==401);
1254        console.info(`${caseName} test end`);
1255        done();
1256      }
1257    });
1258
1259    /* *
1260     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0400
1261     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0400
1262     * @tc.desc  : Set other properties of TCPSocketService connection in listen,input parameters are undefined;callback
1263     * @tc.size  : MediumTest
1264     * @tc.type  : Function
1265     * @tc.level : level 2
1266     */
1267    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1268      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0400';
1269      try {
1270        console.info(`${caseName} test start`);
1271        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1272        expect(tcpServer).assertInstanceOf('Object');
1273        let listenAddress: socket.NetAddress = {
1274          address: '127.0.0.1',
1275          port: 5018,
1276          family: 1
1277        };
1278        await tcpServer.listen(listenAddress);
1279        tcpServer.setExtraOptions(undefined, (err: BusinessError) => {
1280          if (err) {
1281            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1282            expectTrue(err.code==401);
1283          } else {
1284            console.info(`${caseName} success`);
1285            expectFail();
1286          }
1287          console.info(`${caseName} test end`);
1288          done();
1289        });
1290      } catch (err) {
1291        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1292        expectTrue(err.code==401);
1293        console.info(`${caseName} test end`);
1294        done();
1295      }
1296    });
1297
1298    /* *
1299     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0500
1300     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0500
1301     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is true; callback
1302     * @tc.size  : MediumTest
1303     * @tc.type  : Function
1304     * @tc.level : level 2
1305     */
1306    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1307      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0500';
1308      try {
1309        console.info(`${caseName} test start`);
1310        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1311        expect(tcpServer).assertInstanceOf('Object');
1312        let listenAddress: socket.NetAddress = {
1313          address: '127.0.0.1',
1314          port: 11001,
1315          family: 1
1316        };
1317        await tcpServer.listen(listenAddress);
1318        let tcpExtraOptions: socket.TCPExtraOptions = {
1319          keepAlive: true,
1320          socketLinger: {
1321            on: true, linger: 10
1322          }
1323        };
1324        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1325          if (err) {
1326            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1327            expectFail();
1328          } else {
1329            console.info(`${caseName} success`);
1330            expectSuccess();
1331          }
1332          console.info(`${caseName} test end`);
1333          done();
1334        });
1335      } catch (err) {
1336        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1337        expectFail();
1338        console.info(`${caseName} test end`);
1339        done();
1340      }
1341    });
1342
1343    /* *
1344     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0600
1345     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0600
1346     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is false; callback
1347     * @tc.size  : MediumTest
1348     * @tc.type  : Function
1349     * @tc.level : level 2
1350     */
1351    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1352      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0600';
1353      try {
1354        console.info(`${caseName} test start`);
1355        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1356        expect(tcpServer).assertInstanceOf('Object');
1357        let listenAddress: socket.NetAddress = {
1358          address: '127.0.0.1',
1359          port: 11002,
1360          family: 1
1361        };
1362        await tcpServer.listen(listenAddress);
1363        let tcpExtraOptions: socket.TCPExtraOptions = {
1364          keepAlive: false,
1365          socketLinger: {
1366            on: true, linger: 10
1367          }
1368        };
1369        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1370          if (err) {
1371            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1372            expectFail();
1373          } else {
1374            console.info(`${caseName} success`);
1375            expectSuccess();
1376          }
1377          console.info(`${caseName} test end`);
1378          done();
1379        });
1380      } catch (err) {
1381        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1382        expectFail();
1383        console.info(`${caseName} test end`);
1384        done();
1385      }
1386    });
1387
1388    /* *
1389     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0700
1390     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0700
1391     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is true; callback
1392     * @tc.size  : MediumTest
1393     * @tc.type  : Function
1394     * @tc.level : level 2
1395     */
1396    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1397      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0700';
1398      try {
1399        console.info(`${caseName} test start`);
1400        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1401        expect(tcpServer).assertInstanceOf('Object');
1402        let listenAddress: socket.NetAddress = {
1403          address: '127.0.0.1',
1404          port: 11003,
1405          family: 1
1406        };
1407        await tcpServer.listen(listenAddress);
1408        let tcpExtraOptions: socket.TCPExtraOptions = {
1409          OOBInline: true,
1410          socketLinger: {
1411            on: true, linger: 10
1412          }
1413        }
1414        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1415          if (err) {
1416            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1417            expectFail();
1418          } else {
1419            console.info(`${caseName} success`);
1420            expectSuccess();
1421          }
1422          console.info(`${caseName} test end`);
1423          done();
1424        });
1425      } catch (err) {
1426        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1427        expectFail();
1428        console.info(`${caseName} test end`);
1429        done();
1430      }
1431    });
1432
1433    /* *
1434     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0800
1435     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0800
1436     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is false; callback
1437     * @tc.size  : MediumTest
1438     * @tc.type  : Function
1439     * @tc.level : level 2
1440     */
1441    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1442      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0800';
1443      try {
1444        console.info(`${caseName} test start`);
1445        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1446        expect(tcpServer).assertInstanceOf('Object');
1447        let listenAddress: socket.NetAddress = {
1448          address: '127.0.0.1',
1449          port: 11004,
1450          family: 1
1451        };
1452        await tcpServer.listen(listenAddress);
1453        let tcpExtraOptions: socket.TCPExtraOptions = {
1454          OOBInline: false,
1455          socketLinger: {
1456            on: true, linger: 10
1457          }
1458        };
1459        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1460          if (err) {
1461            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1462            expectFail();
1463          } else {
1464            console.info(`${caseName} success`);
1465            expectSuccess();
1466          }
1467          console.info(`${caseName} test end`);
1468          done();
1469        });
1470      } catch (err) {
1471        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1472        expectFail();
1473        console.info(`${caseName} test end`);
1474        done();
1475      }
1476    });
1477
1478    /* *
1479     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0900
1480     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0900
1481     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is true; callback
1482     * @tc.size  : MediumTest
1483     * @tc.type  : Function
1484     * @tc.level : level 2
1485     */
1486    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1487      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0900';
1488      try {
1489        console.info(`${caseName} test start`);
1490        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1491        expect(tcpServer).assertInstanceOf('Object');
1492        let listenAddress: socket.NetAddress = {
1493          address: '127.0.0.1',
1494          port: 11005,
1495          family: 1
1496        };
1497        await tcpServer.listen(listenAddress);
1498        let tcpExtraOptions: socket.TCPExtraOptions = {
1499          TCPNoDelay: true,
1500          socketLinger: {
1501            on: true, linger: 10
1502          }
1503        };
1504        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1505          if (err) {
1506            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1507            expectFail();
1508          } else {
1509            console.info(`${caseName} success`);
1510            expectSuccess();
1511          }
1512          console.info(`${caseName} test end`);
1513          done();
1514        });
1515      } catch (err) {
1516        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1517        expectFail();
1518        console.info(`${caseName} test end`);
1519        done();
1520      }
1521    });
1522
1523    /* *
1524     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1000
1525     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1000
1526     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is false; callback
1527     * @tc.size  : MediumTest
1528     * @tc.type  : Function
1529     * @tc.level : level 2
1530     */
1531    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1532      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1000';
1533      try {
1534        console.info(`${caseName} test start`);
1535        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1536        expect(tcpServer).assertInstanceOf('Object');
1537        let listenAddress: socket.NetAddress = {
1538          address: '127.0.0.1',
1539          port: 11006,
1540          family: 1
1541        };
1542        await tcpServer.listen(listenAddress);
1543        let tcpExtraOptions: socket.TCPExtraOptions = {
1544          TCPNoDelay: false,
1545          socketLinger: {
1546            on: true, linger: 10
1547          }
1548        }
1549        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1550          if (err) {
1551            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1552            expectFail();
1553          } else {
1554            console.info(`${caseName} success`);
1555            expectSuccess();
1556          }
1557          console.info(`${caseName} test end`);
1558          done();
1559        });
1560      } catch (err) {
1561        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1562        expectFail();
1563        console.info(`${caseName} test end`);
1564        done();
1565      }
1566    });
1567
1568    /* *
1569     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1100
1570     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1100
1571     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is -1; callback
1572     * @tc.size  : MediumTest
1573     * @tc.type  : Function
1574     * @tc.level : level 2
1575     */
1576    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1577      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1100';
1578      try {
1579        console.info(`${caseName} test start`);
1580        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1581        expect(tcpServer).assertInstanceOf('Object');
1582        let listenAddress: socket.NetAddress = {
1583          address: '127.0.0.1',
1584          port: 11007,
1585          family: 1
1586        };
1587        await tcpServer.listen(listenAddress);
1588        let tcpExtraOptions: socket.TCPExtraOptions = {
1589          receiveBufferSize: -1,
1590          socketLinger: {
1591            on: true, linger: 10
1592          }
1593        }
1594        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1595          if (err) {
1596            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1597            expectFail();
1598          } else {
1599            console.info(`${caseName} success`);
1600            expectSuccess();
1601          }
1602          console.info(`${caseName} test end`);
1603          done();
1604        });
1605      } catch (err) {
1606        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1607        expectFail();
1608        console.info(`${caseName} test end`);
1609        done();
1610      }
1611    });
1612
1613    /* *
1614     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1200
1615     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1200
1616     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 0; callback
1617     * @tc.size  : MediumTest
1618     * @tc.type  : Function
1619     * @tc.level : level 2
1620     */
1621    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1622      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1200';
1623      try {
1624        console.info(`${caseName} test start`);
1625        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1626        expect(tcpServer).assertInstanceOf('Object');
1627        let listenAddress: socket.NetAddress = {
1628          address: '127.0.0.1',
1629          port: 11008,
1630          family: 1
1631        };
1632        await tcpServer.listen(listenAddress);
1633        let tcpExtraOptions: socket.TCPExtraOptions = {
1634          receiveBufferSize: 0,
1635          socketLinger: {
1636            on: true, linger: 10
1637          }
1638        }
1639        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1640          if (err) {
1641            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1642            expectFail();
1643          } else {
1644            console.info(`${caseName} success`);
1645            expectSuccess();
1646          }
1647          console.info(`${caseName} test end`);
1648          done();
1649        });
1650      } catch (err) {
1651        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1652        expectFail();
1653        console.info(`${caseName} test end`);
1654        done();
1655      }
1656    });
1657
1658    /* *
1659     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1300
1660     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1300
1661     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 100; callback
1662     * @tc.size  : MediumTest
1663     * @tc.type  : Function
1664     * @tc.level : level 2
1665     */
1666    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1667      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1300';
1668      try {
1669        console.info(`${caseName} test start`);
1670        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1671        expect(tcpServer).assertInstanceOf('Object');
1672        let listenAddress: socket.NetAddress = {
1673          address: '127.0.0.1',
1674          port: 11009,
1675          family: 1
1676        };
1677        await tcpServer.listen(listenAddress);
1678        let tcpExtraOptions: socket.TCPExtraOptions = {
1679          receiveBufferSize: 100,
1680          socketLinger: {
1681            on: true, linger: 10
1682          }
1683        }
1684        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1685          if (err) {
1686            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1687            expectFail();
1688          } else {
1689            console.info(`${caseName} success`);
1690            expectSuccess();
1691          }
1692          console.info(`${caseName} test end`);
1693          done();
1694        });
1695      } catch (err) {
1696        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1697        expectFail();
1698        console.info(`${caseName} test end`);
1699        done();
1700      }
1701    });
1702
1703    /* *
1704     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1400
1705     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1400
1706     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is -1; callback
1707     * @tc.size  : MediumTest
1708     * @tc.type  : Function
1709     * @tc.level : level 2
1710     */
1711    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1712      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1400';
1713      try {
1714        console.info(`${caseName} test start`);
1715        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1716        expect(tcpServer).assertInstanceOf('Object');
1717        let listenAddress: socket.NetAddress = {
1718          address: '127.0.0.1',
1719          port: 11010,
1720          family: 1
1721        };
1722        await tcpServer.listen(listenAddress);
1723        let tcpExtraOptions: socket.TCPExtraOptions = {
1724          sendBufferSize: -1,
1725          socketLinger: {
1726            on: true, linger: 10
1727          }
1728        }
1729        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1730          if (err) {
1731            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1732            expectFail();
1733          } else {
1734            console.info(`${caseName} success`);
1735            expectSuccess();
1736          }
1737          console.info(`${caseName} test end`);
1738          done();
1739        });
1740      } catch (err) {
1741        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1742        expectFail();
1743        console.info(`${caseName} test end`);
1744        done();
1745      }
1746    });
1747
1748    /* *
1749     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1500
1750     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1500
1751     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 0; callback
1752     * @tc.size  : MediumTest
1753     * @tc.type  : Function
1754     * @tc.level : level 2
1755     */
1756    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1757      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1500';
1758      try {
1759        console.info(`${caseName} test start`);
1760        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1761        expect(tcpServer).assertInstanceOf('Object');
1762        let listenAddress: socket.NetAddress = {
1763          address: '127.0.0.1',
1764          port: 11011,
1765          family: 1
1766        };
1767        await tcpServer.listen(listenAddress);
1768        let tcpExtraOptions: socket.TCPExtraOptions = {
1769          sendBufferSize: 0,
1770          socketLinger: {
1771            on: true, linger: 10
1772          }
1773        }
1774        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1775          if (err) {
1776            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1777            expectFail();
1778          } else {
1779            console.info(`${caseName} success`);
1780            expectSuccess();
1781          }
1782          console.info(`${caseName} test end`);
1783          done();
1784        });
1785      } catch (err) {
1786        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1787        expectFail();
1788        console.info(`${caseName} test end`);
1789        done();
1790      }
1791    });
1792
1793    /* *
1794     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1600
1795     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1600
1796     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 100; callback
1797     * @tc.size  : MediumTest
1798     * @tc.type  : Function
1799     * @tc.level : level 2
1800     */
1801    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1802      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1600';
1803      try {
1804        console.info(`${caseName} test start`);
1805        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1806        expect(tcpServer).assertInstanceOf('Object');
1807        let listenAddress: socket.NetAddress = {
1808          address: '127.0.0.1',
1809          port: 11012,
1810          family: 1
1811        };
1812        await tcpServer.listen(listenAddress);
1813        let tcpExtraOptions: socket.TCPExtraOptions = {
1814          sendBufferSize: 100,
1815          socketLinger: {
1816            on: true, linger: 10
1817          }
1818        }
1819        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1820          if (err) {
1821            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1822            expectFail();
1823          } else {
1824            console.info(`${caseName} success`);
1825            expectSuccess();
1826          }
1827          console.info(`${caseName} test end`);
1828          done();
1829        });
1830      } catch (err) {
1831        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1832        expectFail();
1833        console.info(`${caseName} test end`);
1834        done();
1835      }
1836    });
1837
1838    /* *
1839     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1700
1840     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1700
1841     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is true; callback
1842     * @tc.size  : MediumTest
1843     * @tc.type  : Function
1844     * @tc.level : level 2
1845     */
1846    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1847      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1700';
1848      try {
1849        console.info(`${caseName} test start`);
1850        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1851        expect(tcpServer).assertInstanceOf('Object');
1852        let listenAddress: socket.NetAddress = {
1853          address: '127.0.0.1',
1854          port: 11013,
1855          family: 1
1856        };
1857        await tcpServer.listen(listenAddress);
1858        let tcpExtraOptions: socket.TCPExtraOptions = {
1859          reuseAddress: true,
1860          socketLinger: {
1861            on: true, linger: 10
1862          }
1863        }
1864        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1865          if (err) {
1866            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1867            expectFail();
1868          } else {
1869            console.info(`${caseName} success`);
1870            expectSuccess();
1871          }
1872          console.info(`${caseName} test end`);
1873          done();
1874        });
1875      } catch (err) {
1876        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1877        expectFail();
1878        console.info(`${caseName} test end`);
1879        done();
1880      }
1881    });
1882
1883    /* *
1884     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1800
1885     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1800
1886     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is false; callback
1887     * @tc.size  : MediumTest
1888     * @tc.type  : Function
1889     * @tc.level : level 2
1890     */
1891    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1892      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1800';
1893      try {
1894        console.info(`${caseName} test start`);
1895        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1896        expect(tcpServer).assertInstanceOf('Object');
1897        let listenAddress: socket.NetAddress = {
1898          address: '127.0.0.1',
1899          port: 11014,
1900          family: 1
1901        };
1902        await tcpServer.listen(listenAddress);
1903        let tcpExtraOptions: socket.TCPExtraOptions = {
1904          reuseAddress: false,
1905          socketLinger: {
1906            on: true, linger: 10
1907          }
1908        }
1909        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1910          if (err) {
1911            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1912            expectFail();
1913          } else {
1914            console.info(`${caseName} success`);
1915            expectSuccess();
1916          }
1917          console.info(`${caseName} test end`);
1918          done();
1919        });
1920      } catch (err) {
1921        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1922        expectFail();
1923        console.info(`${caseName} test end`);
1924        done();
1925      }
1926    });
1927
1928    /* *
1929     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1900
1930     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1900
1931     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is -1; callback
1932     * @tc.size  : MediumTest
1933     * @tc.type  : Function
1934     * @tc.level : level 2
1935     */
1936    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1937      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1900';
1938      try {
1939        console.info(`${caseName} test start`);
1940        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1941        expect(tcpServer).assertInstanceOf('Object');
1942        let listenAddress: socket.NetAddress = {
1943          address: '127.0.0.1',
1944          port: 11014,
1945          family: 1
1946        };
1947        await tcpServer.listen(listenAddress);
1948        let tcpExtraOptions: socket.TCPExtraOptions = {
1949          socketTimeout: -1,
1950          socketLinger: {
1951            on: true, linger: 10
1952          }
1953        }
1954        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1955          if (err) {
1956            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1957            expectFail();
1958          } else {
1959            console.info(`${caseName} success`);
1960            expectSuccess();
1961          }
1962          console.info(`${caseName} test end`);
1963          done();
1964        });
1965      } catch (err) {
1966        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1967        expectFail();
1968        console.info(`${caseName} test end`);
1969        done();
1970      }
1971    });
1972
1973    /* *
1974     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2000
1975     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2000
1976     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 0; callback
1977     * @tc.size  : MediumTest
1978     * @tc.type  : Function
1979     * @tc.level : level 2
1980     */
1981    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1982      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2000';
1983      try {
1984        console.info(`${caseName} test start`);
1985        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1986        expect(tcpServer).assertInstanceOf('Object');
1987        let listenAddress: socket.NetAddress = {
1988          address: '127.0.0.1',
1989          port: 11015,
1990          family: 1
1991        };
1992        await tcpServer.listen(listenAddress);
1993        let tcpExtraOptions: socket.TCPExtraOptions = {
1994          socketTimeout:0,
1995          socketLinger: {
1996            on: true, linger: 10
1997          }
1998        }
1999        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2000          if (err) {
2001            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2002            expectFail();
2003          } else {
2004            console.info(`${caseName} success`);
2005            expectSuccess();
2006          }
2007          console.info(`${caseName} test end`);
2008          done();
2009        });
2010      } catch (err) {
2011        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2012        expectFail();
2013        console.info(`${caseName} test end`);
2014        done();
2015      }
2016    });
2017
2018    /* *
2019     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2100
2020     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2100
2021     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 100; callback
2022     * @tc.size  : MediumTest
2023     * @tc.type  : Function
2024     * @tc.level : level 2
2025     */
2026    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2027      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2100';
2028      try {
2029        console.info(`${caseName} test start`);
2030        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2031        expect(tcpServer).assertInstanceOf('Object');
2032        let listenAddress: socket.NetAddress = {
2033          address: '127.0.0.1',
2034          port: 11016,
2035          family: 1
2036        };
2037        await tcpServer.listen(listenAddress);
2038        let tcpExtraOptions: socket.TCPExtraOptions = {
2039          socketTimeout:100,
2040          socketLinger: {
2041            on: true, linger: 10
2042          }
2043        }
2044        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2045          if (err) {
2046            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2047            expectFail();
2048          } else {
2049            console.info(`${caseName} success`);
2050            expectSuccess();
2051          }
2052          console.info(`${caseName} test end`);
2053          done();
2054        });
2055      } catch (err) {
2056        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2057        expectFail();
2058        console.info(`${caseName} test end`);
2059        done();
2060      }
2061    });
2062
2063    /* *
2064     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2200
2065     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2200
2066     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is -1; callback
2067     * @tc.size  : MediumTest
2068     * @tc.type  : Function
2069     * @tc.level : level 2
2070     */
2071    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2072      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2200';
2073      try {
2074        console.info(`${caseName} test start`);
2075        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2076        expect(tcpServer).assertInstanceOf('Object');
2077        let listenAddress: socket.NetAddress = {
2078          address: '127.0.0.1',
2079          port: 11017,
2080          family: 1
2081        };
2082        await tcpServer.listen(listenAddress);
2083        let tcpExtraOptions: socket.TCPExtraOptions = {
2084          socketLinger: {
2085            on: true, linger: -1
2086          }
2087        }
2088        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2089          if (err) {
2090            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2091            expectFail();
2092          } else {
2093            console.info(`${caseName} success`);
2094            expectSuccess();
2095          }
2096          console.info(`${caseName} test end`);
2097          done();
2098        });
2099      } catch (err) {
2100        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2101        expectFail();
2102        console.info(`${caseName} test end`);
2103        done();
2104      }
2105    });
2106
2107    /* *
2108     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2300
2109     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2300
2110     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 0; callback
2111     * @tc.size  : MediumTest
2112     * @tc.type  : Function
2113     * @tc.level : level 2
2114     */
2115    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2116      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2300';
2117      try {
2118        console.info(`${caseName} test start`);
2119        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2120        expect(tcpServer).assertInstanceOf('Object');
2121        let listenAddress: socket.NetAddress = {
2122          address: '127.0.0.1',
2123          port: 11018,
2124          family: 1
2125        };
2126        await tcpServer.listen(listenAddress);
2127        let tcpExtraOptions: socket.TCPExtraOptions = {
2128          socketLinger: {
2129            on: true, linger: 0
2130          }
2131        }
2132        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2133          if (err) {
2134            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2135            expectFail();
2136          } else {
2137            console.info(`${caseName} success`);
2138            expectSuccess();
2139          }
2140          console.info(`${caseName} test end`);
2141          done();
2142        });
2143      } catch (err) {
2144        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2145        expectFail();
2146        console.info(`${caseName} test end`);
2147        done();
2148      }
2149    });
2150
2151    /* *
2152     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2400
2153     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2400
2154     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65535; callback
2155     * @tc.size  : MediumTest
2156     * @tc.type  : Function
2157     * @tc.level : level 2
2158     */
2159    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2160      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2400';
2161      try {
2162        console.info(`${caseName} test start`);
2163        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2164        expect(tcpServer).assertInstanceOf('Object');
2165        let listenAddress: socket.NetAddress = {
2166          address: '127.0.0.1',
2167          port: 11019,
2168          family: 1
2169        };
2170        await tcpServer.listen(listenAddress);
2171        let tcpExtraOptions: socket.TCPExtraOptions = {
2172          socketLinger: {
2173            on: true, linger: 65535
2174          }
2175        }
2176        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2177          if (err) {
2178            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2179            expectFail();
2180          } else {
2181            console.info(`${caseName} success`);
2182            expectSuccess();
2183          }
2184          console.info(`${caseName} test end`);
2185          done();
2186        });
2187      } catch (err) {
2188        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2189        expectFail();
2190        console.info(`${caseName} test end`);
2191        done();
2192      }
2193    });
2194
2195    /* *
2196     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2500
2197     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2500
2198     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65536; callback
2199     * @tc.size  : MediumTest
2200     * @tc.type  : Function
2201     * @tc.level : level 0
2202     */
2203    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2204      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2500';
2205      try {
2206        console.info(`${caseName} test start`);
2207        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2208        expect(tcpServer).assertInstanceOf('Object');
2209        let listenAddress: socket.NetAddress = {
2210          address: '127.0.0.1',
2211          port: 11020,
2212          family: 1
2213        };
2214        await tcpServer.listen(listenAddress);
2215        let tcpExtraOptions: socket.TCPExtraOptions = {
2216          socketLinger: {
2217            on: true, linger: 65536
2218          }
2219        }
2220        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2221          if (err) {
2222            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2223            expectFail();
2224          } else {
2225            console.info(`${caseName} success`);
2226            expectSuccess();
2227          }
2228          console.info(`${caseName} test end`);
2229          done();
2230        });
2231      } catch (err) {
2232        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2233        expectFail();
2234        console.info(`${caseName} test end`);
2235        done();
2236      }
2237    });
2238
2239    /* *
2240     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2600
2241     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2600
2242     * @tc.desc  : Set other properties of the TCP Socket Server connection,before listen; promise
2243     * @tc.size  : MediumTest
2244     * @tc.type  : Function
2245     * @tc.level : level 2
2246     */
2247    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2248      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2600';
2249      try {
2250        console.info(`${caseName} test start`);
2251        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2252        expect(tcpServer).assertInstanceOf('Object');
2253        let tcpExtraOptions: socket.TCPExtraOptions = {
2254          keepAlive: true,
2255          OOBInline: true,
2256          TCPNoDelay: true,
2257          socketLinger: {
2258            on: true, linger: 10
2259          },
2260          receiveBufferSize: 1000,
2261          sendBufferSize: 1000,
2262          reuseAddress: true,
2263          socketTimeout: 3000
2264        };
2265        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2266          console.info(`${caseName} success`);
2267          expectFail();
2268          done();
2269        }).catch((err: BusinessError) => {
2270          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2271          expectTrue(err.code===2303109);
2272          done();
2273        }).finally(() => {
2274          console.info(`${caseName} test end`);
2275          done();
2276        });
2277      } catch (err) {
2278        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2279        expectFail();
2280        console.info(`${caseName} test end`);
2281        done();
2282      }
2283    });
2284
2285    /* *
2286     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2700
2287     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2700
2288     * @tc.desc  : Set other properties of the TCP Socket Server connection after listening; promise
2289     * @tc.size  : MediumTest
2290     * @tc.type  : Function
2291     * @tc.level : level 2
2292     */
2293    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2294      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2700';
2295      try {
2296        console.info(`${caseName} test start`);
2297        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2298        expect(tcpServer).assertInstanceOf('Object');
2299        let listenAddress: socket.NetAddress = {
2300          address: '127.0.0.1',
2301          port: 5019,
2302          family: 1
2303        };
2304        await tcpServer.listen(listenAddress);
2305        let tcpExtraOptions: socket.TCPExtraOptions = {
2306          keepAlive: true,
2307          OOBInline: true,
2308          TCPNoDelay: true,
2309          socketLinger: {
2310            on: true, linger: 10
2311          },
2312          receiveBufferSize: 1000,
2313          sendBufferSize: 1000,
2314          reuseAddress: true,
2315          socketTimeout: 3000
2316        };
2317        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2318          console.info(`${caseName} success`);
2319          expectSuccess();
2320          done();
2321        }).catch((err: BusinessError) => {
2322          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2323          expectFail();
2324          done();
2325        }).finally(() => {
2326          console.info(`${caseName} test end`);
2327          done();
2328        });
2329      } catch (err) {
2330        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2331        expectFail();
2332        console.info(`${caseName} test end`);
2333        done();
2334      }
2335    });
2336
2337    /* *
2338     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2800
2339     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2800
2340     * @tc.desc  : Set other properties of TCPSocketService connection in listen, input parameters are null; promise
2341     * @tc.size  : MediumTest
2342     * @tc.type  : Function
2343     * @tc.level : level 2
2344     */
2345    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2346      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2800';
2347      try {
2348        console.info(`${caseName} test start`);
2349        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2350        expect(tcpServer).assertInstanceOf('Object');
2351        let listenAddress: socket.NetAddress = {
2352          address: '127.0.0.1',
2353          port: 2020,
2354          family: 1
2355        };
2356        await tcpServer.listen(listenAddress);
2357        tcpServer.setExtraOptions(null).then(() => {
2358          console.info(`${caseName} success`);
2359          expectFail();
2360          done();
2361        }).catch((err: BusinessError) => {
2362          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2363          expectTrue(err.code==401);
2364          done();
2365        }).finally(() => {
2366          console.info(`${caseName} test end`);
2367          done();
2368        });
2369      } catch (err) {
2370        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2371        expectTrue(err.code==401);
2372        console.info(`${caseName} test end`);
2373        done();
2374      }
2375    });
2376
2377    /* *
2378     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2900
2379     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2900
2380     * @tc.desc  : Set other properties of TCPSocketService connection in listen,input parameters are undefined;promise
2381     * @tc.size  : MediumTest
2382     * @tc.type  : Function
2383     * @tc.level : level 2
2384     */
2385    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2386      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2900';
2387      try {
2388        console.info(`${caseName} test start`);
2389        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2390        expect(tcpServer).assertInstanceOf('Object');
2391        let listenAddress: socket.NetAddress = {
2392          address: '127.0.0.1',
2393          port: 5021,
2394          family: 1
2395        };
2396        await tcpServer.listen(listenAddress);
2397        tcpServer.setExtraOptions(undefined).then(() => {
2398          console.info(`${caseName} success`);
2399          expectFail();
2400          done();
2401        }).catch((err: BusinessError) => {
2402          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2403          expectTrue(err.code==401);
2404          done();
2405        }).finally(() => {
2406          console.info(`${caseName} test end`);
2407          done();
2408        });
2409      } catch (err) {
2410        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2411        expectTrue(err.code==401);
2412        console.info(`${caseName} test end`);
2413        done();
2414      }
2415    });
2416
2417    /* *
2418     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3000
2419     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3000
2420     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is true; promise
2421     * @tc.size  : MediumTest
2422     * @tc.type  : Function
2423     * @tc.level : level 0
2424     */
2425    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2426      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3000';
2427      try {
2428        console.info(`${caseName} test start`);
2429        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2430        expect(tcpServer).assertInstanceOf('Object');
2431        let listenAddress: socket.NetAddress = {
2432          address: '127.0.0.1',
2433          port: 10101,
2434          family: 1
2435        };
2436        await tcpServer.listen(listenAddress);
2437        let tcpExtraOptions: socket.TCPExtraOptions = {
2438          keepAlive: true,
2439          socketLinger: {
2440            on: true, linger: 10
2441          }
2442        };
2443        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2444          console.info(`${caseName} success`);
2445          expectSuccess();
2446          done();
2447        }).catch((err: BusinessError) => {
2448          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2449          expectFail();
2450          done();
2451        }).finally(() => {
2452          console.info(`${caseName} test end`);
2453          done();
2454        });
2455      } catch (err) {
2456        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2457        expectFail();
2458        console.info(`${caseName} test end`);
2459        done();
2460      }
2461    });
2462
2463    /* *
2464     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3100
2465     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3100
2466     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is false; promise
2467     * @tc.size  : MediumTest
2468     * @tc.type  : Function
2469     * @tc.level : level 2
2470     */
2471    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2472      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3100';
2473      try {
2474        console.info(`${caseName} test start`);
2475        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2476        expect(tcpServer).assertInstanceOf('Object');
2477        let listenAddress: socket.NetAddress = {
2478          address: '127.0.0.1',
2479          port: 10102,
2480          family: 1
2481        };
2482        await tcpServer.listen(listenAddress);
2483        let tcpExtraOptions: socket.TCPExtraOptions = {
2484          keepAlive: false,
2485          socketLinger: {
2486            on: true, linger: 10
2487          }
2488        };
2489        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2490          console.info(`${caseName} success`);
2491          expectSuccess();
2492          done();
2493        }).catch((err: BusinessError) => {
2494          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2495          expectFail();
2496          done();
2497        }).finally(() => {
2498          console.info(`${caseName} test end`);
2499          done();
2500        });
2501      } catch (err) {
2502        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2503        expectFail();
2504        console.info(`${caseName} test end`);
2505        done();
2506      }
2507    });
2508
2509    /* *
2510     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3200
2511     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3200
2512     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is true; promise
2513     * @tc.size  : MediumTest
2514     * @tc.type  : Function
2515     * @tc.level : level 2
2516     */
2517    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2518      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3200';
2519      try {
2520        console.info(`${caseName} test start`);
2521        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2522        expect(tcpServer).assertInstanceOf('Object');
2523        let listenAddress: socket.NetAddress = {
2524          address: '127.0.0.1',
2525          port: 10103,
2526          family: 1
2527        };
2528        await tcpServer.listen(listenAddress);
2529        let tcpExtraOptions: socket.TCPExtraOptions = {
2530          OOBInline: true,
2531          socketLinger: {
2532            on: true, linger: 10
2533          }
2534        };
2535        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2536          console.info(`${caseName} success`);
2537          expectSuccess();
2538          done();
2539        }).catch((err: BusinessError) => {
2540          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2541          expectFail();
2542          done();
2543        }).finally(() => {
2544          console.info(`${caseName} test end`);
2545          done();
2546        });
2547      } catch (err) {
2548        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2549        expectFail();
2550        console.info(`${caseName} test end`);
2551        done();
2552      }
2553    });
2554
2555    /* *
2556     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3300
2557     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3300
2558     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is false; promise
2559     * @tc.size  : MediumTest
2560     * @tc.type  : Function
2561     * @tc.level : level 0
2562     */
2563    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2564      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3300';
2565      try {
2566        console.info(`${caseName} test start`);
2567        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2568        expect(tcpServer).assertInstanceOf('Object');
2569        let listenAddress: socket.NetAddress = {
2570          address: '127.0.0.1',
2571          port: 10104,
2572          family: 1
2573        };
2574        await tcpServer.listen(listenAddress);
2575        let tcpExtraOptions: socket.TCPExtraOptions = {
2576          OOBInline: false,
2577          socketLinger: {
2578            on: true, linger: 10
2579          }
2580        };
2581        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2582          console.info(`${caseName} success`);
2583          expectSuccess();
2584          done();
2585        }).catch((err: BusinessError) => {
2586          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2587          expectFail();
2588          done();
2589        }).finally(() => {
2590          console.info(`${caseName} test end`);
2591          done();
2592        });
2593      } catch (err) {
2594        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2595        expectFail();
2596        console.info(`${caseName} test end`);
2597        done();
2598      }
2599    });
2600
2601    /* *
2602     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3400
2603     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3400
2604     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is true; promise
2605     * @tc.size  : MediumTest
2606     * @tc.type  : Function
2607     * @tc.level : level 2
2608     */
2609    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2610      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3400';
2611      try {
2612        console.info(`${caseName} test start`);
2613        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2614        expect(tcpServer).assertInstanceOf('Object');
2615        let listenAddress: socket.NetAddress = {
2616          address: '127.0.0.1',
2617          port: 10105,
2618          family: 1
2619        };
2620        await tcpServer.listen(listenAddress);
2621        let tcpExtraOptions: socket.TCPExtraOptions = {
2622          TCPNoDelay: true,
2623          socketLinger: {
2624            on: true, linger: 10
2625          }
2626        };
2627        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2628          console.info(`${caseName} success`);
2629          expectSuccess();
2630          done();
2631        }).catch((err: BusinessError) => {
2632          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2633          expectFail();
2634          done();
2635        }).finally(() => {
2636          console.info(`${caseName} test end`);
2637          done();
2638        });
2639      } catch (err) {
2640        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2641        expectFail();
2642        console.info(`${caseName} test end`);
2643        done();
2644      }
2645    });
2646
2647    /* *
2648     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3500
2649     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3500
2650     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is false; promise
2651     * @tc.size  : MediumTest
2652     * @tc.type  : Function
2653     * @tc.level : level 2
2654     */
2655    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2656      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3500';
2657      try {
2658        console.info(`${caseName} test start`);
2659        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2660        expect(tcpServer).assertInstanceOf('Object');
2661        let listenAddress: socket.NetAddress = {
2662          address: '127.0.0.1',
2663          port: 10106,
2664          family: 1
2665        };
2666        await tcpServer.listen(listenAddress);
2667        let tcpExtraOptions: socket.TCPExtraOptions = {
2668          TCPNoDelay: false,
2669          socketLinger: {
2670            on: true, linger: 10
2671          }
2672        };
2673        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2674          console.info(`${caseName} success`);
2675          expectSuccess();
2676          done();
2677        }).catch((err: BusinessError) => {
2678          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2679          expectFail();
2680          done();
2681        }).finally(() => {
2682          console.info(`${caseName} test end`);
2683          done();
2684        });
2685      } catch (err) {
2686        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2687        expectFail();
2688        console.info(`${caseName} test end`);
2689        done();
2690      }
2691    });
2692
2693    /* *
2694     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3600
2695     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3600
2696     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is -1; promise
2697     * @tc.size  : MediumTest
2698     * @tc.type  : Function
2699     * @tc.level : level 2
2700     */
2701    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2702      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3600';
2703      try {
2704        console.info(`${caseName} test start`);
2705        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2706        expect(tcpServer).assertInstanceOf('Object');
2707        let listenAddress: socket.NetAddress = {
2708          address: '127.0.0.1',
2709          port: 10107,
2710          family: 1
2711        };
2712        await tcpServer.listen(listenAddress);
2713        let tcpExtraOptions: socket.TCPExtraOptions = {
2714          receiveBufferSize: -1,
2715          socketLinger: {
2716            on: true, linger: 10
2717          }
2718        };
2719        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2720          console.info(`${caseName} success`);
2721          expectSuccess();
2722          done();
2723        }).catch((err: BusinessError) => {
2724          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2725          expectFail();
2726          done();
2727        }).finally(() => {
2728          console.info(`${caseName} test end`);
2729          done();
2730        });
2731      } catch (err) {
2732        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2733        expectFail();
2734        console.info(`${caseName} test end`);
2735        done();
2736      }
2737    });
2738
2739    /* *
2740     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3700
2741     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3700
2742     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 0; promise
2743     * @tc.size  : MediumTest
2744     * @tc.type  : Function
2745     * @tc.level : level 2
2746     */
2747    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2748      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3700';
2749      try {
2750        console.info(`${caseName} test start`);
2751        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2752        expect(tcpServer).assertInstanceOf('Object');
2753        let listenAddress: socket.NetAddress = {
2754          address: '127.0.0.1',
2755          port: 10108,
2756          family: 1
2757        };
2758        await tcpServer.listen(listenAddress);
2759        let tcpExtraOptions: socket.TCPExtraOptions = {
2760          receiveBufferSize: 0,
2761          socketLinger: {
2762            on: true, linger: 10
2763          }
2764        };
2765        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2766          console.info(`${caseName} success`);
2767          expectSuccess();
2768          done();
2769        }).catch((err: BusinessError) => {
2770          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2771          expectFail();
2772          done();
2773        }).finally(() => {
2774          console.info(`${caseName} test end`);
2775          done();
2776        });
2777      } catch (err) {
2778        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2779        expectFail();
2780        console.info(`${caseName} test end`);
2781        done();
2782      }
2783    });
2784
2785    /* *
2786     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3800
2787     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3800
2788     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 100; promise
2789     * @tc.size  : MediumTest
2790     * @tc.type  : Function
2791     * @tc.level : level 2
2792     */
2793    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2794      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3800';
2795      try {
2796        console.info(`${caseName} test start`);
2797        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2798        expect(tcpServer).assertInstanceOf('Object');
2799        let listenAddress: socket.NetAddress = {
2800          address: '127.0.0.1',
2801          port: 10109,
2802          family: 1
2803        };
2804        await tcpServer.listen(listenAddress);
2805        let tcpExtraOptions: socket.TCPExtraOptions = {
2806          receiveBufferSize: 100,
2807          socketLinger: {
2808            on: true, linger: 10
2809          }
2810        };
2811        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2812          console.info(`${caseName} success`);
2813          expectSuccess();
2814          done();
2815        }).catch((err: BusinessError) => {
2816          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2817          expectFail();
2818          done();
2819        }).finally(() => {
2820          console.info(`${caseName} test end`);
2821          done();
2822        });
2823      } catch (err) {
2824        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2825        expectFail();
2826        console.info(`${caseName} test end`);
2827        done();
2828      }
2829    });
2830
2831    /* *
2832     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3900
2833     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3900
2834     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is -1; promise
2835     * @tc.size  : MediumTest
2836     * @tc.type  : Function
2837     * @tc.level : level 2
2838     */
2839    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2840      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3900';
2841      try {
2842        console.info(`${caseName} test start`);
2843        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2844        expect(tcpServer).assertInstanceOf('Object');
2845        let listenAddress: socket.NetAddress = {
2846          address: '127.0.0.1',
2847          port: 10110,
2848          family: 1
2849        };
2850        await tcpServer.listen(listenAddress);
2851        let tcpExtraOptions: socket.TCPExtraOptions = {
2852          sendBufferSize: -1,
2853          socketLinger: {
2854            on: true, linger: 10
2855          }
2856        };
2857        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2858          console.info(`${caseName} success`);
2859          expectSuccess();
2860          done();
2861        }).catch((err: BusinessError) => {
2862          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2863          expectFail();
2864          done();
2865        }).finally(() => {
2866          console.info(`${caseName} test end`);
2867          done();
2868        });
2869      } catch (err) {
2870        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2871        expectFail();
2872        console.info(`${caseName} test end`);
2873        done();
2874      }
2875    });
2876
2877    /* *
2878     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4000
2879     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4000
2880     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 0; promise
2881     * @tc.size  : MediumTest
2882     * @tc.type  : Function
2883     * @tc.level : level 2
2884     */
2885    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2886      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4000';
2887      try {
2888        console.info(`${caseName} test start`);
2889        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2890        expect(tcpServer).assertInstanceOf('Object');
2891        let listenAddress: socket.NetAddress = {
2892          address: '127.0.0.1',
2893          port: 10111,
2894          family: 1
2895        };
2896        await tcpServer.listen(listenAddress);
2897        let tcpExtraOptions: socket.TCPExtraOptions = {
2898          sendBufferSize: 0,
2899          socketLinger: {
2900            on: true, linger: 10
2901          }
2902        };
2903        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2904          console.info(`${caseName} success`);
2905          expectSuccess();
2906          done();
2907        }).catch((err: BusinessError) => {
2908          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2909          expectFail();
2910          done();
2911        }).finally(() => {
2912          console.info(`${caseName} test end`);
2913          done();
2914        });
2915      } catch (err) {
2916        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2917        expectFail();
2918        console.info(`${caseName} test end`);
2919        done();
2920      }
2921    });
2922
2923    /* *
2924     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4100
2925     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4100
2926     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 100; promise
2927     * @tc.size  : MediumTest
2928     * @tc.type  : Function
2929     * @tc.level : level 2
2930     */
2931    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2932      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4100';
2933      try {
2934        console.info(`${caseName} test start`);
2935        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2936        expect(tcpServer).assertInstanceOf('Object');
2937        let listenAddress: socket.NetAddress = {
2938          address: '127.0.0.1',
2939          port: 10112,
2940          family: 1
2941        };
2942        await tcpServer.listen(listenAddress);
2943        let tcpExtraOptions: socket.TCPExtraOptions = {
2944          sendBufferSize: 100,
2945          socketLinger: {
2946            on: true, linger: 10
2947          }
2948        };
2949        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2950          console.info(`${caseName} success`);
2951          expectSuccess();
2952          done();
2953        }).catch((err: BusinessError) => {
2954          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2955          expectFail();
2956          done();
2957        }).finally(() => {
2958          console.info(`${caseName} test end`);
2959          done();
2960        });
2961      } catch (err) {
2962        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2963        expectFail();
2964        console.info(`${caseName} test end`);
2965        done();
2966      }
2967    });
2968
2969    /* *
2970     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4200
2971     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4200
2972     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is true; promise
2973     * @tc.size  : MediumTest
2974     * @tc.type  : Function
2975     * @tc.level : level 2
2976     */
2977    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2978      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4200';
2979      try {
2980        console.info(`${caseName} test start`);
2981        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2982        expect(tcpServer).assertInstanceOf('Object');
2983        let listenAddress: socket.NetAddress = {
2984          address: '127.0.0.1',
2985          port: 10113,
2986          family: 1
2987        };
2988        await tcpServer.listen(listenAddress);
2989        let tcpExtraOptions: socket.TCPExtraOptions = {
2990          reuseAddress: true,
2991          socketLinger: {
2992            on: true, linger: 10
2993          }
2994        };
2995        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2996          console.info(`${caseName} success`);
2997          expectSuccess();
2998          done();
2999        }).catch((err: BusinessError) => {
3000          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3001          expectFail();
3002          done();
3003        }).finally(() => {
3004          console.info(`${caseName} test end`);
3005          done();
3006        });
3007      } catch (err) {
3008        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3009        expectFail();
3010        console.info(`${caseName} test end`);
3011        done();
3012      }
3013    });
3014
3015    /* *
3016     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4300
3017     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4300
3018     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is false; promise
3019     * @tc.size  : MediumTest
3020     * @tc.type  : Function
3021     * @tc.level : level 2
3022     */
3023    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3024      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4300';
3025      try {
3026        console.info(`${caseName} test start`);
3027        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3028        expect(tcpServer).assertInstanceOf('Object');
3029        let listenAddress: socket.NetAddress = {
3030          address: '127.0.0.1',
3031          port: 10114,
3032          family: 1
3033        };
3034        await tcpServer.listen(listenAddress);
3035        let tcpExtraOptions: socket.TCPExtraOptions = {
3036          reuseAddress: false,
3037          socketLinger: {
3038            on: true, linger: 10
3039          }
3040        };
3041        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3042          console.info(`${caseName} success`);
3043          expectSuccess();
3044          done();
3045        }).catch((err: BusinessError) => {
3046          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3047          expectFail();
3048          done();
3049        }).finally(() => {
3050          console.info(`${caseName} test end`);
3051          done();
3052        });
3053      } catch (err) {
3054        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3055        expectFail();
3056        console.info(`${caseName} test end`);
3057        done();
3058      }
3059    });
3060
3061    /* *
3062     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4400
3063     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4400
3064     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is -1; promise
3065     * @tc.size  : MediumTest
3066     * @tc.type  : Function
3067     * @tc.level : level 2
3068     */
3069    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3070      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4400';
3071      try {
3072        console.info(`${caseName} test start`);
3073        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3074        expect(tcpServer).assertInstanceOf('Object');
3075        let listenAddress: socket.NetAddress = {
3076          address: '127.0.0.1',
3077          port: 10115,
3078          family: 1
3079        };
3080        await tcpServer.listen(listenAddress);
3081        let tcpExtraOptions: socket.TCPExtraOptions = {
3082          socketTimeout: -1,
3083          socketLinger: {
3084            on: true, linger: 10
3085          }
3086        };
3087        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3088          console.info(`${caseName} success`);
3089          expectSuccess();
3090          done();
3091        }).catch((err: BusinessError) => {
3092          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3093          expectFail();
3094          done();
3095        }).finally(() => {
3096          console.info(`${caseName} test end`);
3097          done();
3098        });
3099      } catch (err) {
3100        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3101        expectFail();
3102        console.info(`${caseName} test end`);
3103        done();
3104      }
3105    });
3106
3107    /* *
3108     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4500
3109     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4500
3110     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 0; promise
3111     * @tc.size  : MediumTest
3112     * @tc.type  : Function
3113     * @tc.level : level 2
3114     */
3115    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3116      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4500';
3117      try {
3118        console.info(`${caseName} test start`);
3119        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3120        expect(tcpServer).assertInstanceOf('Object');
3121        let listenAddress: socket.NetAddress = {
3122          address: '127.0.0.1',
3123          port: 10116,
3124          family: 1
3125        };
3126        await tcpServer.listen(listenAddress);
3127        let tcpExtraOptions: socket.TCPExtraOptions = {
3128          socketTimeout: 0,
3129          socketLinger: {
3130            on: true, linger: 10
3131          }
3132        };
3133        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3134          console.info(`${caseName} success`);
3135          expectSuccess();
3136          done();
3137        }).catch((err: BusinessError) => {
3138          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3139          expectFail();
3140          done();
3141        }).finally(() => {
3142          console.info(`${caseName} test end`);
3143          done();
3144        });
3145      } catch (err) {
3146        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3147        expectFail();
3148        console.info(`${caseName} test end`);
3149        done();
3150      }
3151    });
3152
3153    /* *
3154     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4600
3155     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4600
3156     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 100; promise
3157     * @tc.size  : MediumTest
3158     * @tc.type  : Function
3159     * @tc.level : level 2
3160     */
3161    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3162      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4600';
3163      try {
3164        console.info(`${caseName} test start`);
3165        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3166        expect(tcpServer).assertInstanceOf('Object');
3167        let listenAddress: socket.NetAddress = {
3168          address: '127.0.0.1',
3169          port: 10117,
3170          family: 1
3171        };
3172        await tcpServer.listen(listenAddress);
3173        let tcpExtraOptions: socket.TCPExtraOptions = {
3174          socketTimeout: 100,
3175          socketLinger: {
3176            on: true, linger: 10
3177          }
3178        };
3179        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3180          console.info(`${caseName} success`);
3181          expectSuccess();
3182          done();
3183        }).catch((err: BusinessError) => {
3184          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3185          expectFail();
3186          done();
3187        }).finally(() => {
3188          console.info(`${caseName} test end`);
3189          done();
3190        });
3191      } catch (err) {
3192        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3193        expectFail();
3194        console.info(`${caseName} test end`);
3195        done();
3196      }
3197    });
3198
3199    /* *
3200     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4700
3201     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4700
3202     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is -1; promise
3203     * @tc.size  : MediumTest
3204     * @tc.type  : Function
3205     * @tc.level : level 2
3206     */
3207    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3208      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4700';
3209      try {
3210        console.info(`${caseName} test start`);
3211        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3212        expect(tcpServer).assertInstanceOf('Object');
3213        let listenAddress: socket.NetAddress = {
3214          address: '127.0.0.1',
3215          port: 10118,
3216          family: 1
3217        };
3218        await tcpServer.listen(listenAddress);
3219        let tcpExtraOptions: socket.TCPExtraOptions = {
3220          socketLinger: {
3221            on: true, linger: -1
3222          }
3223        };
3224        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3225          console.info(`${caseName} success`);
3226          expectSuccess();
3227          done();
3228        }).catch((err: BusinessError) => {
3229          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3230          expectFail();
3231          done();
3232        }).finally(() => {
3233          console.info(`${caseName} test end`);
3234          done();
3235        });
3236      } catch (err) {
3237        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3238        expectFail();
3239        console.info(`${caseName} test end`);
3240        done();
3241      }
3242    });
3243
3244    /* *
3245     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4800
3246     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4800
3247     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 0; promise
3248     * @tc.size  : MediumTest
3249     * @tc.type  : Function
3250     * @tc.level : level 2
3251     */
3252    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3253      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4800';
3254      try {
3255        console.info(`${caseName} test start`);
3256        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3257        expect(tcpServer).assertInstanceOf('Object');
3258        let listenAddress: socket.NetAddress = {
3259          address: '127.0.0.1',
3260          port: 10119,
3261          family: 1
3262        };
3263        await tcpServer.listen(listenAddress);
3264        let tcpExtraOptions: socket.TCPExtraOptions = {
3265          socketLinger: {
3266            on: true, linger: 0
3267          }
3268        };
3269        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3270          console.info(`${caseName} success`);
3271          expectSuccess();
3272          done();
3273        }).catch((err: BusinessError) => {
3274          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3275          expectFail();
3276          done();
3277        }).finally(() => {
3278          console.info(`${caseName} test end`);
3279          done();
3280        });
3281      } catch (err) {
3282        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3283        expectFail();
3284        console.info(`${caseName} test end`);
3285        done();
3286      }
3287    });
3288
3289    /* *
3290     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4900
3291     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4900
3292     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65535; promise
3293     * @tc.size  : MediumTest
3294     * @tc.type  : Function
3295     * @tc.level : level 2
3296     */
3297    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3298      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4900';
3299      try {
3300        console.info(`${caseName} test start`);
3301        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3302        expect(tcpServer).assertInstanceOf('Object');
3303        let listenAddress: socket.NetAddress = {
3304          address: '127.0.0.1',
3305          port: 10120,
3306          family: 1
3307        };
3308        await tcpServer.listen(listenAddress);
3309        let tcpExtraOptions: socket.TCPExtraOptions = {
3310          socketLinger: {
3311            on: true, linger: 65535
3312          }
3313        };
3314        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3315          console.info(`${caseName} success`);
3316          expectSuccess();
3317          done();
3318        }).catch((err: BusinessError) => {
3319          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3320          expectFail();
3321          done();
3322        }).finally(() => {
3323          console.info(`${caseName} test end`);
3324          done();
3325        });
3326      } catch (err) {
3327        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3328        expectFail();
3329        console.info(`${caseName} test end`);
3330        done();
3331      }
3332    });
3333
3334    /* *
3335     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_5000
3336     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions5000
3337     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65536; promise
3338     * @tc.size  : MediumTest
3339     * @tc.type  : Function
3340     * @tc.level : level 2
3341     */
3342    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions5000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3343      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions5000';
3344      try {
3345        console.info(`${caseName} test start`);
3346        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3347        expect(tcpServer).assertInstanceOf('Object');
3348        let listenAddress: socket.NetAddress = {
3349          address: '127.0.0.1',
3350          port: 10121,
3351          family: 1
3352        };
3353        await tcpServer.listen(listenAddress);
3354        let tcpExtraOptions: socket.TCPExtraOptions = {
3355          socketLinger: {
3356            on: true, linger: 65536
3357          }
3358        };
3359        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3360          console.info(`${caseName} success`);
3361          expectSuccess();
3362          done();
3363        }).catch((err: BusinessError) => {
3364          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3365          expectFail();
3366          done();
3367        }).finally(() => {
3368          console.info(`${caseName} test end`);
3369          done();
3370        });
3371      } catch (err) {
3372        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3373        expectFail();
3374        console.info(`${caseName} test end`);
3375        done();
3376      }
3377    });
3378
3379    /* *
3380     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OnConnect_0100
3381     * @tc.name  : testNetworkMgrSocketTCPSocketServerOnConnect0100
3382     * @tc.desc  : Subscription to TCP Socket Server connection events;
3383     * @tc.size  : MediumTest
3384     * @tc.type  : Function
3385     * @tc.level : level 2
3386     */
3387    it('testNetworkMgrSocketTCPSocketServerOnConnect0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3388      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOnConnect0100';
3389      try {
3390        console.info(`${caseName} test start`);
3391        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3392        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3393        expect(tcpServer).assertInstanceOf('Object');
3394        let listenAddress: socket.NetAddress = {
3395          address: '127.0.0.1',
3396          port: 5022,
3397          family: 1
3398        };
3399        await tcpServer.listen(listenAddress);
3400        let callback: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3401          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3402          expectTrue(data.clientId!==null);
3403          console.info(`${caseName} test end`);
3404          done();
3405        };
3406        tcpServer.on('connect',callback);
3407        let tcpConnectOptions:socket.TCPConnectOptions={
3408        address:listenAddress
3409        };
3410        await tcp.connect(tcpConnectOptions);
3411      } catch (err) {
3412        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3413        expectFail();
3414        console.info(`${caseName} test end`);
3415        done();
3416      }
3417    });
3418
3419    /* *
3420     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OffConnect_0100
3421     * @tc.name  : testNetworkMgrSocketTCPSocketServerOffConnect0100
3422     * @tc.desc  : Unsubscribe from TCP Socket Server connection events;
3423     * @tc.size  : MediumTest
3424     * @tc.type  : Function
3425     * @tc.level : level 2
3426     */
3427    it('testNetworkMgrSocketTCPSocketServerOffConnect0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3428      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOffConnect0100';
3429      try {
3430        console.info(`${caseName} test start`);
3431        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3432        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3433        expect(tcpServer).assertInstanceOf('Object');
3434        let listenAddress: socket.NetAddress = {
3435          address: '127.0.0.1',
3436          port: 5023,
3437          family: 1
3438        };
3439        await tcpServer.listen(listenAddress);
3440        let callback: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3441          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3442          expectFail();
3443          console.info(`${caseName} test end`);
3444          done();
3445        }
3446        tcpServer.on('connect',callback);
3447        let tcpConnectOptions:socket.TCPConnectOptions={
3448          address:listenAddress
3449        };
3450        tcpServer.off('connect');
3451        await tcp.connect(tcpConnectOptions);
3452        expectSuccess();
3453        console.info(`${caseName} test end`);
3454        done();
3455      } catch (err) {
3456        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3457        expectFail();
3458        console.info(`${caseName} test end`);
3459        done();
3460      }
3461    });
3462
3463    /* *
3464     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OffConnect_0200
3465     * @tc.name  : testNetworkMgrSocketTCPSocketServerOffConnect0200
3466     * @tc.desc  : Unsubscribe from all connection events of TCP Socket Server;
3467     * @tc.size  : MediumTest
3468     * @tc.type  : Function
3469     * @tc.level : level 2
3470     */
3471    it('testNetworkMgrSocketTCPSocketServerOffConnect0200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3472      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOffConnect0200';
3473      try {
3474        console.info(`${caseName} test start`);
3475        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3476        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3477        expect(tcpServer).assertInstanceOf('Object');
3478        let listenAddress: socket.NetAddress = {
3479          address: '127.0.0.1',
3480          port: 5024,
3481          family: 1
3482        };
3483        await tcpServer.listen(listenAddress);
3484        let callback1: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3485          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3486          expectFail();
3487          console.info(`${caseName} test end`);
3488          done();
3489        };
3490        let callback2 : Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3491          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3492          expectFail();
3493          console.info(`${caseName} test end`);
3494          done();
3495        };
3496        tcpServer.on('connect',callback1);
3497        tcpServer.on('connect',callback2);
3498        let tcpConnectOptions:socket.TCPConnectOptions={
3499          address:listenAddress
3500        };
3501        tcpServer.off('connect');
3502        await tcp.connect(tcpConnectOptions);
3503        expectSuccess();
3504        console.info(`${caseName} test end`);
3505        done();
3506      } catch (err) {
3507        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3508        expectFail();
3509        console.info(`${caseName} test end`);
3510        done();
3511      }
3512    });
3513  })
3514}
3515