1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package org.apache.harmony.tests.java.util; 19 20import tests.support.Support_ListTest; 21import java.util.Arrays; 22import java.util.Collection; 23import java.util.Enumeration; 24import java.util.HashSet; 25import java.util.LinkedList; 26import java.util.List; 27import java.util.NoSuchElementException; 28import java.util.Vector; 29 30public class VectorTest extends junit.framework.TestCase { 31 32 private Vector tVector = new Vector(); 33 34 Object[] objArray; 35 36 private String vString = "[Test 0, Test 1, Test 2, Test 3, Test 4, Test 5, Test 6, Test 7, Test 8, Test 9, Test 10, Test 11, Test 12, Test 13, Test 14, Test 15, Test 16, Test 17, Test 18, Test 19, Test 20, Test 21, Test 22, Test 23, Test 24, Test 25, Test 26, Test 27, Test 28, Test 29, Test 30, Test 31, Test 32, Test 33, Test 34, Test 35, Test 36, Test 37, Test 38, Test 39, Test 40, Test 41, Test 42, Test 43, Test 44, Test 45, Test 46, Test 47, Test 48, Test 49, Test 50, Test 51, Test 52, Test 53, Test 54, Test 55, Test 56, Test 57, Test 58, Test 59, Test 60, Test 61, Test 62, Test 63, Test 64, Test 65, Test 66, Test 67, Test 68, Test 69, Test 70, Test 71, Test 72, Test 73, Test 74, Test 75, Test 76, Test 77, Test 78, Test 79, Test 80, Test 81, Test 82, Test 83, Test 84, Test 85, Test 86, Test 87, Test 88, Test 89, Test 90, Test 91, Test 92, Test 93, Test 94, Test 95, Test 96, Test 97, Test 98, Test 99]"; 37 38 /** 39 * java.util.Vector#Vector() 40 */ 41 public void test_Constructor() { 42 // Test for method java.util.Vector() 43 44 Vector tv = new Vector(100); 45 for (int i = 0; i < 100; i++) 46 tv.addElement(new Integer(i)); 47 new Support_ListTest("", tv).runTest(); 48 49 tv = new Vector(200); 50 for (int i = -50; i < 150; i++) 51 tv.addElement(new Integer(i)); 52 new Support_ListTest("", tv.subList(50, 150)).runTest(); 53 54 Vector v = new Vector(); 55 assertEquals("Vector creation failed", 0, v.size()); 56 assertEquals("Wrong capacity", 10, v.capacity()); 57 } 58 59 /** 60 * java.util.Vector#Vector(int) 61 */ 62 public void test_ConstructorI() { 63 // Test for method java.util.Vector(int) 64 65 Vector v = new Vector(100); 66 assertEquals("Vector creation failed", 0, v.size()); 67 assertEquals("Wrong capacity", 100, v.capacity()); 68 69 try { 70 new Vector(-1); 71 fail("IllegalArgumentException expected"); 72 } catch (IllegalArgumentException e) { 73 //expected 74 } 75 } 76 77 /** 78 * java.util.Vector#Vector(int, int) 79 */ 80 public void test_ConstructorII() { 81 // Test for method java.util.Vector(int, int) 82 83 Vector v = new Vector(2, 10); 84 v.addElement(new Object()); 85 v.addElement(new Object()); 86 v.addElement(new Object()); 87 88 assertEquals("Failed to inc capacity by proper amount", 89 12, v.capacity()); 90 91 Vector grow = new Vector(3, -1); 92 grow.addElement("one"); 93 grow.addElement("two"); 94 grow.addElement("three"); 95 grow.addElement("four"); 96 assertEquals("Wrong size", 4, grow.size()); 97 assertEquals("Wrong capacity", 6, grow.capacity()); 98 99 Vector emptyVector = new Vector(0, 0); 100 emptyVector.addElement("one"); 101 assertEquals("Wrong size", 1, emptyVector.size()); 102 emptyVector.addElement("two"); 103 emptyVector.addElement("three"); 104 assertEquals("Wrong size", 3, emptyVector.size()); 105 106 try { 107 Vector negativeVector = new Vector(-1, 0); 108 fail("Should throw IllegalArgumentException"); 109 } catch (IllegalArgumentException e) { 110 // Excepted 111 } 112 } 113 114 /** 115 * java.util.Vector#Vector(java.util.Collection) 116 */ 117 public void test_ConstructorLjava_util_Collection() { 118 // Test for method java.util.Vector(java.util.Collection) 119 Collection l = new LinkedList(); 120 for (int i = 0; i < 100; i++) 121 l.add("Test " + i); 122 Vector myVector = new Vector(l); 123 assertTrue("Vector is not correct size", 124 myVector.size() == objArray.length); 125 for (int counter = 0; counter < objArray.length; counter++) 126 assertTrue("Vector does not contain correct elements", myVector 127 .contains(((List) l).get(counter))); 128 129 try { 130 new Vector(null); 131 fail("NullPointerException expected"); 132 } catch (NullPointerException e) { 133 //expected 134 } 135 } 136 137 /** 138 * java.util.Vector#add(int, java.lang.Object) 139 */ 140 public void test_addILjava_lang_Object() { 141 // Test for method void java.util.Vector.add(int, java.lang.Object) 142 Object o = new Object(); 143 Object prev = tVector.get(45); 144 tVector.add(45, o); 145 assertTrue("Failed to add Object", tVector.get(45) == o); 146 assertTrue("Failed to fix-up existing indices", tVector.get(46) == prev); 147 assertEquals("Wrong size after add", 101, tVector.size()); 148 149 prev = tVector.get(50); 150 tVector.add(50, null); 151 assertNull("Failed to add null", tVector.get(50)); 152 assertTrue("Failed to fix-up existing indices after adding null", 153 tVector.get(51) == prev); 154 assertEquals("Wrong size after add", 102, tVector.size()); 155 156 try { 157 tVector.add(-5, null); 158 fail("ArrayIndexOutOfBoundsException expected"); 159 } catch(ArrayIndexOutOfBoundsException e) { 160 //expected 161 } 162 163 try { 164 tVector.add(tVector.size() + 1, null); 165 fail("ArrayIndexOutOfBoundsException expected"); 166 } catch(ArrayIndexOutOfBoundsException e) { 167 //expected 168 } 169 } 170 171 /** 172 * java.util.Vector#add(java.lang.Object) 173 */ 174 public void test_addLjava_lang_Object() { 175 // Test for method boolean java.util.Vector.add(java.lang.Object) 176 Object o = new Object(); 177 tVector.add(o); 178 assertTrue("Failed to add Object", tVector.lastElement() == o); 179 assertEquals("Wrong size after add", 101, tVector.size()); 180 181 tVector.add(null); 182 assertNull("Failed to add null", tVector.lastElement()); 183 assertEquals("Wrong size after add", 102, tVector.size()); 184 } 185 186 /** 187 * java.util.Vector#addAll(int, java.util.Collection) 188 */ 189 public void test_addAllILjava_util_Collection() { 190 // Test for method boolean java.util.Vector.addAll(int, 191 // java.util.Collection) 192 Collection l = new LinkedList(); 193 for (int i = 0; i < 100; i++) 194 l.add("Test " + i); 195 Vector v = new Vector(); 196 tVector.addAll(50, l); 197 for (int i = 50; i < 100; i++) 198 assertTrue("Failed to add all elements", 199 tVector.get(i) == ((List) l).get(i - 50)); 200 v = new Vector(); 201 v.add("one"); 202 int r = 0; 203 try { 204 v.addAll(3, Arrays.asList(new String[] { "two", "three" })); 205 } catch (ArrayIndexOutOfBoundsException e) { 206 r = 1; 207 } catch (IndexOutOfBoundsException e) { 208 r = 2; 209 } 210 assertTrue("Invalid add: " + r, r == 1); 211 l = new LinkedList(); 212 l.add(null); 213 l.add("gah"); 214 l.add(null); 215 tVector.addAll(50, l); 216 assertNull("Wrong element at position 50--wanted null", 217 tVector.get(50)); 218 assertEquals("Wrong element at position 51--wanted 'gah'", "gah", tVector 219 .get(51)); 220 assertNull("Wrong element at position 52--wanted null", 221 tVector.get(52)); 222 223 try { 224 tVector.addAll(-5, Arrays.asList(new String[] { "two", "three" })); 225 fail("ArrayIndexOutOfBoundsException expected"); 226 } catch(ArrayIndexOutOfBoundsException e) { 227 //expected 228 } 229 230 try { 231 tVector.addAll(tVector.size() + 1, Arrays.asList(new String[] { "two", "three" })); 232 fail("ArrayIndexOutOfBoundsException expected"); 233 } catch(ArrayIndexOutOfBoundsException e) { 234 //expected 235 } 236 237 try { 238 tVector.addAll(tVector.size() / 2, null); 239 fail("NullPointerException expected"); 240 } catch(NullPointerException e) { 241 //expected 242 } 243 } 244 245 /** 246 * java.util.Vector#addAll(java.util.Collection) 247 */ 248 public void test_addAllLjava_util_Collection() { 249 // Test for method boolean java.util.Vector.addAll(java.util.Collection) 250 Vector v = new Vector(); 251 Collection l = new LinkedList(); 252 for (int i = 0; i < 100; i++) 253 l.add("Test " + i); 254 v.addAll(l); 255 assertTrue("Failed to add all elements", tVector.equals(v)); 256 257 v.addAll(l); 258 int vSize = tVector.size(); 259 for (int counter = vSize - 1; counter >= 0; counter--) 260 assertTrue("Failed to add elements correctly", v.get(counter) == v 261 .get(counter + vSize)); 262 263 l = new LinkedList(); 264 l.add(null); 265 l.add("gah"); 266 l.add(null); 267 tVector.addAll(l); 268 assertNull("Wrong element at 3rd last position--wanted null", tVector 269 .get(vSize)); 270 assertEquals("Wrong element at 2nd last position--wanted 'gah'", "gah", tVector 271 .get(vSize + 1)); 272 assertNull("Wrong element at last position--wanted null", tVector 273 .get(vSize + 2)); 274 275 try { 276 tVector.addAll(tVector.size() / 2, null); 277 fail("NullPointerException expected"); 278 } catch(NullPointerException e) { 279 //expected 280 } 281 } 282 283 /** 284 * java.util.Vector#addElement(java.lang.Object) 285 */ 286 public void test_addElementLjava_lang_Object() { 287 // Test for method void java.util.Vector.addElement(java.lang.Object) 288 Vector v = vectorClone(tVector); 289 v.addElement("Added Element"); 290 assertTrue("Failed to add element", v.contains("Added Element")); 291 assertEquals("Added Element to wrong slot", "Added Element", ((String) v.elementAt(100)) 292 ); 293 v.addElement(null); 294 assertTrue("Failed to add null", v.contains(null)); 295 assertNull("Added null to wrong slot", v.elementAt(101)); 296 } 297 298 /** 299 * java.util.Vector#addElement(java.lang.Object) 300 */ 301 public void test_addElementLjava_lang_Object_subtest0() { 302 // Test for method void java.util.Vector.addElement(java.lang.Object) 303 Vector v = vectorClone(tVector); 304 v.addElement("Added Element"); 305 assertTrue("Failed to add element", v.contains("Added Element")); 306 assertEquals("Added Element to wrong slot", "Added Element", ((String) v.elementAt(100)) 307 ); 308 v.addElement(null); 309 assertTrue("Failed to add null", v.contains(null)); 310 assertNull("Added null to wrong slot", v.elementAt(101)); 311 } 312 313 /** 314 * java.util.Vector#capacity() 315 */ 316 public void test_capacity() { 317 // Test for method int java.util.Vector.capacity() 318 319 Vector v = new Vector(9); 320 assertEquals("Incorrect capacity returned", 9, v.capacity()); 321 } 322 323 /** 324 * java.util.Vector#clear() 325 */ 326 public void test_clear() { 327 // Test for method void java.util.Vector.clear() 328 Vector orgVector = vectorClone(tVector); 329 tVector.clear(); 330 assertEquals("a) Cleared Vector has non-zero size", 0, tVector.size()); 331 Enumeration e = orgVector.elements(); 332 while (e.hasMoreElements()) 333 assertTrue("a) Cleared vector contained elements", !tVector 334 .contains(e.nextElement())); 335 336 tVector.add(null); 337 tVector.clear(); 338 assertEquals("b) Cleared Vector has non-zero size", 0, tVector.size()); 339 e = orgVector.elements(); 340 while (e.hasMoreElements()) 341 assertTrue("b) Cleared vector contained elements", !tVector 342 .contains(e.nextElement())); 343 } 344 345 /** 346 * java.util.Vector#clone() 347 */ 348 public void test_clone() { 349 // Test for method java.lang.Object java.util.Vector.clone() 350 tVector.add(25, null); 351 tVector.add(75, null); 352 Vector v = (Vector) tVector.clone(); 353 Enumeration orgNum = tVector.elements(); 354 Enumeration cnum = v.elements(); 355 356 while (orgNum.hasMoreElements()) { 357 assertTrue("Not enough elements copied", cnum.hasMoreElements()); 358 assertTrue("Vector cloned improperly, elements do not match", 359 orgNum.nextElement() == cnum.nextElement()); 360 } 361 assertTrue("Not enough elements copied", !cnum.hasMoreElements()); 362 363 } 364 365 /** 366 * java.util.Vector#contains(java.lang.Object) 367 */ 368 public void test_containsLjava_lang_Object() { 369 // Test for method boolean java.util.Vector.contains(java.lang.Object) 370 assertTrue("Did not find element", tVector.contains("Test 42")); 371 assertTrue("Found bogus element", !tVector.contains("Hello")); 372 assertTrue( 373 "Returned true looking for null in vector without null element", 374 !tVector.contains(null)); 375 tVector.insertElementAt(null, 20); 376 assertTrue( 377 "Returned false looking for null in vector with null element", 378 tVector.contains(null)); 379 } 380 381 /** 382 * java.util.Vector#containsAll(java.util.Collection) 383 */ 384 public void test_containsAllLjava_util_Collection() { 385 // Test for method boolean 386 // java.util.Vector.containsAll(java.util.Collection) 387 Collection s = new HashSet(); 388 for (int i = 0; i < 100; i++) 389 s.add("Test " + i); 390 391 assertTrue("Returned false for valid collection", tVector 392 .containsAll(s)); 393 s.add(null); 394 assertTrue("Returned true for invlaid collection containing null", 395 !tVector.containsAll(s)); 396 tVector.add(25, null); 397 assertTrue("Returned false for valid collection containing null", 398 tVector.containsAll(s)); 399 s = new HashSet(); 400 s.add(new Object()); 401 assertTrue("Returned true for invalid collection", !tVector 402 .containsAll(s)); 403 404 try { 405 tVector.containsAll(null); 406 fail("NullPointerException expected"); 407 } catch (NullPointerException e) { 408 //expected 409 } 410 } 411 412 /** 413 * java.util.Vector#copyInto(java.lang.Object[]) 414 */ 415 public void test_copyInto$Ljava_lang_Object() { 416 // Test for method void java.util.Vector.copyInto(java.lang.Object []) 417 418 Object[] a = new Object[100]; 419 tVector.setElementAt(null, 20); 420 tVector.copyInto(a); 421 422 for (int i = 0; i < 100; i++) 423 assertTrue("copyInto failed", a[i] == tVector.elementAt(i)); 424 425 try { 426 tVector.copyInto(null); 427 fail("NullPointerException expected"); 428 } catch (NullPointerException e) { 429 //expected 430 } 431 } 432 433 /** 434 * java.util.Vector#elementAt(int) 435 */ 436 public void test_elementAtI() { 437 // Test for method java.lang.Object java.util.Vector.elementAt(int) 438 assertEquals("Incorrect element returned", "Test 18", ((String) tVector 439 .elementAt(18))); 440 tVector.setElementAt(null, 20); 441 assertNull("Incorrect element returned--wanted null", tVector 442 .elementAt(20)); 443 444 try { 445 tVector.elementAt(-5); 446 fail("ArrayIndexOutOfBoundsException expected"); 447 } catch(ArrayIndexOutOfBoundsException e) { 448 //expected 449 } 450 451 try { 452 tVector.elementAt(tVector.size() + 1); 453 fail("ArrayIndexOutOfBoundsException expected"); 454 } catch(ArrayIndexOutOfBoundsException e) { 455 //expected 456 } 457 } 458 459 /** 460 * java.util.Vector#elements() 461 */ 462 public void test_elements() { 463 // Test for method java.util.Enumeration java.util.Vector.elements() 464 tVector.insertElementAt(null, 20); 465 Enumeration e = tVector.elements(); 466 int i = 0; 467 while (e.hasMoreElements()) { 468 assertTrue("Enumeration returned incorrect element at pos: " + i, e 469 .nextElement() == tVector.elementAt(i)); 470 i++; 471 } 472 assertTrue("Invalid enumeration", i == tVector.size()); 473 } 474 475 /** 476 * java.util.Vector#elements() 477 */ 478 public void test_elements_subtest0() { 479 final int iterations = 10000; 480 final Vector v = new Vector(); 481 Thread t1 = new Thread() { 482 public void run() { 483 for (int i = 0; i < iterations; i++) { 484 synchronized (v) { 485 v.addElement(String.valueOf(i)); 486 v.removeElementAt(0); 487 } 488 } 489 } 490 }; 491 t1.start(); 492 for (int i = 0; i < iterations; i++) { 493 Enumeration en = v.elements(); 494 try { 495 while (true) { 496 Object result = en.nextElement(); 497 if (result == null) { 498 fail("Null result: " + i); 499 } 500 } 501 } catch (NoSuchElementException e) { 502 } 503 } 504 } 505 506 /** 507 * java.util.Vector#ensureCapacity(int) 508 */ 509 public void test_ensureCapacityI() { 510 // Test for method void java.util.Vector.ensureCapacity(int) 511 512 Vector v = new Vector(9); 513 v.ensureCapacity(20); 514 assertEquals("ensureCapacity failed to set correct capacity", 20, v 515 .capacity()); 516 v = new Vector(100); 517 assertEquals("ensureCapacity reduced capacity", 100, v.capacity()); 518 519 v.ensureCapacity(150); 520 assertEquals( 521 "ensuieCapacity failed to set to be twice the old capacity", 522 200, v.capacity()); 523 524 v = new Vector(9, -1); 525 v.ensureCapacity(20); 526 assertEquals("ensureCapacity failed to set to be minCapacity", 20, v 527 .capacity()); 528 v.ensureCapacity(15); 529 assertEquals("ensureCapacity reduced capacity", 20, v.capacity()); 530 v.ensureCapacity(35); 531 assertEquals( 532 "ensuieCapacity failed to set to be twice the old capacity", 533 40, v.capacity()); 534 535 v = new Vector(9, 4); 536 v.ensureCapacity(11); 537 assertEquals("ensureCapacity failed to set correct capacity", 13, v 538 .capacity()); 539 v.ensureCapacity(5); 540 assertEquals("ensureCapacity reduced capacity", 13, v.capacity()); 541 v.ensureCapacity(20); 542 assertEquals( 543 "ensureCapacity failed to set to be twice the old capacity", 544 20, v.capacity()); 545 } 546 547 /** 548 * java.util.Vector#equals(java.lang.Object) 549 */ 550 public void test_equalsLjava_lang_Object() { 551 // Test for method boolean java.util.Vector.equals(java.lang.Object) 552 Vector v = new Vector(); 553 for (int i = 0; i < 100; i++) 554 v.addElement("Test " + i); 555 assertTrue("a) Equal vectors returned false", tVector.equals(v)); 556 v.addElement(null); 557 assertTrue("b) UnEqual vectors returned true", !tVector.equals(v)); 558 tVector.addElement(null); 559 assertTrue("c) Equal vectors returned false", tVector.equals(v)); 560 tVector.removeElementAt(22); 561 assertTrue("d) UnEqual vectors returned true", !tVector.equals(v)); 562 assertTrue("e) Equal vectors returned false", tVector.equals(tVector)); 563 assertFalse("f) UnEqual vectors returned true", tVector 564 .equals(new Object())); 565 assertFalse("g) Unequal vectors returned true", tVector.equals(null)); 566 } 567 568 /** 569 * java.util.Vector#firstElement() 570 */ 571 public void test_firstElement() { 572 // Test for method java.lang.Object java.util.Vector.firstElement() 573 assertEquals("Returned incorrect firstElement", "Test 0", tVector.firstElement() 574 ); 575 tVector.insertElementAt(null, 0); 576 assertNull("Returned incorrect firstElement--wanted null", tVector 577 .firstElement()); 578 579 Vector v = new Vector(10); 580 try { 581 v.firstElement(); 582 fail("Should throw NoSuchElementException"); 583 } catch (NoSuchElementException e) { 584 // Excepted 585 } 586 } 587 588 /** 589 * java.util.Vector#get(int) 590 */ 591 public void test_getI() { 592 // Test for method java.lang.Object java.util.Vector.get(int) 593 assertEquals("Get returned incorrect object", 594 "Test 80", tVector.get(80)); 595 tVector.add(25, null); 596 assertNull("Returned incorrect element--wanted null", 597 tVector.get(25)); 598 599 try { 600 tVector.get(-5); 601 fail("ArrayIndexOutOfBoundsException expected"); 602 } catch(ArrayIndexOutOfBoundsException e) { 603 //expected 604 } 605 606 try { 607 tVector.get(tVector.size() + 1); 608 fail("ArrayIndexOutOfBoundsException expected"); 609 } catch(ArrayIndexOutOfBoundsException e) { 610 //expected 611 } 612 } 613 614 /** 615 * java.util.Vector#hashCode() 616 */ 617 public void test_hashCode() { 618 // Test for method int java.util.Vector.hashCode() 619 int hashCode = 1; // one 620 tVector.insertElementAt(null, 20); 621 for (int i = 0; i < tVector.size(); i++) { 622 Object obj = tVector.elementAt(i); 623 hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); 624 } 625 assertTrue("Incorrect hashCode returned. Wanted: " + hashCode 626 + " got: " + tVector.hashCode(), tVector.hashCode() == hashCode); 627 } 628 629 /** 630 * java.util.Vector#indexOf(java.lang.Object) 631 */ 632 public void test_indexOfLjava_lang_Object() { 633 // Test for method int java.util.Vector.indexOf(java.lang.Object) 634 assertEquals("Incorrect index returned", 10, tVector.indexOf("Test 10")); 635 assertEquals("Index returned for invalid Object", -1, tVector 636 .indexOf("XXXXXXXXXXX")); 637 tVector.setElementAt(null, 20); 638 tVector.setElementAt(null, 40); 639 assertTrue("Incorrect indexOf returned for null: " 640 + tVector.indexOf(null), tVector.indexOf(null) == 20); 641 } 642 643 /** 644 * java.util.Vector#indexOf(java.lang.Object, int) 645 */ 646 public void test_indexOfLjava_lang_ObjectI() { 647 // Test for method int java.util.Vector.indexOf(java.lang.Object, int) 648 assertEquals("Failed to find correct index", tVector.indexOf("Test 98", 649 50), 98); 650 assertTrue("Found index of bogus element", (tVector.indexOf( 651 "Test 1001", 50) == -1)); 652 tVector.setElementAt(null, 20); 653 tVector.setElementAt(null, 40); 654 tVector.setElementAt(null, 60); 655 assertTrue("a) Incorrect indexOf returned for null: " 656 + tVector.indexOf(null, 25), tVector.indexOf(null, 25) == 40); 657 assertTrue("b) Incorrect indexOf returned for null: " 658 + tVector.indexOf(null, 20), tVector.indexOf(null, 20) == 20); 659 try { 660 tVector.indexOf("Test 98", -1); 661 fail("should throw ArrayIndexOutOfBoundsException"); 662 } catch (ArrayIndexOutOfBoundsException e) { 663 664 } 665 assertEquals(-1, tVector.indexOf("Test 98", 1000)); 666 assertEquals(-1, tVector.indexOf("Test 98", Integer.MAX_VALUE)); 667 assertEquals(-1, tVector.indexOf("Test 98", tVector.size())); 668 assertEquals(98, tVector.indexOf("Test 98", 0)); 669 try { 670 tVector.indexOf("Test 98", Integer.MIN_VALUE); 671 fail("should throw ArrayIndexOutOfBoundsException"); 672 } catch (ArrayIndexOutOfBoundsException e) { 673 674 } 675 } 676 677 /** 678 * java.util.Vector#insertElementAt(java.lang.Object, int) 679 */ 680 public void test_insertElementAtLjava_lang_ObjectI() { 681 // Test for method void 682 // java.util.Vector.insertElementAt(java.lang.Object, int) 683 Vector v = vectorClone(tVector); 684 String prevElement = (String) v.elementAt(99); 685 v.insertElementAt("Inserted Element", 99); 686 assertEquals("Element not inserted", "Inserted Element", ((String) v.elementAt(99)) 687 ); 688 assertTrue("Elements shifted incorrectly", ((String) v.elementAt(100)) 689 .equals(prevElement)); 690 v.insertElementAt(null, 20); 691 assertNull("null not inserted", v.elementAt(20)); 692 693 try { 694 tVector.insertElementAt("Inserted Element", -1); 695 fail("Should throw ArrayIndexOutOfBoundsException"); 696 } catch (ArrayIndexOutOfBoundsException e) { 697 // Excepted 698 } 699 700 try { 701 tVector.insertElementAt(null, -1); 702 fail("Should throw ArrayIndexOutOfBoundsException"); 703 } catch (ArrayIndexOutOfBoundsException e) { 704 // Excepted 705 } 706 707 try { 708 tVector.insertElementAt("Inserted Element", tVector.size() + 1); 709 fail("Should throw ArrayIndexOutOfBoundsException"); 710 } catch (ArrayIndexOutOfBoundsException e) { 711 // Excepted 712 } 713 714 try { 715 tVector.insertElementAt(null, tVector.size() + 1); 716 fail("Should throw ArrayIndexOutOfBoundsException"); 717 } catch (ArrayIndexOutOfBoundsException e) { 718 // Excepted 719 } 720 } 721 722 /** 723 * java.util.Vector#isEmpty() 724 */ 725 public void test_isEmpty() { 726 // Test for method boolean java.util.Vector.isEmpty()Vector 727 Vector v = new java.util.Vector(); 728 assertTrue("Empty vector returned false", v.isEmpty()); 729 v.addElement(new Object()); 730 assertTrue("non-Empty vector returned true", !v.isEmpty()); 731 } 732 733 /** 734 * java.util.Vector#isEmpty() 735 */ 736 public void test_isEmpty_subtest0() { 737 final Vector v = new Vector(); 738 v.addElement("initial"); 739 Thread t1 = new Thread() { 740 public void run() { 741 while (!v.isEmpty()) 742 ; 743 v.addElement("final"); 744 } 745 }; 746 t1.start(); 747 for (int i = 0; i < 10000; i++) { 748 synchronized (v) { 749 v.removeElementAt(0); 750 v.addElement(String.valueOf(i)); 751 } 752 int size; 753 if ((size = v.size()) != 1) { 754 String result = "Size is not 1: " + size + " " + v; 755 // terminate the thread 756 v.removeAllElements(); 757 fail(result); 758 } 759 } 760 // terminate the thread 761 v.removeElementAt(0); 762 } 763 764 /** 765 * java.util.Vector#lastElement() 766 */ 767 public void test_lastElement() { 768 // Test for method java.lang.Object java.util.Vector.lastElement() 769 assertEquals("Incorrect last element returned", "Test 99", tVector.lastElement() 770 ); 771 tVector.addElement(null); 772 assertNull("Incorrect last element returned--wanted null", tVector 773 .lastElement()); 774 775 Vector vector = new Vector(); 776 try { 777 vector.lastElement(); 778 fail("Should throw NoSuchElementException"); 779 } catch (NoSuchElementException e) { 780 // Excepted 781 } 782 } 783 784 /** 785 * java.util.Vector#lastIndexOf(java.lang.Object) 786 */ 787 public void test_lastIndexOfLjava_lang_Object() { 788 // Test for method int java.util.Vector.lastIndexOf(java.lang.Object) 789 Vector v = new Vector(9); 790 for (int i = 0; i < 9; i++) 791 v.addElement("Test"); 792 v.addElement("z"); 793 assertEquals("Failed to return correct index", 8, v.lastIndexOf("Test")); 794 tVector.setElementAt(null, 20); 795 tVector.setElementAt(null, 40); 796 assertTrue("Incorrect lastIndexOf returned for null: " 797 + tVector.lastIndexOf(null), tVector.lastIndexOf(null) == 40); 798 } 799 800 /** 801 * java.util.Vector#lastIndexOf(java.lang.Object, int) 802 */ 803 public void test_lastIndexOfLjava_lang_ObjectI() { 804 // Test for method int java.util.Vector.lastIndexOf(java.lang.Object, 805 // int) 806 assertEquals("Failed to find object", 807 0, tVector.lastIndexOf("Test 0", 0)); 808 assertTrue("Found Object outside of index", (tVector.lastIndexOf( 809 "Test 0", 10) > -1)); 810 tVector.setElementAt(null, 20); 811 tVector.setElementAt(null, 40); 812 tVector.setElementAt(null, 60); 813 assertTrue("Incorrect lastIndexOf returned for null: " 814 + tVector.lastIndexOf(null, 15), 815 tVector.lastIndexOf(null, 15) == -1); 816 assertTrue("Incorrect lastIndexOf returned for null: " 817 + tVector.lastIndexOf(null, 45), 818 tVector.lastIndexOf(null, 45) == 40); 819 820 assertEquals(-1, tVector.lastIndexOf("Test 98", -1)); 821 assertEquals(-1, tVector.lastIndexOf("Test 98", 0)); 822 try { 823 assertEquals(-1, tVector.lastIndexOf("Test 98", 1000)); 824 fail("should throw IndexOutOfBoundsException"); 825 } catch (IndexOutOfBoundsException e) { 826 } 827 try { 828 assertEquals(-1, tVector.lastIndexOf("Test 98", Integer.MAX_VALUE)); 829 fail("should throw IndexOutOfBoundsException"); 830 } catch (IndexOutOfBoundsException e) { 831 } 832 try { 833 tVector.lastIndexOf("Test 98", tVector.size()); 834 fail("should throw IndexOutOfBoundsException"); 835 } catch (IndexOutOfBoundsException e) { 836 } 837 try { 838 tVector.indexOf("Test 98", Integer.MIN_VALUE); 839 fail("should throw ArrayIndexOutOfBoundsException"); 840 } catch (ArrayIndexOutOfBoundsException e) { 841 } 842 } 843 844 /** 845 * java.util.Vector#remove(int) 846 */ 847 public void test_removeI() { 848 // Test for method java.lang.Object java.util.Vector.remove(int) 849 Object removeElement = tVector.get(36); 850 Object result = tVector.remove(36); 851 assertFalse("Contained element after remove", tVector 852 .contains("Test 36")); 853 assertEquals("Should return the element that was removed", 854 removeElement, result); 855 assertEquals("Failed to decrement size after remove", 856 99, tVector.size()); 857 tVector.add(20, null); 858 removeElement = tVector.get(19); 859 result = tVector.remove(19); 860 assertNull("Didn't move null element over", tVector.get(19)); 861 assertEquals("Should return the element that was removed", 862 removeElement, result); 863 removeElement = tVector.get(19); 864 result = tVector.remove(19); 865 assertNotNull("Didn't remove null element", tVector.get(19)); 866 assertEquals("Should return the element that was removed", 867 removeElement, result); 868 assertEquals("Failed to decrement size after removing null", 98, tVector 869 .size()); 870 871 try { 872 tVector.remove(-1); 873 fail("Should throw ArrayIndexOutOfBoundsException"); 874 } catch (ArrayIndexOutOfBoundsException e) { 875 // Excepted 876 } 877 878 try { 879 tVector.remove(tVector.size()); 880 fail("Should throw ArrayIndexOutOfBoundsException"); 881 } catch (ArrayIndexOutOfBoundsException e) { 882 // Excepted 883 } 884 } 885 886 /** 887 * java.util.Vector#remove(java.lang.Object) 888 */ 889 public void test_removeLjava_lang_Object() { 890 // Test for method boolean java.util.Vector.remove(java.lang.Object) 891 tVector.remove("Test 0"); 892 assertTrue("Contained element after remove", !tVector 893 .contains("Test 0")); 894 assertEquals("Failed to decrement size after remove", 895 99, tVector.size()); 896 tVector.add(null); 897 tVector.remove(null); 898 assertTrue("Contained null after remove", !tVector.contains(null)); 899 assertEquals("Failed to decrement size after removing null", 99, tVector 900 .size()); 901 } 902 903 /** 904 * java.util.Vector#removeAll(java.util.Collection) 905 */ 906 public void test_removeAllLjava_util_Collection() { 907 // Test for method boolean 908 // java.util.Vector.removeAll(java.util.Collection) 909 Vector v = new Vector(); 910 Collection l = new LinkedList(); 911 for (int i = 0; i < 5; i++) 912 l.add("Test " + i); 913 v.addElement(l); 914 915 Collection s = new HashSet(); 916 Object o; 917 s.add(o = v.firstElement()); 918 v.removeAll(s); 919 assertTrue("Failed to remove items in collection", !v.contains(o)); 920 v.removeAll(l); 921 assertTrue("Failed to remove all elements", v.isEmpty()); 922 923 v.add(null); 924 v.add(null); 925 v.add("Boom"); 926 v.removeAll(s); 927 assertEquals("Should not have removed any elements", 3, v.size()); 928 l = new LinkedList(); 929 l.add(null); 930 v.removeAll(l); 931 assertEquals("Should only have one element", 1, v.size()); 932 assertEquals("Element should be 'Boom'", "Boom", v.firstElement()); 933 934 try { 935 v.removeAll(null); 936 fail("NullPointerException expected"); 937 } catch (NullPointerException e) { 938 //expected 939 } 940 } 941 942 /** 943 * java.util.Vector#removeAllElements() 944 */ 945 public void test_removeAllElements() { 946 // Test for method void java.util.Vector.removeAllElements() 947 Vector v = vectorClone(tVector); 948 v.removeAllElements(); 949 assertEquals("Failed to remove all elements", 0, v.size()); 950 } 951 952 /** 953 * java.util.Vector#removeElement(java.lang.Object) 954 */ 955 public void test_removeElementLjava_lang_Object() { 956 // Test for method boolean 957 // java.util.Vector.removeElement(java.lang.Object) 958 Vector v = vectorClone(tVector); 959 v.removeElement("Test 98"); 960 assertEquals("Element not removed", "Test 99", ((String) v.elementAt(98)) 961 ); 962 assertTrue("Vector is wrong size after removal: " + v.size(), 963 v.size() == 99); 964 tVector.addElement(null); 965 v.removeElement(null); 966 assertTrue("Vector is wrong size after removing null: " + v.size(), v 967 .size() == 99); 968 } 969 970 /** 971 * java.util.Vector#removeElementAt(int) 972 */ 973 public void test_removeElementAtI() { 974 // Test for method void java.util.Vector.removeElementAt(int) 975 Vector v = vectorClone(tVector); 976 int size = v.size(); 977 v.removeElementAt(50); 978 assertEquals("Failed to remove element", -1, v.indexOf("Test 50", 0)); 979 assertEquals("Test 51", v.get(50)); 980 assertEquals(size - 1, v.size()); 981 982 tVector.insertElementAt(null, 60); 983 assertNull(tVector.get(60)); 984 size = tVector.size(); 985 tVector.removeElementAt(60); 986 assertNotNull("Element at 60 should not be null after removal", tVector 987 .elementAt(60)); 988 assertEquals(size - 1, tVector.size()); 989 990 try { 991 tVector.removeElementAt(-1); 992 fail("Should throw ArrayIndexOutOfBoundsException"); 993 } catch (ArrayIndexOutOfBoundsException e) { 994 // Excepted 995 } 996 997 try { 998 tVector.removeElementAt(tVector.size()); 999 fail("Should throw ArrayIndexOutOfBoundsException"); 1000 } catch (ArrayIndexOutOfBoundsException e) { 1001 // Excepted 1002 } 1003 } 1004 1005 /** 1006 * {@link java.util.Vector#removeRange(int, int)} 1007 */ 1008 public void test_removeRange() { 1009 MockVector myVector = new MockVector(); 1010 myVector.removeRange(0, 0); 1011 1012 try { 1013 myVector.removeRange(0, 1); 1014 fail("Should throw IndexOutOfBoundsException"); 1015 } catch (IndexOutOfBoundsException e) { 1016 // Excepted 1017 } 1018 1019 int[] data = { 1, 2, 3, 4 }; 1020 for (int i = 0; i < data.length; i++) { 1021 myVector.add(i, data[i]); 1022 } 1023 1024 myVector.removeRange(0, 2); 1025 assertEquals(data[2], myVector.get(0)); 1026 assertEquals(data[3], myVector.get(1)); 1027 1028 try { 1029 myVector.removeRange(-1, 1); 1030 fail("Should throw IndexOutOfBoundsException"); 1031 } catch (IndexOutOfBoundsException e) { 1032 // Excepted 1033 } 1034 1035 try { 1036 myVector.removeRange(0, -1); 1037 fail("Should throw IndexOutOfBoundsException"); 1038 } catch (IndexOutOfBoundsException e) { 1039 // Excepted 1040 } 1041 1042 try { 1043 myVector.removeRange(1, 0); 1044 fail("Should throw IndexOutOfBoundsException"); 1045 } catch (IndexOutOfBoundsException e) { 1046 // Excepted 1047 } 1048 1049 try { 1050 myVector.removeRange(2, 1); 1051 fail("Should throw IndexOutOfBoundsException"); 1052 } catch (IndexOutOfBoundsException e) { 1053 // Excepted 1054 } 1055 } 1056 1057 /** 1058 * java.util.Vector#retainAll(java.util.Collection) 1059 */ 1060 public void test_retainAllLjava_util_Collection() { 1061 // Test for method boolean 1062 // java.util.Vector.retainAll(java.util.Collection) 1063 Object o = tVector.firstElement(); 1064 tVector.add(null); 1065 Collection s = new HashSet(); 1066 s.add(o); 1067 s.add(null); 1068 tVector.retainAll(s); 1069 assertTrue("Retained items other than specified", tVector.size() == 2 1070 && tVector.contains(o) && tVector.contains(null)); 1071 } 1072 1073 /** 1074 * java.util.Vector#set(int, java.lang.Object) 1075 */ 1076 public void test_setILjava_lang_Object() { 1077 // Test for method java.lang.Object java.util.Vector.set(int, 1078 // java.lang.Object) 1079 Object o = new Object(); 1080 Object previous = tVector.get(23); 1081 Object result = tVector.set(23, o); 1082 assertEquals( 1083 "Should return the element previously at the specified position", 1084 previous, result); 1085 assertTrue("Failed to set Object", tVector.get(23) == o); 1086 1087 previous = tVector.get(0); 1088 result = tVector.set(0, null); 1089 assertEquals( 1090 "Should return the element previously at the specified position", 1091 previous, result); 1092 assertNull("Failed to set Object", tVector.get(0)); 1093 1094 try { 1095 tVector.set(-1, o); 1096 fail("Should throw ArrayIndexOutOfBoundsException"); 1097 } catch (ArrayIndexOutOfBoundsException e) { 1098 // Excepted 1099 } 1100 1101 try { 1102 tVector.set(-1, null); 1103 fail("Should throw ArrayIndexOutOfBoundsException"); 1104 } catch (ArrayIndexOutOfBoundsException e) { 1105 // Excepted 1106 } 1107 1108 try { 1109 tVector.set(tVector.size(), o); 1110 fail("Should throw ArrayIndexOutOfBoundsException"); 1111 } catch (ArrayIndexOutOfBoundsException e) { 1112 // Excepted 1113 } 1114 1115 try { 1116 tVector.set(tVector.size(), null); 1117 fail("Should throw ArrayIndexOutOfBoundsException"); 1118 } catch (ArrayIndexOutOfBoundsException e) { 1119 // Excepted 1120 } 1121 } 1122 1123 /** 1124 * java.util.Vector#setElementAt(java.lang.Object, int) 1125 */ 1126 public void test_setElementAtLjava_lang_ObjectI() { 1127 // Test for method void java.util.Vector.setElementAt(java.lang.Object, 1128 // int) 1129 Vector v = vectorClone(tVector); 1130 v.setElementAt("Inserted Element", 99); 1131 assertEquals("Element not set", "Inserted Element", ((String) v.elementAt(99)) 1132 ); 1133 1134 v.setElementAt(null, 0); 1135 assertNull("Null element not set", v.elementAt(0)); 1136 1137 try { 1138 v.setElementAt("Inserted Element", -1); 1139 fail("Should throw ArrayIndexOutOfBoundsException"); 1140 } catch (ArrayIndexOutOfBoundsException e) { 1141 // Excepted 1142 } 1143 1144 try { 1145 v.setElementAt(null, -1); 1146 fail("Should throw ArrayIndexOutOfBoundsException"); 1147 } catch (ArrayIndexOutOfBoundsException e) { 1148 // Excepted 1149 } 1150 1151 try { 1152 v.setElementAt("Inserted Element", v.size()); 1153 fail("Should throw ArrayIndexOutOfBoundsException"); 1154 } catch (ArrayIndexOutOfBoundsException e) { 1155 // Excepted 1156 } 1157 1158 try { 1159 v.setElementAt(null, v.size()); 1160 fail("Should throw ArrayIndexOutOfBoundsException"); 1161 } catch (ArrayIndexOutOfBoundsException e) { 1162 // Excepted 1163 } 1164 } 1165 1166 /** 1167 * java.util.Vector#setSize(int) 1168 */ 1169 public void test_setSizeI() { 1170 // Test for method void java.util.Vector.setSize(int) 1171 Vector v = vectorClone(tVector); 1172 int oldSize = v.size(); 1173 Object preElement = v.get(10); 1174 v.setSize(10); 1175 assertEquals("Failed to set size", 10, v.size()); 1176 assertEquals( 1177 "All components at index newSize and greater should be discarded", 1178 -1, v.indexOf(preElement)); 1179 try { 1180 v.get(oldSize - 1); 1181 } catch (ArrayIndexOutOfBoundsException e) { 1182 // Excepted; 1183 } 1184 1185 oldSize = v.size(); 1186 v.setSize(20); 1187 assertEquals("Failed to set size", 20, v.size()); 1188 for (int i = oldSize; i < v.size(); i++) { 1189 assertNull(v.get(i)); 1190 } 1191 1192 try { 1193 v.setSize(-1); 1194 fail("Should throw ArrayIndexOutOfBoundsException"); 1195 } catch (ArrayIndexOutOfBoundsException e) { 1196 // Excepted 1197 } 1198 } 1199 1200 /** 1201 * java.util.Vector#size() 1202 */ 1203 public void test_size() { 1204 // Test for method int java.util.Vector.size() 1205 assertEquals("Returned incorrect size", 100, tVector.size()); 1206 1207 final Vector v = new Vector(); 1208 v.addElement("initial"); 1209 Thread t1 = new Thread() { 1210 public void run() { 1211 while (v.size() > 0) 1212 ; 1213 v.addElement("final"); 1214 } 1215 }; 1216 t1.start(); 1217 for (int i = 0; i < 10000; i++) { 1218 synchronized (v) { 1219 v.removeElementAt(0); 1220 v.addElement(String.valueOf(i)); 1221 } 1222 int size; 1223 if ((size = v.size()) != 1) { 1224 String result = "Size is not 1: " + size + " " + v; 1225 // terminate the thread 1226 v.removeAllElements(); 1227 fail(result); 1228 } 1229 } 1230 // terminate the thread 1231 v.removeElementAt(0); 1232 } 1233 1234 /** 1235 * java.util.Vector#subList(int, int) 1236 */ 1237 public void test_subListII() { 1238 // Test for method java.util.List java.util.Vector.subList(int, int) 1239 List sl = tVector.subList(10, 25); 1240 assertEquals("Returned sublist of incorrect size", 15, sl.size()); 1241 for (int i = 10; i < 25; i++) 1242 assertTrue("Returned incorrect sublist", sl 1243 .contains(tVector.get(i))); 1244 1245 assertEquals("Not synchronized random access", "java.util.Collections$SynchronizedRandomAccessList", sl.getClass().getName() 1246 ); 1247 1248 } 1249 1250 /** 1251 * java.util.Vector#toArray() 1252 */ 1253 public void test_toArray() { 1254 // Test for method java.lang.Object [] java.util.Vector.toArray() 1255 assertTrue("Returned incorrect array", Arrays.equals(objArray, tVector 1256 .toArray())); 1257 } 1258 1259 /** 1260 * java.util.Vector#toArray(java.lang.Object[]) 1261 */ 1262 public void test_toArray$Ljava_lang_Object() { 1263 // Test for method java.lang.Object [] 1264 // java.util.Vector.toArray(java.lang.Object []) 1265 Object[] o = new Object[1000]; 1266 Object f = new Object(); 1267 for (int i = 0; i < o.length; i++) 1268 o[i] = f; 1269 tVector.toArray(o); 1270 assertNull("Failed to set slot to null", o[100]); 1271 for (int i = 0; i < tVector.size(); i++) 1272 assertTrue("Returned incorrect array", tVector.elementAt(i) == o[i]); 1273 } 1274 1275 1276 class SubVector<E> extends Vector<E> { 1277 1278 private static final long serialVersionUID = 1L; 1279 1280 public SubVector() { 1281 super(); 1282 } 1283 1284 public synchronized boolean add(E obj) { 1285 super.addElement(obj); 1286 return true; 1287 } 1288 1289 public synchronized void addElement(E obj) { 1290 super.add(obj); 1291 } 1292 1293 /** 1294 * java.util.Vector#add(Object) 1295 */ 1296 @SuppressWarnings("nls") 1297 public void test_add() { 1298 SubVector<String> subvector = new SubVector<String>(); 1299 subvector.add("foo"); 1300 subvector.addElement("bar"); 1301 assertEquals("Expected two elements in vector", 2, subvector.size()); 1302 } 1303 1304 } 1305 1306 /** 1307 * java.util.Vector#toString() 1308 */ 1309 public void test_toString() { 1310 // Ensure toString works with self-referencing elements. 1311 Vector<Object> vec = new Vector<Object>(3); 1312 vec.add(null); 1313 vec.add(new Object()); 1314 vec.add(vec); 1315 assertNotNull(vec.toString()); 1316 1317 // Test for method java.lang.String java.util.Vector.toString() 1318 assertTrue("Incorrect String returned", tVector.toString().equals( 1319 vString)); 1320 1321 Vector v = new Vector(); 1322 v.addElement("one"); 1323 v.addElement(v); 1324 v.addElement("3"); 1325 // test last element 1326 v.addElement(v); 1327 String result = v.toString(); 1328 assertTrue("should contain self ref", result.indexOf("(this") > -1); 1329 } 1330 1331 public void test_override_size() throws Exception { 1332 Vector v = new Vector(); 1333 Vector testv = new MockVector(); 1334 // though size is overriden, it should passed without exception 1335 testv.add(1); 1336 testv.add(2); 1337 testv.clear(); 1338 1339 testv.add(1); 1340 testv.add(2); 1341 v.add(1); 1342 v.add(2); 1343 // RI's bug here 1344 assertTrue(testv.equals(v)); 1345 } 1346 1347 /** 1348 * java.util.Vector#trimToSize() 1349 */ 1350 public void test_trimToSize() { 1351 // Test for method void java.util.Vector.trimToSize() 1352 Vector v = new Vector(10); 1353 v.addElement(new Object()); 1354 v.trimToSize(); 1355 assertEquals("Failed to trim capacity", 1, v.capacity()); 1356 } 1357 1358 public void test_removeRangeII() { 1359 MockVector mv = new MockVector(); 1360 mv.add("First"); 1361 mv.add("Second"); 1362 mv.add("One more"); 1363 mv.add("Last"); 1364 mv.removeRange(1, 3); 1365 assertTrue(mv.contains("First")); 1366 assertFalse(mv.contains("Second")); 1367 assertFalse(mv.contains("One more")); 1368 assertTrue(mv.contains("Last")); 1369 } 1370 1371 protected Vector vectorClone(Vector s) { 1372 return (Vector) s.clone(); 1373 } 1374 1375 public class MockVector extends Vector { 1376 @Override 1377 public synchronized int size() { 1378 return 0; 1379 } 1380 1381 public void removeRange(int start, int end) { 1382 super.removeRange(start, end); 1383 } 1384 } 1385 1386 /** 1387 * Sets up the fixture, for example, open a network connection. This method 1388 * is called before a test is executed. 1389 */ 1390 protected void setUp() { 1391 for (int i = 0; i < 100; i++) { 1392 tVector.addElement("Test " + i); 1393 } 1394 objArray = new Object[100]; 1395 for (int i = 0; i < 100; i++) { 1396 objArray[i] = "Test " + i; 1397 } 1398 } 1399 1400 /** 1401 * Tears down the fixture, for example, close a network connection. This 1402 * method is called after a test is executed. 1403 */ 1404 protected void tearDown() { 1405 } 1406} 1407