1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the 'License') 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an 'AS IS' BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { describe, expect, it, afterEach, TestType, Size, Level } from '@ohos/hypium'; 17import mdns from '@ohos.net.mdns'; 18import featureAbility from '@ohos.ability.featureAbility'; 19 20let bundleName = featureAbility.getContext(); 21let delayTime = 3000; 22 23let startSearching_status; 24let stopSearching_status; 25let found_status; 26let lost_status; 27 28function startSearching() { 29 console.log(`SUB_Telephony_ run startSearching function`); 30 startSearching_status = true; 31} 32 33function stopSearching() { 34 console.log(`SUB_Telephony_ run stopSearching function`); 35 stopSearching_status = true; 36} 37 38function found() { 39 console.log(`SUB_Telephony_ run found function`); 40 found_status = true; 41} 42 43function lost() { 44 console.log(`SUB_Telephony_ run lost function`); 45 lost_status = true; 46} 47 48let localServiceInfo = { 49 serviceType: "_print._tcp", 50 serviceName: "into type", 51 port: 5555, 52 host: { 53 address: "10.14.0.7", 54 family: 1, 55 port: 5555, 56 }, 57 serviceAttribute: [ 58 { 59 key: "111", 60 value: [1] 61 } 62 ] 63} 64 65function myExpect(value) { 66 expect(value.serviceType).assertEqual(localServiceInfo.serviceType); 67 expect(value.serviceName).assertEqual(localServiceInfo.serviceName); 68 expect(value.port).assertEqual(localServiceInfo.port); 69 expect(value.host.address).assertEqual(localServiceInfo.host.address); 70 expect(value.host.family).assertEqual(localServiceInfo.host.family); 71 expect(value.host.port).assertEqual(localServiceInfo.host.port); 72 expect(value.serviceAttribute[0].key[0]).assertEqual(localServiceInfo.serviceAttribute[0].key[0]); 73 expect(value.serviceAttribute[0].value[0]).assertEqual(localServiceInfo.serviceAttribute[0].value[0]); 74} 75 76export default function NetworkManagerMdnsTest() { 77 78 describe('NetworkManagerMdnsTest', function () { 79 80 afterEach(async function () { 81 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 82 if (err) { 83 console.log(`removeLocalService fail ${JSON.stringify(err)}`); 84 } else { 85 console.log(` removeLocalService success ${JSON.stringify(data)}`); 86 } 87 }); 88 }); 89 90 /** 91 * @tc.number SUB_Telephony_NetManager_addLocalService_Async_0100 92 * @tc.name Test addLocalService() interface 93 * @tc.desc Function test 94 */ 95 it('SUB_Telephony_NetManager_addLocalService_Async_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 96 let caseName = 'SUB_Telephony_NetManager_addLocalService_Async_0100'; 97 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 98 if (err) { 99 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 100 expect().assertFail(); 101 done(); 102 } else { 103 console.log(`${caseName} addLocalService success`); 104 myExpect(data); 105 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 106 if (err) { 107 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 108 expect().assertFail(); 109 done(); 110 } else { 111 console.log(`${caseName} removeLocalService success`); 112 myExpect(data); 113 done(); 114 } 115 }); 116 } 117 }); 118 }); 119 120 /** 121 * @tc.number SUB_Telephony_NetManager_addLocalService_Async_0400 122 * @tc.name Test addLocalService() interface 123 * @tc.desc Function test 124 */ 125 it('SUB_Telephony_NetManager_addLocalService_Async_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 126 let caseName = 'SUB_Telephony_NetManager_addLocalService_Async_0400'; 127 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 128 if (err) { 129 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 130 expect().assertFail(); 131 done(); 132 } else { 133 console.log(`${caseName} addLocalService success`); 134 myExpect(data); 135 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 136 if (err) { 137 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 138 expect(err != undefined).assertEqual(true); 139 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 140 if (err) { 141 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 142 expect().assertFail(); 143 done(); 144 } else { 145 console.log(`${caseName} removeLocalService success`); 146 myExpect(data); 147 done(); 148 } 149 }); 150 } else { 151 console.log(`${caseName} addLocalService success`); 152 expect().assertFail(); 153 done(); 154 } 155 }); 156 } 157 }); 158 }); 159 160 /** 161 * @tc.number SUB_Telephony_NetManager_addLocalService_Async_0500 162 * @tc.name Test addLocalService() interface 163 * @tc.desc Function test 164 */ 165 it('SUB_Telephony_NetManager_addLocalService_Async_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 166 let caseName = 'SUB_Telephony_NetManager_addLocalService_Async_0500'; 167 let localServiceInfo = {} 168 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 169 if (err) { 170 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 171 expect(err != undefined).assertEqual(true); 172 done(); 173 } else { 174 console.log(`${caseName} addLocalService success`); 175 expect().assertFail(); 176 done(); 177 } 178 }); 179 }); 180 181 /** 182 * @tc.number SUB_Telephony_NetManager_addLocalService_Async_0600 183 * @tc.name Test addLocalService() interface 184 * @tc.desc Function test 185 */ 186 it('SUB_Telephony_NetManager_addLocalService_Async_0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 187 let caseName = 'SUB_Telephony_NetManager_addLocalService_Async_0600'; 188 try { 189 mdns.addLocalService(null, localServiceInfo, (err, data) => { 190 if (err) { 191 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 192 expect().assertFail(); 193 done(); 194 } else { 195 console.log(`${caseName} addLocalService success`); 196 expect().assertFail(); 197 done(); 198 } 199 }); 200 } catch (err) { 201 console.log(`${caseName} addLocalService into catch ${JSON.stringify(err)}`); 202 expect(err != undefined).assertEqual(true) 203 done(); 204 } 205 }); 206 207 208 /** 209 * @tc.number SUB_Telephony_NetManager_addLocalService_Promise_0100 210 * @tc.name Test addLocalService() interface 211 * @tc.desc Function test 212 */ 213 it('SUB_Telephony_NetManager_addLocalService_Promise_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 214 let caseName = 'SUB_Telephony_NetManager_addLocalService_Promise_0100'; 215 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 216 console.log(`${caseName} addLocalService success `); 217 myExpect(data); 218 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 219 console.log(`${caseName} removeLocalService success `); 220 myExpect(data); 221 done(); 222 }).catch((err) => { 223 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 224 expect().assertFail(); 225 done(); 226 }); 227 }).catch((err) => { 228 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 229 expect().assertFail(); 230 done(); 231 }); 232 }); 233 234 /** 235 * @tc.number SUB_Telephony_NetManager_addLocalService_Promise_0400 236 * @tc.name Test addLocalService() interface 237 * @tc.desc Function test 238 */ 239 it('SUB_Telephony_NetManager_addLocalService_Promise_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 240 let caseName = 'SUB_Telephony_NetManager_addLocalService_Promise_0400'; 241 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 242 console.log(`${caseName} addLocalService success `); 243 myExpect(data); 244 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 245 console.log(`${caseName} addLocalService success `); 246 expect().assertFail(); 247 done(); 248 }).catch((err) => { 249 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 250 expect(err != undefined).assertEqual(true); 251 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 252 console.log(`${caseName} removeLocalService success `); 253 myExpect(data); 254 done(); 255 }).catch((err) => { 256 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 257 expect().assertFail(); 258 done(); 259 }); 260 }); 261 }).catch((err) => { 262 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 263 expect().assertFail(); 264 done(); 265 }); 266 }); 267 268 /** 269 * @tc.number SUB_Telephony_NetManager_addLocalService_Promise_0500 270 * @tc.name Test addLocalService() interface 271 * @tc.desc Function test 272 */ 273 it('SUB_Telephony_NetManager_addLocalService_Promise_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 274 let caseName = 'SUB_Telephony_NetManager_addLocalService_Promise_0500'; 275 let localServiceInfo = {} 276 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 277 console.log(`${caseName} addLocalService success `); 278 expect().assertFail(); 279 }).catch((err) => { 280 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 281 expect(err != undefined).assertEqual(true); 282 done(); 283 }); 284 }); 285 286 /** 287 * @tc.number SUB_Telephony_NetManager_addLocalService_Promise_0600 288 * @tc.name Test addLocalService() interface 289 * @tc.desc Function test 290 */ 291 it('SUB_Telephony_NetManager_addLocalService_Promise_0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 292 let caseName = 'SUB_Telephony_NetManager_addLocalService_Promise_0600'; 293 try { 294 mdns.addLocalService(null, localServiceInfo).then((data) => { 295 console.log(`${caseName} addLocalService success `); 296 expect().assertFail(); 297 }).catch((err) => { 298 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 299 expect().assertFail(); 300 done(); 301 }); 302 } catch (err) { 303 console.log(`${caseName} addLocalService into catch ${JSON.stringify(err)}`); 304 expect(err != undefined).assertEqual(true) 305 done(); 306 } 307 }); 308 309 310 /** 311 * @tc.number SUB_Telephony_NetManager_removeLocalService_Async_0100 312 * @tc.name Test removeLocalService() interface 313 * @tc.desc Function test 314 */ 315 it('SUB_Telephony_NetManager_removeLocalService_Async_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 316 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Async_0100'; 317 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 318 if (err) { 319 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 320 expect().assertFail(); 321 done(); 322 } else { 323 console.log(`${caseName} addLocalService success `); 324 myExpect(data); 325 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 326 if (err) { 327 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 328 expect().assertFail(); 329 done(); 330 } else { 331 console.log(`${caseName} removeLocalService success `); 332 expect(err).assertEqual(undefined); 333 myExpect(data); 334 done(); 335 } 336 }); 337 } 338 }); 339 }); 340 341 /** 342 * @tc.number SUB_Telephony_NetManager_removeLocalService_Async_0400 343 * @tc.name Test removeLocalService() interface 344 * @tc.desc Function test 345 */ 346 it('SUB_Telephony_NetManager_removeLocalService_Async_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 347 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Async_0400'; 348 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 349 if (err) { 350 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 351 expect().assertFail(); 352 done(); 353 } else { 354 console.log(`${caseName} addLocalService success `); 355 myExpect(data); 356 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 357 if (err) { 358 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 359 expect().assertFail(); 360 done(); 361 } else { 362 console.log(`${caseName} removeLocalService success `); 363 expect(err).assertEqual(undefined); 364 myExpect(data); 365 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 366 if (err) { 367 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 368 expect(err != undefined).assertEqual(true); 369 done(); 370 } else { 371 console.log(`${caseName} removeLocalService success `); 372 expect().assertFail(); 373 done(); 374 } 375 }); 376 } 377 }); 378 } 379 }); 380 }); 381 382 /** 383 * @tc.number SUB_Telephony_NetManager_removeLocalService_Async_0500 384 * @tc.name Test removeLocalService() interface 385 * @tc.desc Function test 386 */ 387 it('SUB_Telephony_NetManager_removeLocalService_Async_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 388 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Async_0500'; 389 let localServiceInfo = {} 390 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 391 if (err) { 392 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 393 expect(err != undefined).assertEqual(true); 394 done(); 395 } else { 396 console.log(`${caseName} removeLocalService success `); 397 expect().assertFail(); 398 done(); 399 } 400 }); 401 }); 402 403 /** 404 * @tc.number SUB_Telephony_NetManager_removeLocalService_Async_0600 405 * @tc.name Test removeLocalService() interface 406 * @tc.desc Function test 407 */ 408 it('SUB_Telephony_NetManager_removeLocalService_Async_0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 409 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Async_0600'; 410 try { 411 mdns.removeLocalService(null, localServiceInfo, (err, data) => { 412 if (err) { 413 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 414 expect().assertFail(); 415 done(); 416 } else { 417 console.log(`${caseName} removeLocalService success `); 418 expect().assertFail(); 419 done(); 420 } 421 }); 422 } catch (err) { 423 console.log(`${caseName} removeLocalService into catch ${JSON.stringify(err)}`); 424 expect(err != undefined).assertEqual(true); 425 done(); 426 } 427 }); 428 429 /** 430 * @tc.number SUB_Telephony_NetManager_removeLocalService_Promise_0100 431 * @tc.name Test removeLocalService() interface 432 * @tc.desc Function test 433 */ 434 it('SUB_Telephony_NetManager_removeLocalService_Promise_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 435 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Promise_0100'; 436 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 437 console.log(`${caseName} addLocalService success `); 438 myExpect(data); 439 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 440 console.log(`${caseName} removeLocalService success`); 441 myExpect(data); 442 done(); 443 }).catch((err) => { 444 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 445 expect().assertFail(); 446 done(); 447 }); 448 }).catch((err) => { 449 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 450 expect().assertFail(); 451 done(); 452 }); 453 }); 454 455 /** 456 * @tc.number SUB_Telephony_NetManager_removeLocalService_Promise_0400 457 * @tc.name Test removeLocalService() interface 458 * @tc.desc Function test 459 */ 460 it('SUB_Telephony_NetManager_removeLocalService_Promise_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 461 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Promise_0400'; 462 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 463 console.log(`${caseName} addLocalService success `); 464 myExpect(data); 465 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 466 console.log(`${caseName} removeLocalService success`); 467 myExpect(data); 468 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 469 console.log(`${caseName} removeLocalService success`); 470 expect().assertFail(); 471 myExpect(data); 472 done(); 473 }).catch((err) => { 474 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 475 expect(err != undefined).assertEqual(true); 476 done(); 477 }); 478 }).catch((err) => { 479 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 480 expect().assertFail(); 481 done(); 482 }); 483 }).catch((err) => { 484 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 485 expect().assertFail(); 486 done(); 487 }); 488 }); 489 490 /** 491 * @tc.number SUB_Telephony_NetManager_removeLocalService_Promise_0500 492 * @tc.name Test removeLocalService() interface 493 * @tc.desc Function test 494 */ 495 it('SUB_Telephony_NetManager_removeLocalService_Promise_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 496 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Promise_0500'; 497 let localServiceInfo = {} 498 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 499 console.log(`${caseName} removeLocalService success`); 500 expect().assertFail(); 501 done(); 502 }).catch((err) => { 503 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 504 expect(err != undefined).assertEqual(true); 505 done(); 506 }); 507 }); 508 509 /** 510 * @tc.number SUB_Telephony_NetManager_removeLocalService_Promise_0600 511 * @tc.name Test removeLocalService() interface 512 * @tc.desc Function test 513 */ 514 it('SUB_Telephony_NetManager_removeLocalService_Promise_0600', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 515 let caseName = 'SUB_Telephony_NetManager_removeLocalService_Promise_0600'; 516 try { 517 mdns.removeLocalService(null, localServiceInfo).then((data) => { 518 console.log(`${caseName} removeLocalService success`); 519 expect().assertFail(); 520 done(); 521 }).catch((err) => { 522 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 523 expect().assertFail(); 524 done(); 525 }); 526 } catch (err) { 527 console.log(`${caseName} removeLocalService into catch ${JSON.stringify(err)}`); 528 expect(err != undefined).assertEqual(true); 529 done(); 530 } 531 }); 532 533 534 /** 535 * @tc.number SUB_Telephony_NetManager_createDiscoveryService_0100 536 * @tc.name Test createDiscoveryService() interface 537 * @tc.desc Function test 538 */ 539 it('SUB_Telephony_NetManager_createDiscoveryService_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 540 let caseName = 'SUB_Telephony_NetManager_createDiscoveryService_0100'; 541 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 542 if (discoveryService != undefined) { 543 console.log(`${caseName} createDiscoveryService success`); 544 expect(discoveryService).assertInstanceOf('Object'); 545 done(); 546 } else { 547 console.log(`${caseName} createDiscoveryService fail`); 548 expect().assertFail(); 549 done(); 550 } 551 }); 552 553 /** 554 * @tc.number SUB_Telephony_NetManager_createDiscoveryService_0400 555 * @tc.name Test createDiscoveryService() interface 556 * @tc.desc Function test 557 */ 558 it('SUB_Telephony_NetManager_createDiscoveryService_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 559 let caseName = 'SUB_Telephony_NetManager_createDiscoveryService_0400'; 560 let discoveryService = mdns.createDiscoveryService(bundleName, null); 561 if (discoveryService != undefined) { 562 console.log(`${caseName} createDiscoveryService success`); 563 expect().assertFail(); 564 done(); 565 } else { 566 console.log(`${caseName} createDiscoveryService fail`); 567 expect(discoveryService == undefined).assertEqual(true); 568 done(); 569 } 570 }); 571 572 /** 573 * @tc.number SUB_Telephony_NetManager_createDiscoveryService_0500 574 * @tc.name Test createDiscoveryService() interface 575 * @tc.desc Function test 576 */ 577 it('SUB_Telephony_NetManager_createDiscoveryService_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 578 let caseName = 'SUB_Telephony_NetManager_createDiscoveryService_0500'; 579 let discoveryService = mdns.createDiscoveryService(null, "_print._tcp"); 580 if (discoveryService != undefined) { 581 console.log(`${caseName} createDiscoveryService success`); 582 expect().assertFail(); 583 done(); 584 } else { 585 console.log(`${caseName} createDiscoveryService fail`); 586 expect(discoveryService == undefined).assertEqual(true); 587 done(); 588 } 589 }); 590 591 592 /** 593 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Async_0100 594 * @tc.name Test resolveLocalService() interface 595 * @tc.desc Function test 596 */ 597 it('SUB_Telephony_NetManager_resolveLocalService_Async_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 598 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Async_0100'; 599 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 600 if (err) { 601 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 602 expect().assertFail(); 603 done(); 604 } else { 605 console.log(`${caseName} addLocalService success`); 606 myExpect(data); 607 mdns.resolveLocalService(bundleName, localServiceInfo, (err, data) => { 608 if (err) { 609 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 610 expect().assertFail(); 611 done(); 612 } else { 613 console.log(`${caseName} resolveLocalService success `); 614 expect(err).assertEqual(undefined); 615 expect(data.serviceType).assertEqual(localServiceInfo.serviceType); 616 expect(data.serviceName).assertEqual(localServiceInfo.serviceName); 617 expect(data.port).assertEqual(localServiceInfo.port); 618 expect(typeof (data.host.address)).assertEqual(typeof (localServiceInfo.host.address)); 619 expect(data.host.family).assertEqual(localServiceInfo.host.family); 620 expect(data.host.port).assertEqual(localServiceInfo.host.port); 621 expect(data.serviceAttribute[0].key[0]).assertEqual(localServiceInfo.serviceAttribute[0].key[0]); 622 expect(data.serviceAttribute[0].value[0]).assertEqual(localServiceInfo.serviceAttribute[0].value[0]); 623 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 624 if (err) { 625 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 626 expect().assertFail(); 627 done(); 628 } else { 629 console.log(`${caseName} removeLocalService success `); 630 expect(err).assertEqual(undefined); 631 myExpect(data); 632 done(); 633 } 634 }); 635 } 636 }); 637 } 638 }); 639 }); 640 641 /** 642 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Async_0400 643 * @tc.name Test resolveLocalService() interface 644 * @tc.desc Function test 645 */ 646 it('SUB_Telephony_NetManager_resolveLocalService_Async_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 647 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Async_0400'; 648 let localServiceInfo = {}; 649 mdns.resolveLocalService(bundleName, localServiceInfo, (err, data) => { 650 if (err) { 651 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 652 expect(err != undefined).assertEqual(true); 653 done(); 654 } else { 655 console.log(`${caseName} resolveLocalService success `); 656 expect().assertFail(); 657 done(); 658 } 659 }); 660 }); 661 662 /** 663 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Async_0500 664 * @tc.name Test resolveLocalService() interface 665 * @tc.desc Function test 666 */ 667 it('SUB_Telephony_NetManager_resolveLocalService_Async_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 668 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Async_0500'; 669 try { 670 mdns.resolveLocalService(null, localServiceInfo, (err, data) => { 671 if (err) { 672 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 673 expect().assertFail(); 674 done(); 675 } else { 676 console.log(`${caseName} resolveLocalService success `); 677 expect().assertFail(); 678 done(); 679 } 680 }); 681 } catch (err) { 682 console.log(`${caseName} resolveLocalService into catch ${JSON.stringify(err)}`); 683 expect(err != undefined).assertEqual(true); 684 done(); 685 } 686 }); 687 688 /** 689 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Promise_0100 690 * @tc.name Test resolveLocalService() interface 691 * @tc.desc Function test 692 */ 693 it('SUB_Telephony_NetManager_resolveLocalService_Promise_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 694 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Promise_0100'; 695 mdns.addLocalService(bundleName, localServiceInfo).then((data) => { 696 console.log(`${caseName} addLocalService success `); 697 myExpect(data); 698 mdns.resolveLocalService(bundleName, localServiceInfo).then((data) => { 699 console.log(`${caseName} resolveLocalService success `); 700 expect(data.serviceType).assertEqual(localServiceInfo.serviceType); 701 expect(data.serviceName).assertEqual(localServiceInfo.serviceName); 702 expect(data.port).assertEqual(localServiceInfo.port); 703 expect(typeof (data.host.address)).assertEqual(typeof (localServiceInfo.host.address)); 704 expect(data.host.family).assertEqual(localServiceInfo.host.family); 705 expect(data.host.port).assertEqual(localServiceInfo.host.port); 706 expect(data.serviceAttribute[0].key[0]).assertEqual(localServiceInfo.serviceAttribute[0].key[0]); 707 expect(data.serviceAttribute[0].value[0]).assertEqual(localServiceInfo.serviceAttribute[0].value[0]); 708 mdns.removeLocalService(bundleName, localServiceInfo).then((data) => { 709 console.log(`${caseName} removeLocalService success `); 710 myExpect(data); 711 done(); 712 }).catch((err) => { 713 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 714 expect().assertFail(); 715 done(); 716 }); 717 }).catch((err) => { 718 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 719 expect().assertFail(); 720 done(); 721 }); 722 }).catch((err) => { 723 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 724 expect().assertFail(); 725 done(); 726 }); 727 }); 728 729 /** 730 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Promise_0400 731 * @tc.name Test resolveLocalService() interface 732 * @tc.desc Function test 733 */ 734 it('SUB_Telephony_NetManager_resolveLocalService_Promise_0400', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 735 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Promise_0400'; 736 let localServiceInfo = {}; 737 mdns.resolveLocalService(bundleName, localServiceInfo).then((data) => { 738 console.log(`${caseName} resolveLocalService success `); 739 expect().assertFail(); 740 done(); 741 }).catch((err) => { 742 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 743 expect(err != undefined).assertEqual(true); 744 done(); 745 }); 746 }); 747 748 /** 749 * @tc.number SUB_Telephony_NetManager_resolveLocalService_Promise_0500 750 * @tc.name Test resolveLocalService() interface 751 * @tc.desc Function test 752 */ 753 it('SUB_Telephony_NetManager_resolveLocalService_Promise_0500', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 754 let caseName = 'SUB_Telephony_NetManager_resolveLocalService_Promise_0500'; 755 try { 756 mdns.resolveLocalService(null, localServiceInfo).then((data) => { 757 console.log(`${caseName} resolveLocalService success `); 758 expect().assertFail(); 759 done(); 760 }).catch((err) => { 761 console.log(`${caseName} resolveLocalService fail ${JSON.stringify(err)}`); 762 expect().assertFail(); 763 done(); 764 }); 765 } catch (err) { 766 console.log(`${caseName} resolveLocalService into catch ${JSON.stringify(err)}`); 767 expect(err != undefined).assertEqual(true); 768 done(); 769 } 770 }); 771 772 773 /** 774 * @tc.number SUB_Telephony_NetManager_startSearchingMDNS_0100 775 * @tc.name Test startSearchingMDNS() interface 776 * @tc.desc Function test 777 */ 778 it('SUB_Telephony_NetManager_startSearchingMDNS_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 779 let caseName = 'SUB_Telephony_NetManager_startSearchingMDNS_0100'; 780 startSearching_status = false; 781 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 782 discoveryService.on("discoveryStart", startSearching); 783 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 784 if (err) { 785 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 786 expect().assertFail(); 787 done(); 788 } else { 789 console.log(`${caseName} addLocalService success `); 790 discoveryService.startSearchingMDNS(); 791 setTimeout(() => { 792 discoveryService.stopSearchingMDNS(); 793 setTimeout(() => { 794 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 795 if (err) { 796 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 797 expect().assertFail(); 798 done(); 799 } else { 800 console.log(`${caseName} removeLocalService success `); 801 expect(err).assertEqual(undefined); 802 setTimeout(() => { 803 expect(startSearching_status).assertEqual(true); 804 discoveryService.off("discoveryStart"); 805 done(); 806 }, delayTime) 807 } 808 }); 809 }, delayTime) 810 }, delayTime) 811 } 812 }); 813 }); 814 815 816 /** 817 * @tc.number SUB_Telephony_NetManager_stopSearchingMDNS_0100 818 * @tc.name Test stopSearchingMDNS() interface 819 * @tc.desc Function test 820 */ 821 it('SUB_Telephony_NetManager_stopSearchingMDNS_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 822 let caseName = 'SUB_Telephony_NetManager_stopSearchingMDNS_0100'; 823 stopSearching_status = false; 824 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 825 discoveryService.on("discoveryStop", stopSearching); 826 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 827 if (err) { 828 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 829 expect().assertFail(); 830 done(); 831 } else { 832 console.log(`${caseName} addLocalService success `); 833 discoveryService.startSearchingMDNS(); 834 setTimeout(() => { 835 discoveryService.stopSearchingMDNS(); 836 setTimeout(() => { 837 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 838 if (err) { 839 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 840 expect().assertFail(); 841 done(); 842 } else { 843 console.log(`${caseName} removeLocalService success `); 844 expect(err).assertEqual(undefined); 845 setTimeout(() => { 846 expect(stopSearching_status).assertEqual(true); 847 discoveryService.off("discoveryStop"); 848 done(); 849 }, delayTime) 850 } 851 }); 852 }, delayTime) 853 }, delayTime) 854 } 855 }); 856 }); 857 858 /** 859 * @tc.number SUB_Telephony_NetManager_on_discoveryStart_0100 860 * @tc.name Test on() interface 861 * @tc.desc Function test 862 */ 863 it('SUB_Telephony_NetManager_on_discoveryStart_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 864 let caseName = 'SUB_Telephony_NetManager_on_discoveryStart_0100'; 865 startSearching_status = false; 866 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 867 discoveryService.on("discoveryStart", startSearching); 868 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 869 if (err) { 870 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 871 expect().assertFail(); 872 done(); 873 } else { 874 console.log(`${caseName} addLocalService success`); 875 discoveryService.startSearchingMDNS(); 876 setTimeout(() => { 877 discoveryService.stopSearchingMDNS(); 878 setTimeout(() => { 879 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 880 if (err) { 881 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 882 expect().assertFail(); 883 done(); 884 } else { 885 console.log(`${caseName} removeLocalService success`); 886 expect(err).assertEqual(undefined); 887 setTimeout(() => { 888 expect(startSearching_status).assertEqual(true); 889 discoveryService.off("discoveryStart"); 890 done(); 891 }, delayTime) 892 } 893 }); 894 }, delayTime) 895 }, delayTime) 896 } 897 }); 898 }); 899 900 /** 901 * @tc.number SUB_Telephony_NetManager_on_discoveryStop_0100 902 * @tc.name Test on() interface 903 * @tc.desc Function test 904 */ 905 it('SUB_Telephony_NetManager_on_discoveryStop_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 906 let caseName = 'SUB_Telephony_NetManager_on_discoveryStop_0100'; 907 stopSearching_status = false; 908 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 909 discoveryService.on("discoveryStop", stopSearching); 910 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 911 if (err) { 912 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 913 expect().assertFail(); 914 done(); 915 } else { 916 console.log(`${caseName} addLocalService success `); 917 discoveryService.startSearchingMDNS(); 918 setTimeout(() => { 919 discoveryService.stopSearchingMDNS(); 920 setTimeout(() => { 921 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 922 if (err) { 923 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 924 expect().assertFail(); 925 done(); 926 } else { 927 console.log(`${caseName} removeLocalService success `); 928 expect(err).assertEqual(undefined); 929 setTimeout(() => { 930 expect(stopSearching_status).assertEqual(true); 931 discoveryService.off("discoveryStop"); 932 done(); 933 }, delayTime) 934 } 935 }); 936 }, delayTime) 937 }, delayTime) 938 } 939 }); 940 }); 941 942 /** 943 * @tc.number SUB_Telephony_NetManager_on_serviceFound_0100 944 * @tc.name Test on() interface 945 * @tc.desc Function test 946 */ 947 it('SUB_Telephony_NetManager_on_serviceFound_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 948 let caseName = 'SUB_Telephony_NetManager_on_serviceFound_0100'; 949 found_status = false; 950 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 951 discoveryService.on("serviceFound", found); 952 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 953 if (err) { 954 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 955 expect().assertFail(); 956 done(); 957 } else { 958 console.log(`${caseName} addLocalService success `); 959 discoveryService.startSearchingMDNS(); 960 setTimeout(() => { 961 discoveryService.stopSearchingMDNS(); 962 setTimeout(() => { 963 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 964 if (err) { 965 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 966 expect().assertFail(); 967 done(); 968 } else { 969 console.log(`${caseName} removeLocalService success `); 970 expect(err).assertEqual(undefined); 971 setTimeout(() => { 972 expect(found_status).assertEqual(true); 973 discoveryService.off("serviceFound"); 974 done(); 975 }, delayTime) 976 } 977 }); 978 }, delayTime) 979 }, delayTime) 980 } 981 }); 982 }); 983 984 /** 985 * @tc.number SUB_Telephony_NetManager_on_serviceLost_0100 986 * @tc.name Test on() interface 987 * @tc.desc Function test 988 */ 989 it('SUB_Telephony_NetManager_on_serviceLost_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 990 let caseName = 'SUB_Telephony_NetManager_on_serviceLost_0100'; 991 lost_status = false; 992 let discoveryService = mdns.createDiscoveryService(bundleName, "_print._tcp"); 993 discoveryService.on("serviceLost", lost); 994 mdns.addLocalService(bundleName, localServiceInfo, (err, data) => { 995 if (err) { 996 console.log(`${caseName} addLocalService fail ${JSON.stringify(err)}`); 997 expect().assertFail(); 998 done(); 999 } else { 1000 console.log(`${caseName} addLocalService success `); 1001 discoveryService.startSearchingMDNS(); 1002 setTimeout(() => { 1003 mdns.removeLocalService(bundleName, localServiceInfo, (err, data) => { 1004 if (err) { 1005 console.log(`${caseName} removeLocalService fail ${JSON.stringify(err)}`); 1006 expect().assertFail(); 1007 done(); 1008 } else { 1009 console.log(`${caseName} removeLocalService success `); 1010 expect(err).assertEqual(undefined); 1011 setTimeout(() => { 1012 expect(lost_status).assertEqual(true); 1013 discoveryService.off("serviceLost"); 1014 done(); 1015 }, delayTime) 1016 } 1017 }); 1018 }, delayTime) 1019 } 1020 }); 1021 }); 1022 1023 /** 1024 * @tc.number SUB_Telephony_NetManager_MdnsError_0100 1025 * @tc.name Test MdnsError enum 1026 * @tc.desc Function test 1027 */ 1028 it('SUB_Telephony_NetManager_MdnsError_0100', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function (done) { 1029 let caseName = 'SUB_Telephony_NetManager_MdnsError_0100'; 1030 expect(mdns.MdnsError.INTERNAL_ERROR == 0 ).assertTrue(); 1031 expect(mdns.MdnsError.ALREADY_ACTIVE == 1 ).assertTrue(); 1032 expect(mdns.MdnsError.MAX_LIMIT == 2 ).assertTrue(); 1033 console.info(caseName + "test finish!"); 1034 done(); 1035 }); 1036 1037 }); 1038}