• 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).catch((err:BusinessError) => {
968            console.info('fail to listen' + err.code.toString());
969        });
970        let tcpConnectOptions: socket.TCPConnectOptions = {
971          address: listenAddress,
972          timeout: 2000
973        };
974        await tcp.connect(tcpConnectOptions).catch((err:BusinessError) => {
975            console.info('fail to connect' + err.code.toString());
976        });
977        tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => {
978          if (err) {
979            console.info(`${caseName} fail err:${JSON.stringify(err)}`);
980            expectFail();
981            done();
982          } else {
983            console.info(`${caseName} success data:${JSON.stringify(data)}`);
984            expectEqual(data.isBound, true);
985            expectEqual(data.isClose, false);
986            expectEqual(data.isConnected, true);
987            done();
988          }
989          console.info(`${caseName} test end`);
990          done();
991        });
992      } catch (err) {
993        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
994        expectFail();
995        console.info(`${caseName} test end`);
996        done();
997      }
998    });
999
1000    /* *
1001     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0400
1002     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0400
1003     * @tc.desc  : Obtain TCPSocketService status without listening; promise
1004     * @tc.size  : MediumTest
1005     * @tc.type  : Function
1006     * @tc.level : level 2
1007     */
1008    it('testNetworkMgrSocketTCPSocketServerGetState0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1009      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0400'
1010      try {
1011        console.info(`${caseName} test start`);
1012        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1013        expect(tcpServer).assertInstanceOf('Object');
1014        tcpServer.getState().then((data: socket.SocketStateBase) => {
1015          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1016          expectEqual(data.isBound, false);
1017          expectEqual(data.isClose, false);
1018          expectEqual(data.isConnected, false);
1019          done();
1020        }).catch((err: BusinessError) => {
1021          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1022          expectFail();
1023          done();
1024        }).finally(() => {
1025          console.info(`${caseName} test end`);
1026          done();
1027        });
1028      } catch (err) {
1029        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1030        expectFail();
1031        console.info(`${caseName} test end`);
1032        done();
1033      }
1034    });
1035
1036    /* *
1037     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0500
1038     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0500
1039     * @tc.desc  : Obtain the TCP Socket Server status after listening; promise
1040     * @tc.size  : MediumTest
1041     * @tc.type  : Function
1042     * @tc.level : level 2
1043     */
1044    it('testNetworkMgrSocketTCPSocketServerGetState0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1045      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0500'
1046      try {
1047        console.info(`${caseName} test start`);
1048        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1049        expect(tcpServer).assertInstanceOf('Object');
1050        let listenAddress: socket.NetAddress = {
1051          address: '127.0.0.1',
1052          port: 5014,
1053          family: 1
1054        };
1055        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1056            console.info('fail to listen' + err.code.toString());
1057        });
1058        tcpServer.getState().then((data: socket.SocketStateBase) => {
1059          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1060          expectEqual(data.isBound, true);
1061          expectEqual(data.isClose, false);
1062          expectEqual(data.isConnected, true);
1063          done();
1064        }).catch((err: BusinessError) => {
1065          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1066          expectFail();
1067          done();
1068        }).finally(() => {
1069          console.info(`${caseName} test end`);
1070          done();
1071        });
1072      } catch (err) {
1073        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1074        expectFail();
1075        console.info(`${caseName} test end`);
1076        done();
1077      }
1078    });
1079
1080    /* *
1081     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_GetState_0600
1082     * @tc.name  : testNetworkMgrSocketTCPSocketServerGetState0600
1083     * @tc.desc  : Obtain the TCP Socket Server status after connect; promise
1084     * @tc.size  : MediumTest
1085     * @tc.type  : Function
1086     * @tc.level : level 0
1087     */
1088    it('testNetworkMgrSocketTCPSocketServerGetState0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
1089      let caseName: string = 'testNetworkMgrSocketTCPSocketServerGetState0600';
1090      try {
1091        console.info(`${caseName} test start`);
1092        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
1093        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1094        expect(tcpServer).assertInstanceOf('Object');
1095        let listenAddress: socket.NetAddress = {
1096          address: '127.0.0.1',
1097          port: 5015,
1098          family: 1
1099        };
1100        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1101            console.info('fail to listen' + err.code.toString());
1102        });
1103        let tcpConnectOptions: socket.TCPConnectOptions = {
1104          address: listenAddress,
1105          timeout: 2000
1106        };
1107        await tcp.connect(tcpConnectOptions).catch((err:BusinessError) => {
1108            console.info('fail to connect' + err.code.toString());
1109        });
1110        tcpServer.getState().then((data: socket.SocketStateBase) => {
1111          console.info(`${caseName} success data:${JSON.stringify(data)}`);
1112          expectEqual(data.isBound, true);
1113          expectEqual(data.isClose, false);
1114          expectEqual(data.isConnected, true);
1115          done();
1116        }).catch((err: BusinessError) => {
1117          console.info(`${caseName} fail err:${JSON.stringify(err)}`);
1118          expectFail();
1119          done();
1120        }).finally(() => {
1121          console.info(`${caseName} test end`);
1122          done();
1123        });
1124      } catch (err) {
1125        console.info(`${caseName}_catch fail err:${JSON.stringify(err)}`);
1126        expectFail();
1127        console.info(`${caseName} test end`);
1128        done();
1129      }
1130    });
1131
1132    /* *
1133     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0100
1134     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0100
1135     * @tc.desc  : Set other properties of the TCP Socket Server connection,before listen; callback
1136     * @tc.size  : MediumTest
1137     * @tc.type  : Function
1138     * @tc.level : level 2
1139     */
1140    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1141      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0100';
1142      try {
1143        console.info(`${caseName} test start`);
1144        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1145        expect(tcpServer).assertInstanceOf('Object');
1146        let tcpExtraOptions: socket.TCPExtraOptions = {
1147          keepAlive: true,
1148          OOBInline: true,
1149          TCPNoDelay: true,
1150          socketLinger: {
1151            on: true, linger: 10
1152          },
1153          receiveBufferSize: 1000,
1154          sendBufferSize: 1000,
1155          reuseAddress: true,
1156          socketTimeout: 3000
1157        };
1158        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1159          if (err) {
1160            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1161            expectTrue(err.code===2303109);
1162            done();
1163          } else {
1164            console.info(`${caseName} success`);
1165            expectFail();
1166            done();
1167          }
1168          console.info(`${caseName} test end`);
1169          done();
1170        });
1171      } catch (err) {
1172        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1173        expectFail();
1174        console.info(`${caseName} test end`);
1175        done();
1176      }
1177    });
1178
1179    /* *
1180     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0200
1181     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0200
1182     * @tc.desc  : Set other properties of the TCP Socket Server connection after listening; callback
1183     * @tc.size  : MediumTest
1184     * @tc.type  : Function
1185     * @tc.level : level 2
1186     */
1187    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1188      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0200';
1189      try {
1190        console.info(`${caseName} test start`);
1191        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1192        expect(tcpServer).assertInstanceOf('Object');
1193        let listenAddress: socket.NetAddress = {
1194          address: '127.0.0.1',
1195          port: 5016,
1196          family: 1
1197        };
1198        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1199            console.info('fail to listen' + err.code.toString());
1200        });
1201        let tcpExtraOptions: socket.TCPExtraOptions = {
1202          keepAlive: true,
1203          OOBInline: true,
1204          TCPNoDelay: true,
1205          socketLinger: {
1206            on: true, linger: 10
1207          },
1208          receiveBufferSize: 1000,
1209          sendBufferSize: 1000,
1210          reuseAddress: true,
1211          socketTimeout: 3000
1212        };
1213        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1214          if (err) {
1215            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1216            expectFail();
1217          } else {
1218            console.info(`${caseName} success`);
1219            expectSuccess();
1220          }
1221          console.info(`${caseName} test end`);
1222          done();
1223        });
1224      } catch (err) {
1225        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1226        expectFail();
1227        console.info(`${caseName} test end`);
1228        done();
1229      }
1230    });
1231
1232    /* *
1233     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0300
1234     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0300
1235     * @tc.desc  : Set other properties of TCPSocketService connection in listen, input parameters are null;callback
1236     * @tc.size  : MediumTest
1237     * @tc.type  : Function
1238     * @tc.level : level 2
1239     */
1240    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1241      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0300';
1242      try {
1243        console.info(`${caseName} test start`);
1244        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1245        expect(tcpServer).assertInstanceOf('Object');
1246        let listenAddress: socket.NetAddress = {
1247          address: '127.0.0.1',
1248          port: 5017,
1249          family: 1
1250        };
1251        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1252            console.info('fail to listen' + err.code.toString());
1253        });
1254        tcpServer.setExtraOptions(null, (err: BusinessError) => {
1255          if (err) {
1256            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1257            expectTrue(err.code==401);
1258          } else {
1259            console.info(`${caseName} success`);
1260            expectFail();
1261          }
1262          console.info(`${caseName} test end`);
1263          done();
1264        });
1265      } catch (err) {
1266        console.info(`${caseName}_catch fail ${JSON.stringify(err)}`);
1267        expectTrue(err.code==401);
1268        console.info(`${caseName} test end`);
1269        done();
1270      }
1271    });
1272
1273    /* *
1274     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0400
1275     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0400
1276     * @tc.desc  : Set other properties of TCPSocketService connection in listen,input parameters are undefined;callback
1277     * @tc.size  : MediumTest
1278     * @tc.type  : Function
1279     * @tc.level : level 2
1280     */
1281    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1282      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0400';
1283      try {
1284        console.info(`${caseName} test start`);
1285        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1286        expect(tcpServer).assertInstanceOf('Object');
1287        let listenAddress: socket.NetAddress = {
1288          address: '127.0.0.1',
1289          port: 5018,
1290          family: 1
1291        };
1292        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1293            console.info('fail to listen' + err.code.toString());
1294        });
1295        tcpServer.setExtraOptions(undefined, (err: BusinessError) => {
1296          if (err) {
1297            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1298            expectTrue(err.code==401);
1299          } else {
1300            console.info(`${caseName} success`);
1301            expectFail();
1302          }
1303          console.info(`${caseName} test end`);
1304          done();
1305        });
1306      } catch (err) {
1307        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1308        expectTrue(err.code==401);
1309        console.info(`${caseName} test end`);
1310        done();
1311      }
1312    });
1313
1314    /* *
1315     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0500
1316     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0500
1317     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is true; callback
1318     * @tc.size  : MediumTest
1319     * @tc.type  : Function
1320     * @tc.level : level 2
1321     */
1322    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1323      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0500';
1324      try {
1325        console.info(`${caseName} test start`);
1326        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1327        expect(tcpServer).assertInstanceOf('Object');
1328        let listenAddress: socket.NetAddress = {
1329          address: '127.0.0.1',
1330          port: 11001,
1331          family: 1
1332        };
1333        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1334            console.info('fail to listen' + err.code.toString());
1335        });
1336        let tcpExtraOptions: socket.TCPExtraOptions = {
1337          keepAlive: true,
1338          socketLinger: {
1339            on: true, linger: 10
1340          }
1341        };
1342        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1343          if (err) {
1344            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1345            expectFail();
1346          } else {
1347            console.info(`${caseName} success`);
1348            expectSuccess();
1349          }
1350          console.info(`${caseName} test end`);
1351          done();
1352        });
1353      } catch (err) {
1354        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1355        expectFail();
1356        console.info(`${caseName} test end`);
1357        done();
1358      }
1359    });
1360
1361    /* *
1362     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0600
1363     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0600
1364     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is false; callback
1365     * @tc.size  : MediumTest
1366     * @tc.type  : Function
1367     * @tc.level : level 2
1368     */
1369    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1370      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0600';
1371      try {
1372        console.info(`${caseName} test start`);
1373        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1374        expect(tcpServer).assertInstanceOf('Object');
1375        let listenAddress: socket.NetAddress = {
1376          address: '127.0.0.1',
1377          port: 11002,
1378          family: 1
1379        };
1380        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1381            console.info('fail to listen' + err.code.toString());
1382        });
1383        let tcpExtraOptions: socket.TCPExtraOptions = {
1384          keepAlive: false,
1385          socketLinger: {
1386            on: true, linger: 10
1387          }
1388        };
1389        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1390          if (err) {
1391            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1392            expectFail();
1393          } else {
1394            console.info(`${caseName} success`);
1395            expectSuccess();
1396          }
1397          console.info(`${caseName} test end`);
1398          done();
1399        });
1400      } catch (err) {
1401        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1402        expectFail();
1403        console.info(`${caseName} test end`);
1404        done();
1405      }
1406    });
1407
1408    /* *
1409     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0700
1410     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0700
1411     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is true; callback
1412     * @tc.size  : MediumTest
1413     * @tc.type  : Function
1414     * @tc.level : level 2
1415     */
1416    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1417      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0700';
1418      try {
1419        console.info(`${caseName} test start`);
1420        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1421        expect(tcpServer).assertInstanceOf('Object');
1422        let listenAddress: socket.NetAddress = {
1423          address: '127.0.0.1',
1424          port: 11003,
1425          family: 1
1426        };
1427        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1428            console.info('fail to listen' + err.code.toString());
1429        });
1430        let tcpExtraOptions: socket.TCPExtraOptions = {
1431          OOBInline: true,
1432          socketLinger: {
1433            on: true, linger: 10
1434          }
1435        }
1436        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1437          if (err) {
1438            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1439            expectFail();
1440          } else {
1441            console.info(`${caseName} success`);
1442            expectSuccess();
1443          }
1444          console.info(`${caseName} test end`);
1445          done();
1446        });
1447      } catch (err) {
1448        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1449        expectFail();
1450        console.info(`${caseName} test end`);
1451        done();
1452      }
1453    });
1454
1455    /* *
1456     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0800
1457     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0800
1458     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is false; callback
1459     * @tc.size  : MediumTest
1460     * @tc.type  : Function
1461     * @tc.level : level 2
1462     */
1463    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1464      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0800';
1465      try {
1466        console.info(`${caseName} test start`);
1467        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1468        expect(tcpServer).assertInstanceOf('Object');
1469        let listenAddress: socket.NetAddress = {
1470          address: '127.0.0.1',
1471          port: 11004,
1472          family: 1
1473        };
1474        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1475            console.info('fail to listen' + err.code.toString());
1476        });
1477        let tcpExtraOptions: socket.TCPExtraOptions = {
1478          OOBInline: false,
1479          socketLinger: {
1480            on: true, linger: 10
1481          }
1482        };
1483        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1484          if (err) {
1485            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1486            expectFail();
1487          } else {
1488            console.info(`${caseName} success`);
1489            expectSuccess();
1490          }
1491          console.info(`${caseName} test end`);
1492          done();
1493        });
1494      } catch (err) {
1495        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1496        expectFail();
1497        console.info(`${caseName} test end`);
1498        done();
1499      }
1500    });
1501
1502    /* *
1503     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_0900
1504     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions0900
1505     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is true; callback
1506     * @tc.size  : MediumTest
1507     * @tc.type  : Function
1508     * @tc.level : level 2
1509     */
1510    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions0900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1511      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions0900';
1512      try {
1513        console.info(`${caseName} test start`);
1514        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1515        expect(tcpServer).assertInstanceOf('Object');
1516        let listenAddress: socket.NetAddress = {
1517          address: '127.0.0.1',
1518          port: 11005,
1519          family: 1
1520        };
1521        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1522            console.info('fail to listen' + err.code.toString());
1523        });
1524        let tcpExtraOptions: socket.TCPExtraOptions = {
1525          TCPNoDelay: true,
1526          socketLinger: {
1527            on: true, linger: 10
1528          }
1529        };
1530        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1531          if (err) {
1532            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1533            expectFail();
1534          } else {
1535            console.info(`${caseName} success`);
1536            expectSuccess();
1537          }
1538          console.info(`${caseName} test end`);
1539          done();
1540        });
1541      } catch (err) {
1542        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1543        expectFail();
1544        console.info(`${caseName} test end`);
1545        done();
1546      }
1547    });
1548
1549    /* *
1550     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1000
1551     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1000
1552     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is false; callback
1553     * @tc.size  : MediumTest
1554     * @tc.type  : Function
1555     * @tc.level : level 2
1556     */
1557    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1558      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1000';
1559      try {
1560        console.info(`${caseName} test start`);
1561        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1562        expect(tcpServer).assertInstanceOf('Object');
1563        let listenAddress: socket.NetAddress = {
1564          address: '127.0.0.1',
1565          port: 11006,
1566          family: 1
1567        };
1568        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1569            console.info('fail to listen' + err.code.toString());
1570        });
1571        let tcpExtraOptions: socket.TCPExtraOptions = {
1572          TCPNoDelay: false,
1573          socketLinger: {
1574            on: true, linger: 10
1575          }
1576        }
1577        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1578          if (err) {
1579            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1580            expectFail();
1581          } else {
1582            console.info(`${caseName} success`);
1583            expectSuccess();
1584          }
1585          console.info(`${caseName} test end`);
1586          done();
1587        });
1588      } catch (err) {
1589        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1590        expectFail();
1591        console.info(`${caseName} test end`);
1592        done();
1593      }
1594    });
1595
1596    /* *
1597     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1100
1598     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1100
1599     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is -1; callback
1600     * @tc.size  : MediumTest
1601     * @tc.type  : Function
1602     * @tc.level : level 2
1603     */
1604    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1605      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1100';
1606      try {
1607        console.info(`${caseName} test start`);
1608        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1609        expect(tcpServer).assertInstanceOf('Object');
1610        let listenAddress: socket.NetAddress = {
1611          address: '127.0.0.1',
1612          port: 11007,
1613          family: 1
1614        };
1615        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1616            console.info('fail to listen' + err.code.toString());
1617        });
1618        let tcpExtraOptions: socket.TCPExtraOptions = {
1619          receiveBufferSize: -1,
1620          socketLinger: {
1621            on: true, linger: 10
1622          }
1623        }
1624        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1625          if (err) {
1626            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1627            expectFail();
1628          } else {
1629            console.info(`${caseName} success`);
1630            expectSuccess();
1631          }
1632          console.info(`${caseName} test end`);
1633          done();
1634        });
1635      } catch (err) {
1636        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1637        expectFail();
1638        console.info(`${caseName} test end`);
1639        done();
1640      }
1641    });
1642
1643    /* *
1644     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1200
1645     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1200
1646     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 0; callback
1647     * @tc.size  : MediumTest
1648     * @tc.type  : Function
1649     * @tc.level : level 2
1650     */
1651    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1652      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1200';
1653      try {
1654        console.info(`${caseName} test start`);
1655        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1656        expect(tcpServer).assertInstanceOf('Object');
1657        let listenAddress: socket.NetAddress = {
1658          address: '127.0.0.1',
1659          port: 11008,
1660          family: 1
1661        };
1662        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1663            console.info('fail to listen' + err.code.toString());
1664        });
1665        let tcpExtraOptions: socket.TCPExtraOptions = {
1666          receiveBufferSize: 0,
1667          socketLinger: {
1668            on: true, linger: 10
1669          }
1670        }
1671        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1672          if (err) {
1673            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1674            expectFail();
1675          } else {
1676            console.info(`${caseName} success`);
1677            expectSuccess();
1678          }
1679          console.info(`${caseName} test end`);
1680          done();
1681        });
1682      } catch (err) {
1683        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1684        expectFail();
1685        console.info(`${caseName} test end`);
1686        done();
1687      }
1688    });
1689
1690    /* *
1691     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1300
1692     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1300
1693     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 100; callback
1694     * @tc.size  : MediumTest
1695     * @tc.type  : Function
1696     * @tc.level : level 2
1697     */
1698    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1699      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1300';
1700      try {
1701        console.info(`${caseName} test start`);
1702        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1703        expect(tcpServer).assertInstanceOf('Object');
1704        let listenAddress: socket.NetAddress = {
1705          address: '127.0.0.1',
1706          port: 11009,
1707          family: 1
1708        };
1709        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1710            console.info('fail to listen' + err.code.toString());
1711        });
1712        let tcpExtraOptions: socket.TCPExtraOptions = {
1713          receiveBufferSize: 100,
1714          socketLinger: {
1715            on: true, linger: 10
1716          }
1717        }
1718        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1719          if (err) {
1720            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1721            expectFail();
1722          } else {
1723            console.info(`${caseName} success`);
1724            expectSuccess();
1725          }
1726          console.info(`${caseName} test end`);
1727          done();
1728        });
1729      } catch (err) {
1730        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1731        expectFail();
1732        console.info(`${caseName} test end`);
1733        done();
1734      }
1735    });
1736
1737    /* *
1738     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1400
1739     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1400
1740     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is -1; callback
1741     * @tc.size  : MediumTest
1742     * @tc.type  : Function
1743     * @tc.level : level 2
1744     */
1745    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1746      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1400';
1747      try {
1748        console.info(`${caseName} test start`);
1749        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1750        expect(tcpServer).assertInstanceOf('Object');
1751        let listenAddress: socket.NetAddress = {
1752          address: '127.0.0.1',
1753          port: 11010,
1754          family: 1
1755        };
1756        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1757            console.info('fail to listen' + err.code.toString());
1758        });
1759        let tcpExtraOptions: socket.TCPExtraOptions = {
1760          sendBufferSize: -1,
1761          socketLinger: {
1762            on: true, linger: 10
1763          }
1764        }
1765        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1766          if (err) {
1767            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1768            expectFail();
1769          } else {
1770            console.info(`${caseName} success`);
1771            expectSuccess();
1772          }
1773          console.info(`${caseName} test end`);
1774          done();
1775        });
1776      } catch (err) {
1777        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1778        expectFail();
1779        console.info(`${caseName} test end`);
1780        done();
1781      }
1782    });
1783
1784    /* *
1785     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1500
1786     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1500
1787     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 0; callback
1788     * @tc.size  : MediumTest
1789     * @tc.type  : Function
1790     * @tc.level : level 2
1791     */
1792    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1793      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1500';
1794      try {
1795        console.info(`${caseName} test start`);
1796        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1797        expect(tcpServer).assertInstanceOf('Object');
1798        let listenAddress: socket.NetAddress = {
1799          address: '127.0.0.1',
1800          port: 11011,
1801          family: 1
1802        };
1803        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1804            console.info('fail to listen' + err.code.toString());
1805        });
1806        let tcpExtraOptions: socket.TCPExtraOptions = {
1807          sendBufferSize: 0,
1808          socketLinger: {
1809            on: true, linger: 10
1810          }
1811        }
1812        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1813          if (err) {
1814            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1815            expectFail();
1816          } else {
1817            console.info(`${caseName} success`);
1818            expectSuccess();
1819          }
1820          console.info(`${caseName} test end`);
1821          done();
1822        });
1823      } catch (err) {
1824        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1825        expectFail();
1826        console.info(`${caseName} test end`);
1827        done();
1828      }
1829    });
1830
1831    /* *
1832     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1600
1833     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1600
1834     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 100; callback
1835     * @tc.size  : MediumTest
1836     * @tc.type  : Function
1837     * @tc.level : level 2
1838     */
1839    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1840      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1600';
1841      try {
1842        console.info(`${caseName} test start`);
1843        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1844        expect(tcpServer).assertInstanceOf('Object');
1845        let listenAddress: socket.NetAddress = {
1846          address: '127.0.0.1',
1847          port: 11012,
1848          family: 1
1849        };
1850        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1851            console.info('fail to listen' + err.code.toString());
1852        });
1853        let tcpExtraOptions: socket.TCPExtraOptions = {
1854          sendBufferSize: 100,
1855          socketLinger: {
1856            on: true, linger: 10
1857          }
1858        }
1859        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1860          if (err) {
1861            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1862            expectFail();
1863          } else {
1864            console.info(`${caseName} success`);
1865            expectSuccess();
1866          }
1867          console.info(`${caseName} test end`);
1868          done();
1869        });
1870      } catch (err) {
1871        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1872        expectFail();
1873        console.info(`${caseName} test end`);
1874        done();
1875      }
1876    });
1877
1878    /* *
1879     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1700
1880     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1700
1881     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is true; callback
1882     * @tc.size  : MediumTest
1883     * @tc.type  : Function
1884     * @tc.level : level 2
1885     */
1886    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1887      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1700';
1888      try {
1889        console.info(`${caseName} test start`);
1890        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1891        expect(tcpServer).assertInstanceOf('Object');
1892        let listenAddress: socket.NetAddress = {
1893          address: '127.0.0.1',
1894          port: 11013,
1895          family: 1
1896        };
1897        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1898            console.info('fail to listen' + err.code.toString());
1899        });
1900        let tcpExtraOptions: socket.TCPExtraOptions = {
1901          reuseAddress: true,
1902          socketLinger: {
1903            on: true, linger: 10
1904          }
1905        }
1906        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1907          if (err) {
1908            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1909            expectFail();
1910          } else {
1911            console.info(`${caseName} success`);
1912            expectSuccess();
1913          }
1914          console.info(`${caseName} test end`);
1915          done();
1916        });
1917      } catch (err) {
1918        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1919        expectFail();
1920        console.info(`${caseName} test end`);
1921        done();
1922      }
1923    });
1924
1925    /* *
1926     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1800
1927     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1800
1928     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is false; callback
1929     * @tc.size  : MediumTest
1930     * @tc.type  : Function
1931     * @tc.level : level 2
1932     */
1933    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1934      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1800';
1935      try {
1936        console.info(`${caseName} test start`);
1937        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1938        expect(tcpServer).assertInstanceOf('Object');
1939        let listenAddress: socket.NetAddress = {
1940          address: '127.0.0.1',
1941          port: 11014,
1942          family: 1
1943        };
1944        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1945            console.info('fail to listen' + err.code.toString());
1946        });
1947        let tcpExtraOptions: socket.TCPExtraOptions = {
1948          reuseAddress: false,
1949          socketLinger: {
1950            on: true, linger: 10
1951          }
1952        }
1953        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
1954          if (err) {
1955            console.info(`${caseName} fail ${JSON.stringify(err)}`);
1956            expectFail();
1957          } else {
1958            console.info(`${caseName} success`);
1959            expectSuccess();
1960          }
1961          console.info(`${caseName} test end`);
1962          done();
1963        });
1964      } catch (err) {
1965        console.info(`${caseName} fail ${JSON.stringify(err)}`);
1966        expectFail();
1967        console.info(`${caseName} test end`);
1968        done();
1969      }
1970    });
1971
1972    /* *
1973     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_1900
1974     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions1900
1975     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is -1; callback
1976     * @tc.size  : MediumTest
1977     * @tc.type  : Function
1978     * @tc.level : level 2
1979     */
1980    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions1900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
1981      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions1900';
1982      try {
1983        console.info(`${caseName} test start`);
1984        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
1985        expect(tcpServer).assertInstanceOf('Object');
1986        let listenAddress: socket.NetAddress = {
1987          address: '127.0.0.1',
1988          port: 11014,
1989          family: 1
1990        };
1991        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
1992            console.info('fail to listen' + err.code.toString());
1993        });
1994        let tcpExtraOptions: socket.TCPExtraOptions = {
1995          socketTimeout: -1,
1996          socketLinger: {
1997            on: true, linger: 10
1998          }
1999        }
2000        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2001          if (err) {
2002            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2003            expectFail();
2004          } else {
2005            console.info(`${caseName} success`);
2006            expectSuccess();
2007          }
2008          console.info(`${caseName} test end`);
2009          done();
2010        });
2011      } catch (err) {
2012        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2013        expectFail();
2014        console.info(`${caseName} test end`);
2015        done();
2016      }
2017    });
2018
2019    /* *
2020     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2000
2021     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2000
2022     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 0; callback
2023     * @tc.size  : MediumTest
2024     * @tc.type  : Function
2025     * @tc.level : level 2
2026     */
2027    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2028      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2000';
2029      try {
2030        console.info(`${caseName} test start`);
2031        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2032        expect(tcpServer).assertInstanceOf('Object');
2033        let listenAddress: socket.NetAddress = {
2034          address: '127.0.0.1',
2035          port: 11015,
2036          family: 1
2037        };
2038        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2039            console.info('fail to listen' + err.code.toString());
2040        });
2041        let tcpExtraOptions: socket.TCPExtraOptions = {
2042          socketTimeout:0,
2043          socketLinger: {
2044            on: true, linger: 10
2045          }
2046        }
2047        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2048          if (err) {
2049            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2050            expectFail();
2051          } else {
2052            console.info(`${caseName} success`);
2053            expectSuccess();
2054          }
2055          console.info(`${caseName} test end`);
2056          done();
2057        });
2058      } catch (err) {
2059        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2060        expectFail();
2061        console.info(`${caseName} test end`);
2062        done();
2063      }
2064    });
2065
2066    /* *
2067     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2100
2068     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2100
2069     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 100; callback
2070     * @tc.size  : MediumTest
2071     * @tc.type  : Function
2072     * @tc.level : level 2
2073     */
2074    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2075      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2100';
2076      try {
2077        console.info(`${caseName} test start`);
2078        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2079        expect(tcpServer).assertInstanceOf('Object');
2080        let listenAddress: socket.NetAddress = {
2081          address: '127.0.0.1',
2082          port: 11016,
2083          family: 1
2084        };
2085        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2086            console.info('fail to listen' + err.code.toString());
2087        });
2088        let tcpExtraOptions: socket.TCPExtraOptions = {
2089          socketTimeout:100,
2090          socketLinger: {
2091            on: true, linger: 10
2092          }
2093        }
2094        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2095          if (err) {
2096            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2097            expectFail();
2098          } else {
2099            console.info(`${caseName} success`);
2100            expectSuccess();
2101          }
2102          console.info(`${caseName} test end`);
2103          done();
2104        });
2105      } catch (err) {
2106        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2107        expectFail();
2108        console.info(`${caseName} test end`);
2109        done();
2110      }
2111    });
2112
2113    /* *
2114     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2200
2115     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2200
2116     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is -1; callback
2117     * @tc.size  : MediumTest
2118     * @tc.type  : Function
2119     * @tc.level : level 2
2120     */
2121    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2122      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2200';
2123      try {
2124        console.info(`${caseName} test start`);
2125        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2126        expect(tcpServer).assertInstanceOf('Object');
2127        let listenAddress: socket.NetAddress = {
2128          address: '127.0.0.1',
2129          port: 11017,
2130          family: 1
2131        };
2132        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2133            console.info('fail to listen' + err.code.toString());
2134        });
2135        let tcpExtraOptions: socket.TCPExtraOptions = {
2136          socketLinger: {
2137            on: true, linger: -1
2138          }
2139        }
2140        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2141          if (err) {
2142            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2143            expectFail();
2144          } else {
2145            console.info(`${caseName} success`);
2146            expectSuccess();
2147          }
2148          console.info(`${caseName} test end`);
2149          done();
2150        });
2151      } catch (err) {
2152        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2153        expectFail();
2154        console.info(`${caseName} test end`);
2155        done();
2156      }
2157    });
2158
2159    /* *
2160     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2300
2161     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2300
2162     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 0; callback
2163     * @tc.size  : MediumTest
2164     * @tc.type  : Function
2165     * @tc.level : level 2
2166     */
2167    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2168      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2300';
2169      try {
2170        console.info(`${caseName} test start`);
2171        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2172        expect(tcpServer).assertInstanceOf('Object');
2173        let listenAddress: socket.NetAddress = {
2174          address: '127.0.0.1',
2175          port: 11018,
2176          family: 1
2177        };
2178        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2179            console.info('fail to listen' + err.code.toString());
2180        });
2181        let tcpExtraOptions: socket.TCPExtraOptions = {
2182          socketLinger: {
2183            on: true, linger: 0
2184          }
2185        }
2186        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2187          if (err) {
2188            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2189            expectFail();
2190          } else {
2191            console.info(`${caseName} success`);
2192            expectSuccess();
2193          }
2194          console.info(`${caseName} test end`);
2195          done();
2196        });
2197      } catch (err) {
2198        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2199        expectFail();
2200        console.info(`${caseName} test end`);
2201        done();
2202      }
2203    });
2204
2205    /* *
2206     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2400
2207     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2400
2208     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65535; callback
2209     * @tc.size  : MediumTest
2210     * @tc.type  : Function
2211     * @tc.level : level 2
2212     */
2213    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2214      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2400';
2215      try {
2216        console.info(`${caseName} test start`);
2217        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2218        expect(tcpServer).assertInstanceOf('Object');
2219        let listenAddress: socket.NetAddress = {
2220          address: '127.0.0.1',
2221          port: 11019,
2222          family: 1
2223        };
2224        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2225            console.info('fail to listen' + err.code.toString());
2226        });
2227        let tcpExtraOptions: socket.TCPExtraOptions = {
2228          socketLinger: {
2229            on: true, linger: 65535
2230          }
2231        }
2232        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2233          if (err) {
2234            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2235            expectFail();
2236          } else {
2237            console.info(`${caseName} success`);
2238            expectSuccess();
2239          }
2240          console.info(`${caseName} test end`);
2241          done();
2242        });
2243      } catch (err) {
2244        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2245        expectFail();
2246        console.info(`${caseName} test end`);
2247        done();
2248      }
2249    });
2250
2251    /* *
2252     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2500
2253     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2500
2254     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65536; callback
2255     * @tc.size  : MediumTest
2256     * @tc.type  : Function
2257     * @tc.level : level 0
2258     */
2259    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2260      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2500';
2261      try {
2262        console.info(`${caseName} test start`);
2263        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2264        expect(tcpServer).assertInstanceOf('Object');
2265        let listenAddress: socket.NetAddress = {
2266          address: '127.0.0.1',
2267          port: 11020,
2268          family: 1
2269        };
2270        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2271            console.info('fail to listen' + err.code.toString());
2272        });
2273        let tcpExtraOptions: socket.TCPExtraOptions = {
2274          socketLinger: {
2275            on: true, linger: 65536
2276          }
2277        }
2278        tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => {
2279          if (err) {
2280            console.info(`${caseName} fail ${JSON.stringify(err)}`);
2281            expectFail();
2282          } else {
2283            console.info(`${caseName} success`);
2284            expectSuccess();
2285          }
2286          console.info(`${caseName} test end`);
2287          done();
2288        });
2289      } catch (err) {
2290        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2291        expectFail();
2292        console.info(`${caseName} test end`);
2293        done();
2294      }
2295    });
2296
2297    /* *
2298     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2600
2299     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2600
2300     * @tc.desc  : Set other properties of the TCP Socket Server connection,before listen; promise
2301     * @tc.size  : MediumTest
2302     * @tc.type  : Function
2303     * @tc.level : level 2
2304     */
2305    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2306      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2600';
2307      try {
2308        console.info(`${caseName} test start`);
2309        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2310        expect(tcpServer).assertInstanceOf('Object');
2311        let tcpExtraOptions: socket.TCPExtraOptions = {
2312          keepAlive: true,
2313          OOBInline: true,
2314          TCPNoDelay: true,
2315          socketLinger: {
2316            on: true, linger: 10
2317          },
2318          receiveBufferSize: 1000,
2319          sendBufferSize: 1000,
2320          reuseAddress: true,
2321          socketTimeout: 3000
2322        };
2323        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2324          console.info(`${caseName} success`);
2325          expectFail();
2326          done();
2327        }).catch((err: BusinessError) => {
2328          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2329          expectTrue(err.code===2303109);
2330          done();
2331        }).finally(() => {
2332          console.info(`${caseName} test end`);
2333          done();
2334        });
2335      } catch (err) {
2336        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2337        expectFail();
2338        console.info(`${caseName} test end`);
2339        done();
2340      }
2341    });
2342
2343    /* *
2344     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2700
2345     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2700
2346     * @tc.desc  : Set other properties of the TCP Socket Server connection after listening; promise
2347     * @tc.size  : MediumTest
2348     * @tc.type  : Function
2349     * @tc.level : level 2
2350     */
2351    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2352      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2700';
2353      try {
2354        console.info(`${caseName} test start`);
2355        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2356        expect(tcpServer).assertInstanceOf('Object');
2357        let listenAddress: socket.NetAddress = {
2358          address: '127.0.0.1',
2359          port: 5019,
2360          family: 1
2361        };
2362        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2363            console.info('fail to listen' + err.code.toString());
2364        });
2365        let tcpExtraOptions: socket.TCPExtraOptions = {
2366          keepAlive: true,
2367          OOBInline: true,
2368          TCPNoDelay: true,
2369          socketLinger: {
2370            on: true, linger: 10
2371          },
2372          receiveBufferSize: 1000,
2373          sendBufferSize: 1000,
2374          reuseAddress: true,
2375          socketTimeout: 3000
2376        };
2377        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2378          console.info(`${caseName} success`);
2379          expectSuccess();
2380          done();
2381        }).catch((err: BusinessError) => {
2382          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2383          expectFail();
2384          done();
2385        }).finally(() => {
2386          console.info(`${caseName} test end`);
2387          done();
2388        });
2389      } catch (err) {
2390        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2391        expectFail();
2392        console.info(`${caseName} test end`);
2393        done();
2394      }
2395    });
2396
2397    /* *
2398     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2800
2399     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2800
2400     * @tc.desc  : Set other properties of TCPSocketService connection in listen, input parameters are null; promise
2401     * @tc.size  : MediumTest
2402     * @tc.type  : Function
2403     * @tc.level : level 2
2404     */
2405    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2406      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2800';
2407      try {
2408        console.info(`${caseName} test start`);
2409        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2410        expect(tcpServer).assertInstanceOf('Object');
2411        let listenAddress: socket.NetAddress = {
2412          address: '127.0.0.1',
2413          port: 2020,
2414          family: 1
2415        };
2416        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2417            console.info('fail to listen' + err.code.toString());
2418        });
2419        tcpServer.setExtraOptions(null).then(() => {
2420          console.info(`${caseName} success`);
2421          expectFail();
2422          done();
2423        }).catch((err: BusinessError) => {
2424          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2425          expectTrue(err.code==401);
2426          done();
2427        }).finally(() => {
2428          console.info(`${caseName} test end`);
2429          done();
2430        });
2431      } catch (err) {
2432        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2433        expectTrue(err.code==401);
2434        console.info(`${caseName} test end`);
2435        done();
2436      }
2437    });
2438
2439    /* *
2440     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_2900
2441     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions2900
2442     * @tc.desc  : Set other properties of TCPSocketService connection in listen,input parameters are undefined;promise
2443     * @tc.size  : MediumTest
2444     * @tc.type  : Function
2445     * @tc.level : level 2
2446     */
2447    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions2900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2448      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions2900';
2449      try {
2450        console.info(`${caseName} test start`);
2451        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2452        expect(tcpServer).assertInstanceOf('Object');
2453        let listenAddress: socket.NetAddress = {
2454          address: '127.0.0.1',
2455          port: 5021,
2456          family: 1
2457        };
2458        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2459            console.info('fail to listen' + err.code.toString());
2460        });
2461        tcpServer.setExtraOptions(undefined).then(() => {
2462          console.info(`${caseName} success`);
2463          expectFail();
2464          done();
2465        }).catch((err: BusinessError) => {
2466          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2467          expectTrue(err.code==401);
2468          done();
2469        }).finally(() => {
2470          console.info(`${caseName} test end`);
2471          done();
2472        });
2473      } catch (err) {
2474        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2475        expectTrue(err.code==401);
2476        console.info(`${caseName} test end`);
2477        done();
2478      }
2479    });
2480
2481    /* *
2482     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3000
2483     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3000
2484     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is true; promise
2485     * @tc.size  : MediumTest
2486     * @tc.type  : Function
2487     * @tc.level : level 0
2488     */
2489    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2490      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3000';
2491      try {
2492        console.info(`${caseName} test start`);
2493        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2494        expect(tcpServer).assertInstanceOf('Object');
2495        let listenAddress: socket.NetAddress = {
2496          address: '127.0.0.1',
2497          port: 10101,
2498          family: 1
2499        };
2500        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2501            console.info('fail to listen' + err.code.toString());
2502        });
2503        let tcpExtraOptions: socket.TCPExtraOptions = {
2504          keepAlive: true,
2505          socketLinger: {
2506            on: true, linger: 10
2507          }
2508        };
2509        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2510          console.info(`${caseName} success`);
2511          expectSuccess();
2512          done();
2513        }).catch((err: BusinessError) => {
2514          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2515          expectFail();
2516          done();
2517        }).finally(() => {
2518          console.info(`${caseName} test end`);
2519          done();
2520        });
2521      } catch (err) {
2522        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2523        expectFail();
2524        console.info(`${caseName} test end`);
2525        done();
2526      }
2527    });
2528
2529    /* *
2530     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3100
2531     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3100
2532     * @tc.desc  : Set other properties of the TCP Socket Server connection,keepAlive is false; promise
2533     * @tc.size  : MediumTest
2534     * @tc.type  : Function
2535     * @tc.level : level 2
2536     */
2537    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2538      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3100';
2539      try {
2540        console.info(`${caseName} test start`);
2541        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2542        expect(tcpServer).assertInstanceOf('Object');
2543        let listenAddress: socket.NetAddress = {
2544          address: '127.0.0.1',
2545          port: 10102,
2546          family: 1
2547        };
2548        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2549            console.info('fail to listen' + err.code.toString());
2550        });
2551        let tcpExtraOptions: socket.TCPExtraOptions = {
2552          keepAlive: false,
2553          socketLinger: {
2554            on: true, linger: 10
2555          }
2556        };
2557        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2558          console.info(`${caseName} success`);
2559          expectSuccess();
2560          done();
2561        }).catch((err: BusinessError) => {
2562          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2563          expectFail();
2564          done();
2565        }).finally(() => {
2566          console.info(`${caseName} test end`);
2567          done();
2568        });
2569      } catch (err) {
2570        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2571        expectFail();
2572        console.info(`${caseName} test end`);
2573        done();
2574      }
2575    });
2576
2577    /* *
2578     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3200
2579     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3200
2580     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is true; promise
2581     * @tc.size  : MediumTest
2582     * @tc.type  : Function
2583     * @tc.level : level 2
2584     */
2585    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2586      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3200';
2587      try {
2588        console.info(`${caseName} test start`);
2589        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2590        expect(tcpServer).assertInstanceOf('Object');
2591        let listenAddress: socket.NetAddress = {
2592          address: '127.0.0.1',
2593          port: 10103,
2594          family: 1
2595        };
2596        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2597            console.info('fail to listen' + err.code.toString());
2598        });
2599        let tcpExtraOptions: socket.TCPExtraOptions = {
2600          OOBInline: true,
2601          socketLinger: {
2602            on: true, linger: 10
2603          }
2604        };
2605        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2606          console.info(`${caseName} success`);
2607          expectSuccess();
2608          done();
2609        }).catch((err: BusinessError) => {
2610          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2611          expectFail();
2612          done();
2613        }).finally(() => {
2614          console.info(`${caseName} test end`);
2615          done();
2616        });
2617      } catch (err) {
2618        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2619        expectFail();
2620        console.info(`${caseName} test end`);
2621        done();
2622      }
2623    });
2624
2625    /* *
2626     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3300
2627     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3300
2628     * @tc.desc  : Set other properties of the TCP Socket Server connection,OOBlnLine is false; promise
2629     * @tc.size  : MediumTest
2630     * @tc.type  : Function
2631     * @tc.level : level 0
2632     */
2633    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async (done: Function) => {
2634      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3300';
2635      try {
2636        console.info(`${caseName} test start`);
2637        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2638        expect(tcpServer).assertInstanceOf('Object');
2639        let listenAddress: socket.NetAddress = {
2640          address: '127.0.0.1',
2641          port: 10104,
2642          family: 1
2643        };
2644        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2645            console.info('fail to listen' + err.code.toString());
2646        });
2647        let tcpExtraOptions: socket.TCPExtraOptions = {
2648          OOBInline: false,
2649          socketLinger: {
2650            on: true, linger: 10
2651          }
2652        };
2653        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2654          console.info(`${caseName} success`);
2655          expectSuccess();
2656          done();
2657        }).catch((err: BusinessError) => {
2658          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2659          expectFail();
2660          done();
2661        }).finally(() => {
2662          console.info(`${caseName} test end`);
2663          done();
2664        });
2665      } catch (err) {
2666        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2667        expectFail();
2668        console.info(`${caseName} test end`);
2669        done();
2670      }
2671    });
2672
2673    /* *
2674     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3400
2675     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3400
2676     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is true; promise
2677     * @tc.size  : MediumTest
2678     * @tc.type  : Function
2679     * @tc.level : level 2
2680     */
2681    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2682      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3400';
2683      try {
2684        console.info(`${caseName} test start`);
2685        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2686        expect(tcpServer).assertInstanceOf('Object');
2687        let listenAddress: socket.NetAddress = {
2688          address: '127.0.0.1',
2689          port: 10105,
2690          family: 1
2691        };
2692        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2693            console.info('fail to listen' + err.code.toString());
2694        });
2695        let tcpExtraOptions: socket.TCPExtraOptions = {
2696          TCPNoDelay: true,
2697          socketLinger: {
2698            on: true, linger: 10
2699          }
2700        };
2701        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2702          console.info(`${caseName} success`);
2703          expectSuccess();
2704          done();
2705        }).catch((err: BusinessError) => {
2706          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2707          expectFail();
2708          done();
2709        }).finally(() => {
2710          console.info(`${caseName} test end`);
2711          done();
2712        });
2713      } catch (err) {
2714        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2715        expectFail();
2716        console.info(`${caseName} test end`);
2717        done();
2718      }
2719    });
2720
2721    /* *
2722     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3500
2723     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3500
2724     * @tc.desc  : Set other properties of the TCP Socket Server connection,TCPNoDelay is false; promise
2725     * @tc.size  : MediumTest
2726     * @tc.type  : Function
2727     * @tc.level : level 2
2728     */
2729    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2730      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3500';
2731      try {
2732        console.info(`${caseName} test start`);
2733        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2734        expect(tcpServer).assertInstanceOf('Object');
2735        let listenAddress: socket.NetAddress = {
2736          address: '127.0.0.1',
2737          port: 10106,
2738          family: 1
2739        };
2740        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2741            console.info('fail to listen' + err.code.toString());
2742        });
2743        let tcpExtraOptions: socket.TCPExtraOptions = {
2744          TCPNoDelay: false,
2745          socketLinger: {
2746            on: true, linger: 10
2747          }
2748        };
2749        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2750          console.info(`${caseName} success`);
2751          expectSuccess();
2752          done();
2753        }).catch((err: BusinessError) => {
2754          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2755          expectFail();
2756          done();
2757        }).finally(() => {
2758          console.info(`${caseName} test end`);
2759          done();
2760        });
2761      } catch (err) {
2762        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2763        expectFail();
2764        console.info(`${caseName} test end`);
2765        done();
2766      }
2767    });
2768
2769    /* *
2770     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3600
2771     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3600
2772     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is -1; promise
2773     * @tc.size  : MediumTest
2774     * @tc.type  : Function
2775     * @tc.level : level 2
2776     */
2777    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2778      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3600';
2779      try {
2780        console.info(`${caseName} test start`);
2781        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2782        expect(tcpServer).assertInstanceOf('Object');
2783        let listenAddress: socket.NetAddress = {
2784          address: '127.0.0.1',
2785          port: 10107,
2786          family: 1
2787        };
2788        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2789            console.info('fail to listen' + err.code.toString());
2790        });
2791        let tcpExtraOptions: socket.TCPExtraOptions = {
2792          receiveBufferSize: -1,
2793          socketLinger: {
2794            on: true, linger: 10
2795          }
2796        };
2797        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2798          console.info(`${caseName} success`);
2799          expectSuccess();
2800          done();
2801        }).catch((err: BusinessError) => {
2802          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2803          expectFail();
2804          done();
2805        }).finally(() => {
2806          console.info(`${caseName} test end`);
2807          done();
2808        });
2809      } catch (err) {
2810        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2811        expectFail();
2812        console.info(`${caseName} test end`);
2813        done();
2814      }
2815    });
2816
2817    /* *
2818     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3700
2819     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3700
2820     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 0; promise
2821     * @tc.size  : MediumTest
2822     * @tc.type  : Function
2823     * @tc.level : level 2
2824     */
2825    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2826      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3700';
2827      try {
2828        console.info(`${caseName} test start`);
2829        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2830        expect(tcpServer).assertInstanceOf('Object');
2831        let listenAddress: socket.NetAddress = {
2832          address: '127.0.0.1',
2833          port: 10108,
2834          family: 1
2835        };
2836        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2837            console.info('fail to listen' + err.code.toString());
2838        });
2839        let tcpExtraOptions: socket.TCPExtraOptions = {
2840          receiveBufferSize: 0,
2841          socketLinger: {
2842            on: true, linger: 10
2843          }
2844        };
2845        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2846          console.info(`${caseName} success`);
2847          expectSuccess();
2848          done();
2849        }).catch((err: BusinessError) => {
2850          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2851          expectFail();
2852          done();
2853        }).finally(() => {
2854          console.info(`${caseName} test end`);
2855          done();
2856        });
2857      } catch (err) {
2858        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2859        expectFail();
2860        console.info(`${caseName} test end`);
2861        done();
2862      }
2863    });
2864
2865    /* *
2866     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3800
2867     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3800
2868     * @tc.desc  : Set other properties of the TCP Socket Server connection,receiveBufferSize is 100; promise
2869     * @tc.size  : MediumTest
2870     * @tc.type  : Function
2871     * @tc.level : level 2
2872     */
2873    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2874      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3800';
2875      try {
2876        console.info(`${caseName} test start`);
2877        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2878        expect(tcpServer).assertInstanceOf('Object');
2879        let listenAddress: socket.NetAddress = {
2880          address: '127.0.0.1',
2881          port: 10109,
2882          family: 1
2883        };
2884        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2885            console.info('fail to listen' + err.code.toString());
2886        });
2887        let tcpExtraOptions: socket.TCPExtraOptions = {
2888          receiveBufferSize: 100,
2889          socketLinger: {
2890            on: true, linger: 10
2891          }
2892        };
2893        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2894          console.info(`${caseName} success`);
2895          expectSuccess();
2896          done();
2897        }).catch((err: BusinessError) => {
2898          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2899          expectFail();
2900          done();
2901        }).finally(() => {
2902          console.info(`${caseName} test end`);
2903          done();
2904        });
2905      } catch (err) {
2906        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2907        expectFail();
2908        console.info(`${caseName} test end`);
2909        done();
2910      }
2911    });
2912
2913    /* *
2914     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_3900
2915     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions3900
2916     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is -1; promise
2917     * @tc.size  : MediumTest
2918     * @tc.type  : Function
2919     * @tc.level : level 2
2920     */
2921    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions3900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2922      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions3900';
2923      try {
2924        console.info(`${caseName} test start`);
2925        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2926        expect(tcpServer).assertInstanceOf('Object');
2927        let listenAddress: socket.NetAddress = {
2928          address: '127.0.0.1',
2929          port: 10110,
2930          family: 1
2931        };
2932        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2933            console.info('fail to listen' + err.code.toString());
2934        });
2935        let tcpExtraOptions: socket.TCPExtraOptions = {
2936          sendBufferSize: -1,
2937          socketLinger: {
2938            on: true, linger: 10
2939          }
2940        };
2941        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2942          console.info(`${caseName} success`);
2943          expectSuccess();
2944          done();
2945        }).catch((err: BusinessError) => {
2946          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2947          expectFail();
2948          done();
2949        }).finally(() => {
2950          console.info(`${caseName} test end`);
2951          done();
2952        });
2953      } catch (err) {
2954        console.info(`${caseName} fail ${JSON.stringify(err)}`);
2955        expectFail();
2956        console.info(`${caseName} test end`);
2957        done();
2958      }
2959    });
2960
2961    /* *
2962     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4000
2963     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4000
2964     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 0; promise
2965     * @tc.size  : MediumTest
2966     * @tc.type  : Function
2967     * @tc.level : level 2
2968     */
2969    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
2970      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4000';
2971      try {
2972        console.info(`${caseName} test start`);
2973        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
2974        expect(tcpServer).assertInstanceOf('Object');
2975        let listenAddress: socket.NetAddress = {
2976          address: '127.0.0.1',
2977          port: 10111,
2978          family: 1
2979        };
2980        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
2981            console.info('fail to listen' + err.code.toString());
2982        });
2983        let tcpExtraOptions: socket.TCPExtraOptions = {
2984          sendBufferSize: 0,
2985          socketLinger: {
2986            on: true, linger: 10
2987          }
2988        };
2989        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
2990          console.info(`${caseName} success`);
2991          expectSuccess();
2992          done();
2993        }).catch((err: BusinessError) => {
2994          console.info(`${caseName} fail ${JSON.stringify(err)}`);
2995          expectFail();
2996          done();
2997        }).finally(() => {
2998          console.info(`${caseName} test end`);
2999          done();
3000        });
3001      } catch (err) {
3002        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3003        expectFail();
3004        console.info(`${caseName} test end`);
3005        done();
3006      }
3007    });
3008
3009    /* *
3010     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4100
3011     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4100
3012     * @tc.desc  : Set other properties of the TCP Socket Server connection,sendBufferSize is 100; promise
3013     * @tc.size  : MediumTest
3014     * @tc.type  : Function
3015     * @tc.level : level 2
3016     */
3017    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3018      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4100';
3019      try {
3020        console.info(`${caseName} test start`);
3021        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3022        expect(tcpServer).assertInstanceOf('Object');
3023        let listenAddress: socket.NetAddress = {
3024          address: '127.0.0.1',
3025          port: 10112,
3026          family: 1
3027        };
3028        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3029            console.info('fail to listen' + err.code.toString());
3030        });
3031        let tcpExtraOptions: socket.TCPExtraOptions = {
3032          sendBufferSize: 100,
3033          socketLinger: {
3034            on: true, linger: 10
3035          }
3036        };
3037        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3038          console.info(`${caseName} success`);
3039          expectSuccess();
3040          done();
3041        }).catch((err: BusinessError) => {
3042          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3043          expectFail();
3044          done();
3045        }).finally(() => {
3046          console.info(`${caseName} test end`);
3047          done();
3048        });
3049      } catch (err) {
3050        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3051        expectFail();
3052        console.info(`${caseName} test end`);
3053        done();
3054      }
3055    });
3056
3057    /* *
3058     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4200
3059     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4200
3060     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is true; promise
3061     * @tc.size  : MediumTest
3062     * @tc.type  : Function
3063     * @tc.level : level 2
3064     */
3065    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3066      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4200';
3067      try {
3068        console.info(`${caseName} test start`);
3069        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3070        expect(tcpServer).assertInstanceOf('Object');
3071        let listenAddress: socket.NetAddress = {
3072          address: '127.0.0.1',
3073          port: 10113,
3074          family: 1
3075        };
3076        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3077            console.info('fail to listen' + err.code.toString());
3078        });
3079        let tcpExtraOptions: socket.TCPExtraOptions = {
3080          reuseAddress: true,
3081          socketLinger: {
3082            on: true, linger: 10
3083          }
3084        };
3085        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3086          console.info(`${caseName} success`);
3087          expectSuccess();
3088          done();
3089        }).catch((err: BusinessError) => {
3090          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3091          expectFail();
3092          done();
3093        }).finally(() => {
3094          console.info(`${caseName} test end`);
3095          done();
3096        });
3097      } catch (err) {
3098        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3099        expectFail();
3100        console.info(`${caseName} test end`);
3101        done();
3102      }
3103    });
3104
3105    /* *
3106     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4300
3107     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4300
3108     * @tc.desc  : Set other properties of the TCP Socket Server connection,reuseAddress is false; promise
3109     * @tc.size  : MediumTest
3110     * @tc.type  : Function
3111     * @tc.level : level 2
3112     */
3113    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4300', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3114      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4300';
3115      try {
3116        console.info(`${caseName} test start`);
3117        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3118        expect(tcpServer).assertInstanceOf('Object');
3119        let listenAddress: socket.NetAddress = {
3120          address: '127.0.0.1',
3121          port: 10114,
3122          family: 1
3123        };
3124        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3125            console.info('fail to listen' + err.code.toString());
3126        });
3127        let tcpExtraOptions: socket.TCPExtraOptions = {
3128          reuseAddress: false,
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_4400
3155     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4400
3156     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is -1; promise
3157     * @tc.size  : MediumTest
3158     * @tc.type  : Function
3159     * @tc.level : level 2
3160     */
3161    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3162      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4400';
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: 10115,
3170          family: 1
3171        };
3172        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3173            console.info('fail to listen' + err.code.toString());
3174        });
3175        let tcpExtraOptions: socket.TCPExtraOptions = {
3176          socketTimeout: -1,
3177          socketLinger: {
3178            on: true, linger: 10
3179          }
3180        };
3181        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3182          console.info(`${caseName} success`);
3183          expectSuccess();
3184          done();
3185        }).catch((err: BusinessError) => {
3186          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3187          expectFail();
3188          done();
3189        }).finally(() => {
3190          console.info(`${caseName} test end`);
3191          done();
3192        });
3193      } catch (err) {
3194        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3195        expectFail();
3196        console.info(`${caseName} test end`);
3197        done();
3198      }
3199    });
3200
3201    /* *
3202     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4500
3203     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4500
3204     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 0; promise
3205     * @tc.size  : MediumTest
3206     * @tc.type  : Function
3207     * @tc.level : level 2
3208     */
3209    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3210      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4500';
3211      try {
3212        console.info(`${caseName} test start`);
3213        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3214        expect(tcpServer).assertInstanceOf('Object');
3215        let listenAddress: socket.NetAddress = {
3216          address: '127.0.0.1',
3217          port: 10116,
3218          family: 1
3219        };
3220        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3221            console.info('fail to listen' + err.code.toString());
3222        });
3223        let tcpExtraOptions: socket.TCPExtraOptions = {
3224          socketTimeout: 0,
3225          socketLinger: {
3226            on: true, linger: 10
3227          }
3228        };
3229        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3230          console.info(`${caseName} success`);
3231          expectSuccess();
3232          done();
3233        }).catch((err: BusinessError) => {
3234          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3235          expectFail();
3236          done();
3237        }).finally(() => {
3238          console.info(`${caseName} test end`);
3239          done();
3240        });
3241      } catch (err) {
3242        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3243        expectFail();
3244        console.info(`${caseName} test end`);
3245        done();
3246      }
3247    });
3248
3249    /* *
3250     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4600
3251     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4600
3252     * @tc.desc  : Set other properties of the TCP Socket Server connection,socketTimeout is 100; promise
3253     * @tc.size  : MediumTest
3254     * @tc.type  : Function
3255     * @tc.level : level 2
3256     */
3257    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3258      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4600';
3259      try {
3260        console.info(`${caseName} test start`);
3261        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3262        expect(tcpServer).assertInstanceOf('Object');
3263        let listenAddress: socket.NetAddress = {
3264          address: '127.0.0.1',
3265          port: 10117,
3266          family: 1
3267        };
3268        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3269            console.info('fail to listen' + err.code.toString());
3270        });
3271        let tcpExtraOptions: socket.TCPExtraOptions = {
3272          socketTimeout: 100,
3273          socketLinger: {
3274            on: true, linger: 10
3275          }
3276        };
3277        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3278          console.info(`${caseName} success`);
3279          expectSuccess();
3280          done();
3281        }).catch((err: BusinessError) => {
3282          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3283          expectFail();
3284          done();
3285        }).finally(() => {
3286          console.info(`${caseName} test end`);
3287          done();
3288        });
3289      } catch (err) {
3290        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3291        expectFail();
3292        console.info(`${caseName} test end`);
3293        done();
3294      }
3295    });
3296
3297    /* *
3298     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4700
3299     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4700
3300     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is -1; promise
3301     * @tc.size  : MediumTest
3302     * @tc.type  : Function
3303     * @tc.level : level 2
3304     */
3305    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4700', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3306      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4700';
3307      try {
3308        console.info(`${caseName} test start`);
3309        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3310        expect(tcpServer).assertInstanceOf('Object');
3311        let listenAddress: socket.NetAddress = {
3312          address: '127.0.0.1',
3313          port: 10118,
3314          family: 1
3315        };
3316        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3317            console.info('fail to listen' + err.code.toString());
3318        });
3319        let tcpExtraOptions: socket.TCPExtraOptions = {
3320          socketLinger: {
3321            on: true, linger: -1
3322          }
3323        };
3324        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3325          console.info(`${caseName} success`);
3326          expectSuccess();
3327          done();
3328        }).catch((err: BusinessError) => {
3329          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3330          expectFail();
3331          done();
3332        }).finally(() => {
3333          console.info(`${caseName} test end`);
3334          done();
3335        });
3336      } catch (err) {
3337        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3338        expectFail();
3339        console.info(`${caseName} test end`);
3340        done();
3341      }
3342    });
3343
3344    /* *
3345     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4800
3346     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4800
3347     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 0; promise
3348     * @tc.size  : MediumTest
3349     * @tc.type  : Function
3350     * @tc.level : level 2
3351     */
3352    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4800', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3353      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4800';
3354      try {
3355        console.info(`${caseName} test start`);
3356        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3357        expect(tcpServer).assertInstanceOf('Object');
3358        let listenAddress: socket.NetAddress = {
3359          address: '127.0.0.1',
3360          port: 10119,
3361          family: 1
3362        };
3363        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3364            console.info('fail to listen' + err.code.toString());
3365        });
3366        let tcpExtraOptions: socket.TCPExtraOptions = {
3367          socketLinger: {
3368            on: true, linger: 0
3369          }
3370        };
3371        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3372          console.info(`${caseName} success`);
3373          expectSuccess();
3374          done();
3375        }).catch((err: BusinessError) => {
3376          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3377          expectFail();
3378          done();
3379        }).finally(() => {
3380          console.info(`${caseName} test end`);
3381          done();
3382        });
3383      } catch (err) {
3384        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3385        expectFail();
3386        console.info(`${caseName} test end`);
3387        done();
3388      }
3389    });
3390
3391    /* *
3392     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_4900
3393     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions4900
3394     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65535; promise
3395     * @tc.size  : MediumTest
3396     * @tc.type  : Function
3397     * @tc.level : level 2
3398     */
3399    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions4900', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3400      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions4900';
3401      try {
3402        console.info(`${caseName} test start`);
3403        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3404        expect(tcpServer).assertInstanceOf('Object');
3405        let listenAddress: socket.NetAddress = {
3406          address: '127.0.0.1',
3407          port: 10120,
3408          family: 1
3409        };
3410        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3411            console.info('fail to listen' + err.code.toString());
3412        });
3413        let tcpExtraOptions: socket.TCPExtraOptions = {
3414          socketLinger: {
3415            on: true, linger: 65535
3416          }
3417        };
3418        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3419          console.info(`${caseName} success`);
3420          expectSuccess();
3421          done();
3422        }).catch((err: BusinessError) => {
3423          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3424          expectFail();
3425          done();
3426        }).finally(() => {
3427          console.info(`${caseName} test end`);
3428          done();
3429        });
3430      } catch (err) {
3431        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3432        expectFail();
3433        console.info(`${caseName} test end`);
3434        done();
3435      }
3436    });
3437
3438    /* *
3439     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_SetExtraOptions_5000
3440     * @tc.name  : testNetworkMgrSocketTCPSocketServerSetExtraOptions5000
3441     * @tc.desc  : Set other properties of the TCP Socket Server connection,linger is 65536; promise
3442     * @tc.size  : MediumTest
3443     * @tc.type  : Function
3444     * @tc.level : level 2
3445     */
3446    it('testNetworkMgrSocketTCPSocketServerSetExtraOptions5000', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3447      let caseName: string = 'testNetworkMgrSocketTCPSocketServerSetExtraOptions5000';
3448      try {
3449        console.info(`${caseName} test start`);
3450        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3451        expect(tcpServer).assertInstanceOf('Object');
3452        let listenAddress: socket.NetAddress = {
3453          address: '127.0.0.1',
3454          port: 10121,
3455          family: 1
3456        };
3457        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3458            console.info('fail to listen' + err.code.toString());
3459        });
3460        let tcpExtraOptions: socket.TCPExtraOptions = {
3461          socketLinger: {
3462            on: true, linger: 65536
3463          }
3464        };
3465        tcpServer.setExtraOptions(tcpExtraOptions).then(() => {
3466          console.info(`${caseName} success`);
3467          expectSuccess();
3468          done();
3469        }).catch((err: BusinessError) => {
3470          console.info(`${caseName} fail ${JSON.stringify(err)}`);
3471          expectFail();
3472          done();
3473        }).finally(() => {
3474          console.info(`${caseName} test end`);
3475          done();
3476        });
3477      } catch (err) {
3478        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3479        expectFail();
3480        console.info(`${caseName} test end`);
3481        done();
3482      }
3483    });
3484
3485    /* *
3486     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OnConnect_0100
3487     * @tc.name  : testNetworkMgrSocketTCPSocketServerOnConnect0100
3488     * @tc.desc  : Subscription to TCP Socket Server connection events;
3489     * @tc.size  : MediumTest
3490     * @tc.type  : Function
3491     * @tc.level : level 2
3492     */
3493    it('testNetworkMgrSocketTCPSocketServerOnConnect0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3494      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOnConnect0100';
3495      try {
3496        console.info(`${caseName} test start`);
3497        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3498        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3499        expect(tcpServer).assertInstanceOf('Object');
3500        let listenAddress: socket.NetAddress = {
3501          address: '127.0.0.1',
3502          port: 5022,
3503          family: 1
3504        };
3505        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3506            console.info('fail to listen' + err.code.toString());
3507        });
3508        let callback: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3509          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3510          expectTrue(data.clientId!==null);
3511          console.info(`${caseName} test end`);
3512          done();
3513        };
3514        tcpServer.on('connect',callback);
3515        let tcpConnectOptions:socket.TCPConnectOptions={
3516        address:listenAddress
3517        };
3518        await tcp.connect(tcpConnectOptions).catch((err:BusinessError) => {
3519            console.info('fail to connect' + err.code.toString());
3520        });
3521      } catch (err) {
3522        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3523        expectFail();
3524        console.info(`${caseName} test end`);
3525        done();
3526      }
3527    });
3528
3529    /* *
3530     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OffConnect_0100
3531     * @tc.name  : testNetworkMgrSocketTCPSocketServerOffConnect0100
3532     * @tc.desc  : Unsubscribe from TCP Socket Server connection events;
3533     * @tc.size  : MediumTest
3534     * @tc.type  : Function
3535     * @tc.level : level 2
3536     */
3537    it('testNetworkMgrSocketTCPSocketServerOffConnect0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3538      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOffConnect0100';
3539      try {
3540        console.info(`${caseName} test start`);
3541        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3542        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3543        expect(tcpServer).assertInstanceOf('Object');
3544        let listenAddress: socket.NetAddress = {
3545          address: '127.0.0.1',
3546          port: 5023,
3547          family: 1
3548        };
3549        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3550            console.info('fail to listen' + err.code.toString());
3551        });
3552        let callback: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3553          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3554          expectFail();
3555          console.info(`${caseName} test end`);
3556          done();
3557        }
3558        tcpServer.on('connect',callback);
3559        let tcpConnectOptions:socket.TCPConnectOptions={
3560          address:listenAddress
3561        };
3562        tcpServer.off('connect');
3563        await tcp.connect(tcpConnectOptions).catch((err:BusinessError) => {
3564            console.info('fail to connect' + err.code.toString());
3565        });
3566        expectSuccess();
3567        console.info(`${caseName} test end`);
3568        done();
3569      } catch (err) {
3570        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3571        expectFail();
3572        console.info(`${caseName} test end`);
3573        done();
3574      }
3575    });
3576
3577    /* *
3578     * @tc.number: SUB_NetworkMgr_Socket_TCPSocketServer_OffConnect_0200
3579     * @tc.name  : testNetworkMgrSocketTCPSocketServerOffConnect0200
3580     * @tc.desc  : Unsubscribe from all connection events of TCP Socket Server;
3581     * @tc.size  : MediumTest
3582     * @tc.type  : Function
3583     * @tc.level : level 2
3584     */
3585    it('testNetworkMgrSocketTCPSocketServerOffConnect0200', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL2, async (done: Function) => {
3586      let caseName: string = 'testNetworkMgrSocketTCPSocketServerOffConnect0200';
3587      try {
3588        console.info(`${caseName} test start`);
3589        let tcp: socket.TCPSocket = socket.constructTCPSocketInstance();
3590        let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance();
3591        expect(tcpServer).assertInstanceOf('Object');
3592        let listenAddress: socket.NetAddress = {
3593          address: '127.0.0.1',
3594          port: 5024,
3595          family: 1
3596        };
3597        await tcpServer.listen(listenAddress).catch((err:BusinessError) => {
3598            console.info('fail to listen' + err.code.toString());
3599        });
3600        let callback1: Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3601          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3602          expectFail();
3603          console.info(`${caseName} test end`);
3604          done();
3605        };
3606        let callback2 : Callback<socket.TCPSocketConnection> = (data: socket.TCPSocketConnection)=>{
3607          console.info(`${caseName} success data:${JSON.stringify(data)}`);
3608          expectFail();
3609          console.info(`${caseName} test end`);
3610          done();
3611        };
3612        tcpServer.on('connect',callback1);
3613        tcpServer.on('connect',callback2);
3614        let tcpConnectOptions:socket.TCPConnectOptions={
3615          address:listenAddress
3616        };
3617        tcpServer.off('connect');
3618        await tcp.connect(tcpConnectOptions).catch((err:BusinessError) => {
3619            console.info('fail to connect' + err.code.toString());
3620        });
3621        expectSuccess();
3622        console.info(`${caseName} test end`);
3623        done();
3624      } catch (err) {
3625        console.info(`${caseName} fail ${JSON.stringify(err)}`);
3626        expectFail();
3627        console.info(`${caseName} test end`);
3628        done();
3629      }
3630    });
3631  })
3632}
3633