1/*Pop 2 * Copyright (C) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the 'License') 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an 'AS IS' BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15import Vector from "@ohos.util.Vector"; 16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium' 17export default function VectorTest() { 18describe("VectorTest", function () { 19 20 /** 21 * @tc.name: testConstructor001 22 * @tc.desc: Create an Vector instance. For example: let vector = new Vector(). 23 */ 24 it("testConstructor001", 0, function () { 25 try { 26 let vector = new Vector(); 27 } catch (err) { 28 expect(err.name).assertEqual("TypeError"); 29 expect(err.message).assertEqual("Cannot create new vector"); 30 } 31 }); 32 33 /** 34 * @tc.name: testAdd002 35 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add("四"). 36 */ 37 it("testAdd002", 0, function () { 38 let vector = new Vector(); 39 vector.add("四"); 40 let res = vector.getFirstElement(); 41 expect(res).assertEqual("四"); 42 }); 43 44 /** 45 * @tc.name: testAdd003 46 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add(4). 47 */ 48 it("testAdd003", 0, function () { 49 let vector = new Vector(); 50 vector.add(4); 51 let res = vector.getFirstElement(); 52 expect(res).assertEqual(4); 53 }); 54 55 /** 56 * @tc.name: testAdd004 57 * @tc.desc: Add a element to the end of the Vector instance. 58 * For example: let a = {name: "lala", age: "13岁"}; vector.add(a). 59 */ 60 it("testAdd004", 0, function () { 61 let vector = new Vector(); 62 let a = {name: "lala", age: "13岁"}; 63 vector.add(a); 64 let res = vector.getFirstElement(); 65 expect(res).assertEqual(a); 66 }); 67 68 /** 69 * @tc.name: testAdd005 70 * @tc.desc: Add a element to the end of the Vector instance. For example: let a = [1, 2, 3, 4]; vector.add(a). 71 */ 72 it("testAdd005", 0, function () { 73 let vector = new Vector(); 74 let a = [1, 2, 3, 4]; 75 vector.add(a); 76 let res = vector.getFirstElement(); 77 expect(res).assertEqual(a); 78 }); 79 80 /** 81 * @tc.name: testInsert006 82 * @tc.desc: Insert an element into the middle of the Vector instance. For example: vector.insert(8, 2). 83 */ 84 it("testInsert006", 0, function () { 85 let vector = new Vector(); 86 vector.add("四"); 87 vector.add("三"); 88 vector.add(1); 89 vector.add("a"); 90 vector.insert(8, 2); 91 let res = vector.get(2); 92 expect(res).assertEqual(8); 93 }); 94 95 /** 96 * @tc.name: testInsert007 97 * @tc.desc: Insert an element into the middle of the Vector instance. For example: vector.insert(-1, 2). 98 */ 99 it("testInsert007", 0, function () { 100 let vector = new Vector(); 101 vector.add("四"); 102 vector.add("三"); 103 vector.add(1); 104 vector.add("a"); 105 try { 106 vector.insert(-1, 2); 107 } catch (err) { 108 expect(err.name).assertEqual("RangeError"); 109 expect(err.message).assertEqual("the index is out-of-bounds"); 110 } 111 }); 112 113 /** 114 * @tc.name: testInsert008 115 * @tc.desc: Insert an element into the middle of the Vector instance. For example: vector.insert(capacity, 2). 116 */ 117 it("testInsert008", 0, function () { 118 let vector = new Vector(); 119 vector.add("四"); 120 vector.add("三"); 121 vector.add(1); 122 vector.add("a"); 123 let capacity = vector.getCapacity(); 124 vector.insert(capacity, 2); 125 let res = vector.get(2); 126 expect(res).assertEqual(10); 127 }); 128 129 /** 130 * @tc.name: testInsert009 131 * @tc.desc: Insert an element into the middle of the Vector instance. For example: vector.insert(2, capacity + 1). 132 */ 133 it("testInsert009", 0, function () { 134 let vector = new Vector(); 135 vector.add("四"); 136 vector.add("三"); 137 vector.add(1); 138 vector.add("a"); 139 let capacity = vector.getCapacity(); 140 try { 141 vector.insert(2, capacity + 1); 142 } catch (err) { 143 expect(err.name).assertEqual("RangeError"); 144 expect(err.message).assertEqual("the index is out-of-bounds"); 145 } 146 }); 147 148 /** 149 * @tc.name: testLength010 150 * @tc.desc: Get the number of elements contained in the Vector instance. For example: vector.length. 151 */ 152 it("testLength010", 0, function () { 153 let vector = new Vector(); 154 vector.add("四"); 155 vector.add("三"); 156 vector.add(1); 157 vector.add("a"); 158 let res = vector.length; 159 expect(res).assertEqual(4); 160 }); 161 162 /** 163 * @tc.name: testHas011 164 * @tc.desc: Check whether the Vector contains a specified element. For example: vector.has(8). 165 */ 166 it("testHas011", 0, function () { 167 let vector = new Vector(); 168 vector.add("四"); 169 vector.add("三"); 170 vector.add(1); 171 vector.add("a"); 172 vector.insert(8, 2); 173 let res = vector.has(8); 174 expect(res).assertEqual(true); 175 }); 176 177 /** 178 * @tc.name: testHas012 179 * @tc.desc: Check whether the Vector contains a specified element. For example: vector.has("二"). 180 */ 181 it("testHas012", 0, function () { 182 let vector = new Vector(); 183 vector.add("四"); 184 vector.add("三"); 185 vector.add(1); 186 vector.add("a"); 187 vector.insert(8, 2); 188 let res1 = vector.has("二"); 189 expect(res1).assertEqual(false); 190 }); 191 192 /** 193 * @tc.name: testGet013 194 * @tc.desc: Gets the element corresponding to the specified index. For example: vector.get(1). 195 */ 196 it("testGet013", 0, function () { 197 let vector = new Vector(); 198 vector.add("四"); 199 vector.add("三"); 200 vector.add(1); 201 vector.add("a"); 202 vector.insert(8, 2); 203 let res1 = vector.get(1); 204 expect(res1).assertEqual("三"); 205 }); 206 207 /** 208 * @tc.name: testGet014 209 * @tc.desc: Gets the element corresponding to the specified index. For example: vector.get(10). 210 */ 211 it("testGet014", 0, function () { 212 let vector = new Vector(); 213 vector.add("四"); 214 vector.add("三"); 215 vector.add(1); 216 vector.add("a"); 217 vector.insert(8, 2); 218 try { 219 let res = vector.get(10); 220 } catch (err) { 221 expect(err.name).assertEqual("RangeError"); 222 expect(err.message).assertEqual("the index is out-of-bounds"); 223 } 224 }); 225 226 /** 227 * @tc.name: testGetIndexOf015 228 * @tc.desc: In the Vector instance, find the index of a specified element from front to back, 229 * and return the index found for the first time. If not found, return -1. For example: vector.getIndexOf(1). 230 */ 231 it("testGetIndexOf015", 0, function () { 232 let vector = new Vector(); 233 vector.add(1); 234 vector.add("三"); 235 vector.add(1); 236 vector.add("a"); 237 vector.insert(1, 2); 238 let res1 = vector.getIndexOf(1); 239 expect(res1).assertEqual(0); 240 }); 241 242 /** 243 * @tc.name: testGetFirstElement016 244 * @tc.desc: Get the header element of the Vector instance. For example: vector.getFirstElement(). 245 */ 246 it("testGetFirstElement016", 0, function () { 247 let vector = new Vector(); 248 vector.add("四"); 249 vector.add("三"); 250 vector.add(1); 251 vector.add("a"); 252 vector.insert(8, 2); 253 let res = vector.getFirstElement(); 254 expect(res).assertEqual("四"); 255 }); 256 257 /** 258 * @tc.name: testGetFirstElement017 259 * @tc.desc: Get the header element of the Vector instance. For example: vector.getFirstElement(). 260 */ 261 it("testGetFirstElement017", 0, function () { 262 let vector = new Vector(); 263 let res = vector.getFirstElement(); 264 expect(res).assertEqual(undefined); 265 }); 266 267 /** 268 * @tc.name: testSet018 269 * @tc.desc: Modify the element corresponding to the specified index. For example: vector.set(1, "二"). 270 */ 271 it("testSet018", 0, function () { 272 let vector = new Vector(); 273 vector.add("四"); 274 vector.add("三"); 275 vector.add(1); 276 vector.add("a"); 277 vector.insert(8, 2); 278 vector.set(1, "二"); 279 let res = vector.get(1); 280 expect(res).assertEqual("二"); 281 }); 282 283 /** 284 * @tc.name: testRemoveByIndex019 285 * @tc.desc: In the Vector instance, delete the element based on its index. For example: vector.removeByIndex(2). 286 */ 287 it("testRemoveByIndex019", 0, function () { 288 let vector = new Vector(); 289 vector.add("四"); 290 vector.add("三"); 291 vector.add(1); 292 vector.add("a"); 293 vector.removeByIndex(2); 294 let res = vector.has(1); 295 expect(res).assertEqual(false); 296 }); 297 298 /** 299 * @tc.name: testRemove020 300 * @tc.desc: Delete the specified element. For example: vector.remove("三"). 301 */ 302 it("testRemove020", 0, function () { 303 let vector = new Vector(); 304 vector.add("四"); 305 vector.add("三"); 306 vector.add(1); 307 vector.add("a"); 308 vector.remove("三"); 309 let res = vector.has("三"); 310 expect(res).assertEqual(false); 311 }); 312 313 /** 314 * @tc.name: testRemove021 315 * @tc.desc: Delete the specified element. For example: vector.remove(2). 316 */ 317 it("testRemove021", 0, function () { 318 let vector = new Vector(); 319 vector.add("四"); 320 vector.add("三"); 321 vector.add(1); 322 vector.add("a"); 323 let res = vector.remove(2); 324 expect(res).assertEqual(false); 325 }); 326 327 /** 328 * @tc.name: testGetLastElement022 329 * @tc.desc: Get the end element of the Vector instance. For example: vector.getLastElement(). 330 */ 331 it("testGetLastElement022", 0, function () { 332 let vector = new Vector(); 333 vector.add("四"); 334 vector.add("三"); 335 vector.add(1); 336 vector.add("a"); 337 let res1 = vector.length; 338 let res = vector.getLastElement(); 339 expect(res).assertEqual("a"); 340 }); 341 342 /** 343 * @tc.name: testGetLastElement023 344 * @tc.desc: Get the end element of the Vector instance. For example: vector.getLastElement(). 345 */ 346 it("testGetLastElement023", 0, function () { 347 let vector = new Vector(); 348 let res = vector.getLastElement(); 349 expect(res).assertEqual(undefined); 350 }); 351 352 /** 353 * @tc.name: testGetLastIndexOf024 354 * @tc.desc: In the Vector instance, find the index of a specified element from back to front, 355 * and return the index found for the first time. If not found, return -1. For example: vector.getLastIndexOf(1). 356 */ 357 it("testGetLastIndexOf024", 0, function () { 358 let vector = new Vector(); 359 vector.add("四"); 360 vector.add("三"); 361 vector.add(1); 362 vector.add("a"); 363 vector.add(1); 364 vector.add("b"); 365 let res = vector.getLastIndexOf(1); 366 expect(res).assertEqual(4); 367 }); 368 369 /** 370 * @tc.name: testGetLastIndexFrom025 371 * In the vector instance, find the index of the specified element from back to front 372 * from the specified index position, and return the index found for the first time If not found, 373 * return -1.vector.getLastIndexFrom(1, 5). 374 */ 375 it("testGetLastIndexFrom025", 0, function () { 376 let vector = new Vector(); 377 vector.add("四"); 378 vector.add("三"); 379 vector.add(1); 380 vector.add("a"); 381 vector.add(1); 382 vector.add("b"); 383 vector.add("c"); 384 vector.add(1); 385 let res = vector.getLastIndexFrom(1, 5); 386 expect(res).assertEqual(4); 387 }); 388 389 /** 390 * @tc.name: testGetIndexFrom026 391 * In the vector instance, find the index of the specified element from front to back 392 * from the specified index position, and return the index found for the first time If not found, 393 * return -1.vector.getLastIndexFrom(1, 5). 394 */ 395 it("testGetIndexFrom026", 0, function () { 396 let vector = new Vector(); 397 vector.add("四"); 398 vector.add("三"); 399 vector.add(1); 400 vector.add("a"); 401 vector.add(1); 402 vector.add("b"); 403 vector.add("c"); 404 vector.add(1); 405 let res = vector.getIndexFrom(1, 5); 406 expect(res).assertEqual(7); 407 }); 408 409 /** 410 * @tc.name: testRemoveByRange027 411 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 412 * elements at the end position. For example: vector.removeByRange(1, 3). 413 */ 414 it("testRemoveByRange027", 0, function () { 415 let vector = new Vector(); 416 vector.add("四"); 417 vector.add("三"); 418 vector.add(1); 419 vector.add("a"); 420 vector.add(1); 421 vector.add("b"); 422 vector.add("c"); 423 vector.add(1); 424 vector.removeByRange(1, 3); 425 let arr = []; 426 vector.forEach((item, index) => { 427 arr.push(item); 428 }); 429 let a = ["四", "a", 1, "b", "c", 1]; 430 for (let i = 0; i < a.length; i++) { 431 expect(arr[i]).assertEqual(a[i]); 432 } 433 }); 434 435 /** 436 * @tc.name: testRemoveByRange028 437 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 438 * elements at the end position. For example: vector.removeByRange(3, 1). 439 */ 440 it("testRemoveByRange028", 0, function () { 441 let vector = new Vector(); 442 vector.add("四"); 443 vector.add("三"); 444 vector.add(1); 445 vector.add("a"); 446 vector.add(1); 447 vector.add("b"); 448 vector.add("c"); 449 vector.add(1); 450 try { 451 vector.removeByRange(3, 1); 452 } catch (err) { 453 expect(err.name).assertEqual("RangeError"); 454 expect(err.message).assertEqual("the fromIndex cannot be less than or equal to toIndex"); 455 } 456 }); 457 458 /** 459 * @tc.name: testRemoveByRange029 460 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 461 * elements at the end position. For example: vector.removeByRange(length + 1, 7). 462 */ 463 it("testRemoveByRange029", 0, function () { 464 let vector = new Vector(); 465 vector.add("四"); 466 vector.add("三"); 467 vector.add(1); 468 let length = vector.length; 469 try { 470 vector.removeByRange(length + 1, 7); 471 } catch (err) { 472 expect(err.name).assertEqual("RangeError"); 473 expect(err.message).assertEqual("the fromIndex or the toIndex is out-of-bounds"); 474 } 475 }); 476 477 /** 478 * @tc.name: testRemoveByRange030 479 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 480 * elements at the end position. For example: vector.removeByRange(1, 7). 481 */ 482 it("testRemoveByRange030", 0, function () { 483 let vector = new Vector(); 484 vector.add("四"); 485 vector.add("三"); 486 vector.add(1); 487 let length = vector.length; 488 try { 489 vector.removeByRange(1, 7); 490 } catch (err) { 491 expect(err.name).assertEqual("RangeError"); 492 expect(err.message).assertEqual("the index is out-of-bounds"); 493 } 494 }); 495 496 /** 497 * @tc.name: testRemoveByRange031 498 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 499 * elements at the end position. For example: vector.removeByRange(0, capacity). 500 */ 501 it("testRemoveByRange031", 0, function () { 502 let vector = new Vector(); 503 vector.add("四"); 504 vector.add("三"); 505 vector.add(1); 506 vector.add("a"); 507 vector.add(1); 508 vector.add("b"); 509 vector.add("c"); 510 vector.add(1); 511 let capacity = vector.getCapacity(); 512 vector.removeByRange(0, capacity); 513 let arr = []; 514 vector.forEach((item, index) => { 515 arr.push(item); 516 }); 517 expect(arr.length).assertEqual(0); 518 }); 519 520 /** 521 * @tc.name: testRemoveByRange032 522 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 523 * elements at the end position. For example: vector.removeByRange(-1, capacity). 524 */ 525 it("testRemoveByRange032", 0, function () { 526 let vector = new Vector(); 527 vector.add("四"); 528 vector.add("三"); 529 vector.add(1); 530 vector.add("a"); 531 vector.add(1); 532 vector.add("b"); 533 vector.add("c"); 534 vector.add(1); 535 let capacity = vector.getCapacity(); 536 try { 537 vector.removeByRange(-1, capacity); 538 } catch (err) { 539 expect(err.name).assertEqual("RangeError"); 540 expect(err.message).assertEqual("the fromIndex or the toIndex is out-of-bounds"); 541 } 542 }); 543 544 /** 545 * @tc.name: testRemoveByRange033 546 * @tc.desc: Deletes elements from a specified range, including elements at the start position and 547 * elements at the end position. For example: vector.removeByRange(0, capacity + 1). 548 */ 549 it("testRemoveByRange033", 0, function () { 550 let vector = new Vector(); 551 vector.add("四"); 552 vector.add("三"); 553 vector.add(1); 554 vector.add("a"); 555 vector.add(1); 556 vector.add("b"); 557 vector.add("c"); 558 vector.add(1); 559 let capacity = vector.getCapacity(); 560 vector.removeByRange(0, capacity + 1); 561 let length = vector.length; 562 expect(length).assertEqual(0); 563 }); 564 565 /** 566 * @tc.name: testSetLength034 567 * @tc.desc: Get the number of elements contained in the Vector instance. For example: vector.length. 568 */ 569 it("testSetLength034", 0, function () { 570 let vector = new Vector(); 571 vector.add("四"); 572 vector.add("三"); 573 vector.add(1); 574 vector.add("a"); 575 vector.add(1); 576 vector.add("b"); 577 vector.add("c"); 578 vector.add(1); 579 vector.setLength(5); 580 let res1 = vector.length; 581 expect(res1).assertEqual(5); 582 }); 583 584 /** 585 * @tc.name: testReplaceAllElements035 586 * @tc.desc: Perform some operation on the elements in the Vector instance and return the Vector instance 587 * after the operation. For example: vector.replaceAllElements((item, index) => {return (item = 2 * item);}). 588 */ 589 it("testReplaceAllElements035", 0, function () { 590 let vector = new Vector(); 591 vector.add(4); 592 vector.add(3); 593 vector.add(1); 594 vector.add(2); 595 vector.add(14); 596 vector.replaceAllElements((item, index) => { 597 return (item = 2 * item); 598 }); 599 let arr = []; 600 vector.forEach((item, index) => { 601 arr.push(item); 602 }); 603 let a = [8, 6, 2, 4, 28]; 604 for (let i = 0; i < a.length; i++) { 605 expect(arr[i]).assertEqual(a[i]); 606 } 607 }); 608 609 /** 610 * @tc.name: testForEach036 611 * @tc.desc: Traversing elements in an Vector instance. 612 * For example: vector.forEach((item, index) => {arr.push(item);}). 613 */ 614 it("testForEach036", 0, function () { 615 let vector = new Vector(); 616 vector.add(4); 617 vector.add(3); 618 vector.add(1); 619 vector.add(2); 620 vector.add(14); 621 let arr = []; 622 vector.forEach((item, index) => { 623 arr.push(item); 624 }); 625 let a = [4, 3, 1, 2, 14]; 626 for (let i = 0; i < a.length; i++) { 627 expect(arr[i]).assertEqual(a[i]); 628 } 629 }); 630 631 /** 632 * @tc.name: testForEach037 633 * @tc.desc: Traversing elements in an Vector instance. 634 * For example: vector.forEach((item, index) => {arr.push(item);}). 635 */ 636 it("testForEach037", 0, function () { 637 let vector = new Vector(); 638 let arr = []; 639 vector.forEach((item, index) => { 640 arr.push(item); 641 }); 642 let a = [4, 3, 1, 2, 14]; 643 expect(arr.length).assertEqual(0); 644 }); 645 646 /** 647 * @tc.name: testSubVector038 648 * @tc.desc: Intercepts an element within the specified range, including the element with the 649 * starting index but not the element with the ending index. For example: vector.subVector(2, 4). 650 */ 651 it("testSubVector038", 0, function () { 652 let vector = new Vector(); 653 vector.add(4); 654 vector.add(3); 655 vector.add(1); 656 vector.add(2); 657 vector.add(14); 658 let res = vector.subVector(2, 4); 659 let arr = []; 660 res.forEach((item, index) => { 661 arr.push(item); 662 }); 663 let a = [1, 2]; 664 for (let i = 0; i < a.length; i++) { 665 expect(arr[i]).assertEqual(a[i]); 666 } 667 }); 668 669 /** 670 * @tc.name: testSubVector039 671 * @tc.desc: Intercepts an element within the specified range, including the element with the 672 * starting index but not the element with the ending index. For example: vector.subVector(4, 2). 673 */ 674 it("testSubVector039", 0, function () { 675 let vector = new Vector(); 676 vector.add(4); 677 vector.add(3); 678 vector.add(1); 679 vector.add(2); 680 vector.add(14); 681 try { 682 let res = vector.subVector(4, 2); 683 } catch (err) { 684 expect(err.name).assertEqual("RangeError"); 685 expect(err.message).assertEqual("the fromIndex cannot be less than or equal to toIndex"); 686 } 687 }); 688 689 /** 690 * @tc.name: testSubVector040 691 * @tc.desc: Intercepts an element within the specified range, including the element with the 692 * starting index but not the element with the ending index. For example: vector.subVector(length + 1, length + 3). 693 */ 694 it("testSubVector040", 0, function () { 695 let vector = new Vector(); 696 vector.add(4); 697 vector.add(3); 698 vector.add(1); 699 vector.add(2); 700 vector.add(14); 701 let length = vector.length; 702 try { 703 vector.subVector(length + 1, length + 3); 704 } catch (err) { 705 expect(err.name).assertEqual("RangeError"); 706 expect(err.message).assertEqual("the fromIndex or the toIndex is out-of-bounds"); 707 } 708 }); 709 710 /** 711 * @tc.name: testSubVector041 712 * @tc.desc: Intercepts an element within the specified range, including the element with the 713 * starting index but not the element with the ending index. For example: vector.vector.subVector(1, length + 1). 714 */ 715 it("testSubVector041", 0, function () { 716 let vector = new Vector(); 717 vector.add(4); 718 vector.add(3); 719 vector.add(1); 720 vector.add(2); 721 vector.add(14); 722 let length = vector.length; 723 try { 724 let res = vector.subVector(1, length + 1); 725 } catch (err) { 726 expect(err.name).assertEqual("RangeError"); 727 expect(err.message).assertEqual("the fromIndex or the toIndex is out-of-bounds"); 728 } 729 }); 730 731 /** 732 * @tc.name: testClear042 733 * @tc.desc: Clear all elements in the Vector instance. For example: vector.clear(). 734 */ 735 it("testClear042", 0, function () { 736 let vector = new Vector(); 737 vector.add(4); 738 vector.add(3); 739 vector.add(1); 740 vector.add(2); 741 vector.add(14); 742 vector.clear(); 743 let res = vector.length; 744 expect(res).assertEqual(0); 745 }); 746 747 /** 748 * @tc.name: testConvertToArray043 749 * @tc.desc: Convert an Vector instance to an array. For example: vector.convertToArray(). 750 */ 751 it("testConvertToArray043", 0, function () { 752 let vector = new Vector(); 753 vector.add(4); 754 vector.add(3); 755 vector.add(1); 756 vector.add(2); 757 vector.add(14); 758 let arr = vector.convertToArray(); 759 let a = [4, 3, 1, 2, 14]; 760 for (let i = 0; i < a.length; i++) { 761 expect(arr[i]).assertEqual(a[i]); 762 } 763 }); 764 765 /** 766 * @tc.name: testCopyToArray044 767 * @tc.desc: Appends the number of elements of corresponding length to a specified array. 768 * For example: vector.copyToArray(arr1). 769 */ 770 it("testCopyToArray044", 0, function () { 771 let vector = new Vector(); 772 vector.add(4); 773 vector.add(3); 774 vector.add(1); 775 vector.add(2); 776 vector.add(14); 777 let arr1 = ["a", "b", "c"]; 778 vector.copyToArray(arr1); 779 let a = [4, 3, 1, 2, 14]; 780 for (let i = 0; i < a.length; i++) { 781 expect(arr1[i]).assertEqual(a[i]); 782 } 783 }); 784 785 /** 786 * @tc.name: testToString045 787 * @tc.desc: Use "," to splice the elements in the vector instance into a string. For example: vector.toString(). 788 */ 789 it("testToString045", 0, function () { 790 let vector = new Vector(); 791 vector.add(4); 792 vector.add(3); 793 vector.add(1); 794 vector.add(2); 795 vector.add(14); 796 let res = vector.toString(); 797 expect(res).assertEqual("4,3,1,2,14"); 798 }); 799 800 /** 801 * @tc.name: testClone046 802 * @tc.desc: Clone an ArrayList instance. For example: vector.clone(). 803 */ 804 it("testClone046", 0, function () { 805 let vector = new Vector(); 806 vector.add(4); 807 vector.add(3); 808 vector.add(1); 809 vector.add(2); 810 vector.add(14); 811 let res = vector.clone(); 812 let arr = []; 813 res.forEach((item, index) => { 814 arr.push(item); 815 }); 816 let a = [4, 3, 1, 2, 14]; 817 for (let i = 0; i < a.length; i++) { 818 expect(arr[i]).assertEqual(a[i]); 819 } 820 }); 821 822 /** 823 * @tc.name: testGetCapacity047 824 * @tc.desc: Get the capacity of Vector instance. For example: vector.getCapacity(). 825 */ 826 it("testGetCapacity047", 0, function () { 827 let vector = new Vector(); 828 vector.add(4); 829 vector.add(3); 830 vector.add(1); 831 vector.add(2); 832 vector.add(14); 833 let res = vector.getCapacity(); 834 expect(res).assertEqual(10); 835 }); 836 837 /** 838 * @tc.name: testGetCapacity048 839 * @tc.desc: Get the capacity of Vector instance. For example: vector.getCapacity(). 840 */ 841 it("testGetCapacity048", 0, function () { 842 let vector = new Vector(); 843 vector.add(4); 844 vector.add(3); 845 vector.add(1); 846 vector.add(2); 847 vector.add(14); 848 vector.add("a"); 849 vector.add("b"); 850 vector.add("c"); 851 vector.add("d"); 852 vector.add("v"); 853 let a = [1, 2, 3, 4]; 854 vector.add(a); 855 let res = vector.getCapacity(); 856 expect(res).assertEqual(20); 857 }); 858 859 /** 860 * @tc.name: testIncreaseCapacityTo049 861 * @tc.desc: Expand the Vector instance capacity to the specified value. For example: vector.increaseCapacityTo(30). 862 */ 863 it("testIncreaseCapacityTo049", 0, function () { 864 let vector = new Vector(); 865 vector.add(4); 866 vector.add(3); 867 vector.add(1); 868 vector.add(2); 869 vector.add(14); 870 vector.increaseCapacityTo(30); 871 let res = vector.getCapacity(); 872 expect(res).assertEqual(30); 873 }); 874 875 /** 876 * @tc.name: testTrimToCurrentLength050 877 * @tc.desc: Limit the Vector instance capacity to the length of the Vector instance. 878 * For example: vector.trimToCurrentLength(). 879 */ 880 it("testTrimToCurrentLength050", 0, function () { 881 let vector = new Vector(); 882 vector.add(4); 883 vector.add(3); 884 vector.add(1); 885 vector.add(2); 886 vector.add(14); 887 vector.trimToCurrentLength(); 888 let res = vector.getCapacity(); 889 expect(res).assertEqual(5); 890 }); 891 892 /** 893 * @tc.name: testSetLength051 894 * @tc.desc: Sets the length of the vector instance to the specified value. For example: vector.setLength(7). 895 */ 896 it("testSetLength051", 0, function () { 897 let vector = new Vector(); 898 vector.add(4); 899 vector.add(3); 900 vector.add(1); 901 vector.add(2); 902 vector.add(14); 903 vector.setLength(7); 904 let res1 = vector.length; 905 expect(res1).assertEqual(7); 906 }); 907 908 /** 909 * @tc.name: testIterator052 910 * @tc.desc: Iterate over all elements in the Vector instance. 911 * For example: for (let item of vector) {arr.push(item);}. 912 */ 913 it("testIterator052", 0, function () { 914 let vector = new Vector(); 915 vector.add(8); 916 vector.add("一"); 917 vector.add("二"); 918 vector.add(5); 919 let c = [1, 2, 3, 4]; 920 vector.add(c); 921 vector.add(6); 922 vector.add("三"); 923 vector.add("四"); 924 let arr = []; 925 for (let item of vector) { 926 arr.push(item); 927 } 928 let a = [8, "一", "二", 5, c, 6, "三", "四"]; 929 for (let i = 0; i < a.length; i++) { 930 expect(arr[i]).assertEqual(a[i]); 931 } 932 }); 933 934 /** 935 * @tc.name: testIteratorAndRemove053 936 * @tc.desc: Iterate over all elements in the Vector instance. 937 */ 938 it("testIteratorAndRemove053", 0, function () { 939 let vector = new Vector(); 940 vector.add(8); 941 vector.add("一"); 942 vector.add("二"); 943 vector.add(5); 944 let c = [1, 2, 3, 4]; 945 vector.add(c); 946 vector.add(6); 947 vector.add(8); 948 vector.add("三"); 949 vector.add("四"); 950 let arr = []; 951 for (let item of vector) { 952 if (item == 8) { 953 vector.remove(8); 954 } 955 } 956 for (let item of vector) { 957 arr.push(item); 958 } 959 let a = ["一", "二", 5, c, 6, "三", "四"]; 960 for (let i = 0; i < a.length; i++) { 961 expect(arr[i]).assertEqual(a[i]); 962 } 963 }); 964 965 /** 966 * @tc.name: testIteratorAndRemove054 967 * @tc.desc: Iterate over all elements in the Vector instance. 968 */ 969 it("testIteratorAndRemove054", 0, function () { 970 let vector = new Vector(); 971 vector.add(8); 972 vector.add("一"); 973 vector.add("二"); 974 vector.add(5); 975 let c = [1, 2, 3, 4]; 976 vector.add(c); 977 vector.add(6); 978 vector.add("三"); 979 vector.add("四"); 980 let arr = []; 981 for (let item of vector) { 982 if (item == 123) { 983 vector.remove(123); 984 } else { 985 arr.push(item); 986 } 987 } 988 let a = [8, "一", "二", 5, c, 6, "三", "四"]; 989 for (let i = 0; i < a.length; i++) { 990 expect(arr[i]).assertEqual(a[i]); 991 } 992 }); 993 994 /** 995 * @tc.name: testIterator055 996 * @tc.desc: Iterate over all elements in the Vector instance. 997 * For example: for (let item of vector) {arr.push(item);}. 998 */ 999 it("testIterator055", 0, function () { 1000 let vector = new Vector(); 1001 let arr = []; 1002 for (let item of vector) { 1003 arr.push(item); 1004 } 1005 expect(arr.length).assertEqual(0); 1006 }); 1007 1008 /** 1009 * @tc.name: testSort056 1010 * @tc.desc: Arrange the elements in the Vector instance in descending order. 1011 * For example: vector.sort((a, b) => a - b). 1012 */ 1013 it("testSort056", 0, function () { 1014 let vector = new Vector(); 1015 vector.add(4); 1016 vector.add(3); 1017 vector.add(1); 1018 vector.add(2); 1019 vector.add(14); 1020 vector.sort((a, b) => a - b); 1021 let arr = []; 1022 vector.forEach((item, index) => { 1023 arr.push(item); 1024 }); 1025 let a = [1, 2, 3, 4, 14]; 1026 for (let i = 0; i < a.length; i++) { 1027 expect(arr[i]).assertEqual(a[i]); 1028 } 1029 }); 1030 1031 /** 1032 * @tc.name: testIsEmpty057 1033 * @tc.desc: Determine whether the Vector instance is empty. For example: vector.isEmpty(). 1034 */ 1035 it("testIsEmpty057", 0, function () { 1036 let vector = new Vector(); 1037 vector.add("四"); 1038 let res = vector.isEmpty(); 1039 expect(res).assertEqual(false); 1040 }); 1041 1042 /** 1043 * @tc.name: testisEmpty058 1044 * @tc.desc: Determine whether the Vector instance is empty. For example: vector.isEmpty(). 1045 */ 1046 it("testisEmpty058", 0, function () { 1047 let vector = new Vector(); 1048 let res = vector.isEmpty(); 1049 expect(res).assertEqual(true); 1050 }); 1051 1052 /** 1053 * @tc.name: testAdd060 1054 * @tc.desc: Add a element to the end of the Vector instance. 1055 * For example: for (let i = 0; i < 100; i++) {let res3 = vector.add(i);}. 1056 */ 1057 it("testAdd060", 0, function () { 1058 let vector = new Vector(); 1059 for (let i = 0; i < 100; i++) { 1060 let res3 = vector.add(i); 1061 } 1062 let res = vector.getLastElement(); 1063 let res1 = vector.length; 1064 expect(res).assertEqual(99); 1065 expect(res1).assertEqual(100); 1066 }); 1067 1068 /** 1069 * @tc.name: testAdd061 1070 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add("%"). 1071 */ 1072 it("testAdd061", 0, function () { 1073 let vector = new Vector(); 1074 vector.add("%"); 1075 let res = vector.getFirstElement(); 1076 expect(res).assertEqual("%"); 1077 }); 1078 1079 /** 1080 * @tc.name: testAdd062 1081 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add(1.89). 1082 */ 1083 it("testAdd062", 0, function () { 1084 let vector = new Vector(); 1085 vector.add(1.89); 1086 let res = vector.getFirstElement(); 1087 expect(res).assertEqual(1.89); 1088 }); 1089 1090 /** 1091 * @tc.name: testAdd063 1092 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add(""). 1093 */ 1094 it("testAdd063", 0, function () { 1095 let vector = new Vector(); 1096 vector.add(""); 1097 let res = vector.getFirstElement(); 1098 expect(res).assertEqual(""); 1099 }); 1100 1101 /** 1102 * @tc.name: testAdd064 1103 * @tc.desc: Add a element to the end of the Vector instance. For example: vector.add(true). 1104 */ 1105 it("testAdd064", 0, function () { 1106 let vector = new Vector(); 1107 vector.add(true); 1108 let res = vector.getFirstElement(); 1109 expect(res).assertEqual(true); 1110 }); 1111 1112 /** 1113 * @tc.name: testGetIndexOf065 1114 * @tc.desc: In the Vector instance, find the index of a specified element from front to back, 1115 * and return the index found for the first time. If not found, return -1. For example: vector.getIndexOf(23). 1116 */ 1117 it("testGetIndexOf065", 0, function () { 1118 let vector = new Vector(); 1119 vector.add(1); 1120 vector.add(2); 1121 vector.add(3); 1122 let res = vector.getIndexOf(23); 1123 expect(res).assertEqual(-1); 1124 }); 1125 1126 /** 1127 * @tc.name: testSet066 1128 * @tc.desc: Modify the element corresponding to the specified index. For example: vector.set(12, "二"). 1129 */ 1130 it("testSet066", 0, function () { 1131 let vector = new Vector(); 1132 vector.add("四"); 1133 vector.add("三"); 1134 try { 1135 vector.set(12, "二"); 1136 } catch (err) { 1137 expect(err.name).assertEqual("RangeError"); 1138 expect(err.message).assertEqual("the index is out-of-bounds"); 1139 } 1140 }); 1141 1142 /** 1143 * @tc.name: testRemoveByIndex067 1144 * @tc.desc: In the Vector instance, delete the element based on its index. For example: vector.removeByIndex(12). 1145 */ 1146 it("testRemoveByIndex067", 0, function () { 1147 let vector = new Vector(); 1148 vector.add("四"); 1149 vector.add("三"); 1150 try { 1151 vector.removeByIndex(12); 1152 } catch (err) { 1153 expect(err.name).assertEqual("RangeError"); 1154 expect(err.message).assertEqual("the index is out-of-bounds"); 1155 } 1156 }); 1157 1158 /** 1159 * @tc.name: testGetLastIndexOf068 1160 * @tc.desc: In the Vector instance, find the index of a specified element from back to front, 1161 * and return the index found for the first time. If not found, return -1. For example: vector.getLastIndexOf("二"). 1162 */ 1163 it("testGetLastIndexOf068", 0, function () { 1164 let vector = new Vector(); 1165 vector.add("四"); 1166 vector.add("三"); 1167 let res = vector.getLastIndexOf("二"); 1168 expect(res).assertEqual(-1); 1169 }); 1170 1171 /** 1172 * @tc.name: testIterator069 1173 * @tc.desc: Iterate over all elements in the Vector instance. For example: Vector[Symbol.iterator](). 1174 */ 1175 it("testIterator069", 0, function () { 1176 let vector = new Vector(); 1177 vector.add(8); 1178 vector.add("一"); 1179 vector.add("二"); 1180 vector.add(5); 1181 let c = [1, 2, 3, 4]; 1182 vector.add(c); 1183 vector.add(6); 1184 vector.add("三"); 1185 vector.add("四"); 1186 let arr = []; 1187 let itr = vector[Symbol.iterator](); 1188 let tmp = undefined; 1189 do { 1190 tmp = itr.next().value; 1191 arr.push(tmp); 1192 } while (tmp != undefined); 1193 let a = [8, "一", "二", 5, c, 6, "三", "四"]; 1194 for (let i = 0; i < a.length; i++) { 1195 expect(arr[i]).assertEqual(a[i]); 1196 } 1197 }); 1198}); 1199} 1200