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 tests.api.java.util; 19 20import dalvik.annotation.TestTargetNew; 21import dalvik.annotation.TestTargets; 22import dalvik.annotation.TestLevel; 23import dalvik.annotation.TestTargetClass; 24 25import java.util.Calendar; 26import java.util.Date; 27import java.util.GregorianCalendar; 28import java.util.Locale; 29import java.util.TimeZone; 30 31@TestTargetClass(Date.class) 32public class DateTest extends junit.framework.TestCase { 33 34 /** 35 * @tests java.util.Date#Date() 36 */ 37 @TestTargetNew( 38 level = TestLevel.COMPLETE, 39 notes = "", 40 method = "Date", 41 args = {} 42 ) 43 public void test_Constructor() { 44 // Test for method java.util.Date() 45 GregorianCalendar gc = new GregorianCalendar(1998, Calendar.OCTOBER, 46 13, 19, 9); 47 long oldTime = gc.getTime().getTime(); 48 long now = new Date().getTime(); 49 assertTrue("Created incorrect date: " + oldTime + " now: " + now, 50 oldTime < now); 51 } 52 53 /** 54 * @tests java.util.Date#Date(int, int, int) 55 */ 56 @TestTargetNew( 57 level = TestLevel.COMPLETE, 58 notes = "", 59 method = "Date", 60 args = {int.class, int.class, int.class} 61 ) 62 public void test_ConstructorIII() { 63 // Test for method java.util.Date(int, int, int) 64 Date d1 = new Date(70, 0, 1); // the epoch + local time 65 66 // the epoch + local time 67 Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000); 68 69 assertTrue("Created incorrect date", d1.equals(d2)); 70 71 Date date = new Date(99, 5, 22); 72 Calendar cal = new GregorianCalendar(1999, Calendar.JUNE, 22); 73 assertTrue("Wrong time zone", date.equals(cal.getTime())); 74 } 75 76 /** 77 * @tests java.util.Date#Date(int, int, int, int, int) 78 */ 79 @TestTargetNew( 80 level = TestLevel.COMPLETE, 81 notes = "", 82 method = "Date", 83 args = {int.class, int.class, int.class, int.class, int.class} 84 ) 85 public void test_ConstructorIIIII() { 86 // Test for method java.util.Date(int, int, int, int, int) 87 88 // the epoch + local time + (1 hour and 1 minute) 89 Date d1 = new Date(70, 0, 1, 1, 1); 90 91 // the epoch + local time + (1 hour and 1 minute) 92 Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60 93 * 1000 + 60 * 1000); 94 95 assertTrue("Created incorrect date", d1.equals(d2)); 96 } 97 98 /** 99 * @tests java.util.Date#Date(int, int, int, int, int, int) 100 */ 101 @TestTargetNew( 102 level = TestLevel.COMPLETE, 103 notes = "", 104 method = "Date", 105 args = {int.class, int.class, int.class, int.class, int.class, int.class} 106 ) 107 public void test_ConstructorIIIIII() { 108 // Test for method java.util.Date(int, int, int, int, int, int) 109 110 // the epoch + local time + (1 hour and 1 minute + 1 second) 111 Date d1 = new Date(70, 0, 1, 1, 1, 1); 112 113 // the epoch + local time + (1 hour and 1 minute + 1 second) 114 Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60 115 * 1000 + 60 * 1000 + 1000); 116 117 assertTrue("Created incorrect date", d1.equals(d2)); 118 } 119 120 /** 121 * @tests java.util.Date#Date(long) 122 */ 123 @TestTargetNew( 124 level = TestLevel.COMPLETE, 125 notes = "", 126 method = "Date", 127 args = {long.class} 128 ) 129 public void test_ConstructorJ() { 130 // Test for method java.util.Date(long) 131 assertTrue("Used to test", true); 132 } 133 134 /** 135 * @tests java.util.Date#Date(java.lang.String) 136 */ 137 @TestTargetNew( 138 level = TestLevel.COMPLETE, 139 notes = "", 140 method = "Date", 141 args = {java.lang.String.class} 142 ) 143 public void test_ConstructorLjava_lang_String() { 144 // Test for method java.util.Date(java.lang.String) 145 Date d1 = new Date("January 1, 1970, 00:00:00 GMT"); // the epoch 146 Date d2 = new Date(0); // the epoch 147 assertTrue("Created incorrect date", d1.equals(d2)); 148 149 try { 150 // Regression for HARMONY-238 151 new Date(null); 152 fail("Constructor Date((String)null) should " 153 + "throw IllegalArgumentException"); 154 } catch (IllegalArgumentException e) { 155 // expected 156 } 157 } 158 159 /** 160 * @tests java.util.Date#after(java.util.Date) 161 */ 162 @TestTargetNew( 163 level = TestLevel.COMPLETE, 164 notes = "", 165 method = "after", 166 args = {java.util.Date.class} 167 ) 168 public void test_afterLjava_util_Date() { 169 // Test for method boolean java.util.Date.after(java.util.Date) 170 Date d1 = new Date(0); 171 Date d2 = new Date(1900000); 172 assertTrue("Older was returned as newer", d2.after(d1)); 173 assertTrue("Newer was returned as older", !d1.after(d2)); 174 175 try { 176 d1.after(null); 177 fail("NullPointerException expected"); 178 } catch (NullPointerException e) { 179 //expected 180 } 181 } 182 183 /** 184 * @tests java.util.Date#before(java.util.Date) 185 */ 186 @TestTargetNew( 187 level = TestLevel.COMPLETE, 188 notes = "", 189 method = "before", 190 args = {java.util.Date.class} 191 ) 192 public void test_beforeLjava_util_Date() { 193 // Test for method boolean java.util.Date.before(java.util.Date) 194 Date d1 = new Date(0); 195 Date d2 = new Date(1900000); 196 assertTrue("Older was returned as newer", !d2.before(d1)); 197 assertTrue("Newer was returned as older", d1.before(d2)); 198 199 try { 200 d1.before(null); 201 fail("NullPointerException expected"); 202 } catch (NullPointerException e) { 203 //expected 204 } 205 } 206 207 /** 208 * @tests java.util.Date#clone() 209 */ 210 @TestTargetNew( 211 level = TestLevel.COMPLETE, 212 notes = "", 213 method = "clone", 214 args = {} 215 ) 216 public void test_clone() { 217 // Test for method java.lang.Object java.util.Date.clone() 218 Date d1 = new Date(100000); 219 Date d2 = (Date) d1.clone(); 220 assertTrue( 221 "Cloning date results in same reference--new date is equivalent", 222 d1 != d2); 223 assertTrue("Cloning date results unequal date", d1.equals(d2)); 224 } 225 226 /** 227 * @tests java.util.Date#compareTo(java.util.Date) 228 */ 229 @TestTargetNew( 230 level = TestLevel.COMPLETE, 231 notes = "", 232 method = "compareTo", 233 args = {java.util.Date.class} 234 ) 235 public void test_compareToLjava_util_Date() { 236 // Test for method int java.util.Date.compareTo(java.util.Date) 237 final int someNumber = 10000; 238 Date d1 = new Date(someNumber); 239 Date d2 = new Date(someNumber); 240 Date d3 = new Date(someNumber + 1); 241 Date d4 = new Date(someNumber - 1); 242 assertEquals("Comparing a date to itself did not answer zero", 0, d1 243 .compareTo(d1)); 244 assertEquals("Comparing equal dates did not answer zero", 0, d1 245 .compareTo(d2)); 246 assertEquals("date1.compareTo(date2), where date1 > date2, did not result in 1", 247 1, d1.compareTo(d4)); 248 assertEquals("date1.compareTo(date2), where date1 < date2, did not result in -1", 249 -1, d1.compareTo(d3)); 250 251 try { 252 d1.compareTo(null); 253 fail("NullPointerException expected"); 254 } catch (NullPointerException e) { 255 //expected 256 } 257 } 258 259 /** 260 * @tests java.util.Date#equals(java.lang.Object) 261 */ 262 @TestTargetNew( 263 level = TestLevel.COMPLETE, 264 notes = "", 265 method = "equals", 266 args = {java.lang.Object.class} 267 ) 268 public void test_equalsLjava_lang_Object() { 269 // Test for method boolean java.util.Date.equals(java.lang.Object) 270 Date d1 = new Date(0); 271 Date d2 = new Date(1900000); 272 Date d3 = new Date(1900000); 273 assertTrue("Equality test failed", d2.equals(d3)); 274 assertTrue("Equality test failed", !d1.equals(d2)); 275 } 276 277 /** 278 * @tests java.util.Date#getDate() 279 */ 280 @TestTargetNew( 281 level = TestLevel.COMPLETE, 282 notes = "", 283 method = "getDate", 284 args = {} 285 ) 286 public void test_getDate() { 287 // Test for method int java.util.Date.getDate() 288 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 289 .getTime(); 290 assertEquals("Returned incorrect date", 13, d.getDate()); 291 } 292 293 /** 294 * @tests java.util.Date#getDay() 295 */ 296 @TestTargetNew( 297 level = TestLevel.COMPLETE, 298 notes = "", 299 method = "getDay", 300 args = {} 301 ) 302 public void test_getDay() { 303 // Test for method int java.util.Date.getDay() 304 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 305 .getTime(); 306 assertEquals("Returned incorrect day", 2, d.getDay()); 307 } 308 309 /** 310 * @tests java.util.Date#getHours() 311 */ 312 @TestTargetNew( 313 level = TestLevel.COMPLETE, 314 notes = "", 315 method = "getHours", 316 args = {} 317 ) 318 public void test_getHours() { 319 // Test for method int java.util.Date.getHours() 320 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 321 .getTime(); 322 assertEquals("Returned incorrect hours", 19, d.getHours()); 323 } 324 325 /** 326 * @tests java.util.Date#getMinutes() 327 */ 328 @TestTargetNew( 329 level = TestLevel.COMPLETE, 330 notes = "", 331 method = "getMinutes", 332 args = {} 333 ) 334 public void test_getMinutes() { 335 // Test for method int java.util.Date.getMinutes() 336 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 337 .getTime(); 338 assertEquals("Returned incorrect minutes", 9, d.getMinutes()); 339 } 340 341 /** 342 * @tests java.util.Date#getMonth() 343 */ 344 @TestTargetNew( 345 level = TestLevel.COMPLETE, 346 notes = "", 347 method = "getMonth", 348 args = {} 349 ) 350 public void test_getMonth() { 351 // Test for method int java.util.Date.getMonth() 352 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 353 .getTime(); 354 assertEquals("Returned incorrect month", 9, d.getMonth()); 355 } 356 357 /** 358 * @tests java.util.Date#getSeconds() 359 */ 360 @TestTargetNew( 361 level = TestLevel.COMPLETE, 362 notes = "", 363 method = "getSeconds", 364 args = {} 365 ) 366 public void test_getSeconds() { 367 // Test for method int java.util.Date.getSeconds() 368 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 369 .getTime(); 370 assertEquals("Returned incorrect seconds", 0, d.getSeconds()); 371 } 372 373 /** 374 * @tests java.util.Date#getTime() 375 */ 376 @TestTargetNew( 377 level = TestLevel.COMPLETE, 378 notes = "", 379 method = "getTime", 380 args = {} 381 ) 382 public void test_getTime() { 383 // Test for method long java.util.Date.getTime() 384 Date d1 = new Date(0); 385 Date d2 = new Date(1900000); 386 assertEquals("Returned incorrect time", 1900000, d2.getTime()); 387 assertEquals("Returned incorrect time", 0, d1.getTime()); 388 } 389 390 /** 391 * @tests java.util.Date#getTimezoneOffset() 392 */ 393 @TestTargetNew( 394 level = TestLevel.COMPLETE, 395 notes = "", 396 method = "getTimezoneOffset", 397 args = {} 398 ) 399 public void test_getTimezoneOffset() { 400 // Test for method int java.util.Date.getTimezoneOffset() 401 assertTrue("Used to test", true); 402 int offset = new Date(96, 1, 14).getTimezoneOffset(); 403 assertTrue(offset > -720 && offset < 720); 404 } 405 406 /** 407 * @tests java.util.Date#getYear() 408 */ 409 @TestTargetNew( 410 level = TestLevel.COMPLETE, 411 notes = "", 412 method = "getYear", 413 args = {} 414 ) 415 public void test_getYear() { 416 // Test for method int java.util.Date.getYear() 417 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 418 .getTime(); 419 assertEquals("Returned incorrect year", 98, d.getYear()); 420 } 421 422 /** 423 * @tests java.util.Date#hashCode() 424 */ 425 @TestTargetNew( 426 level = TestLevel.COMPLETE, 427 notes = "", 428 method = "hashCode", 429 args = {} 430 ) 431 public void test_hashCode() { 432 // Test for method int java.util.Date.hashCode() 433 Date d1 = new Date(0); 434 Date d2 = new Date(1900000); 435 assertEquals("Returned incorrect hash", 1900000, d2.hashCode()); 436 assertEquals("Returned incorrect hash", 0, d1.hashCode()); 437 } 438 439 /** 440 * @tests java.util.Date#parse(java.lang.String) 441 */ 442 @TestTargetNew( 443 level = TestLevel.COMPLETE, 444 notes = "", 445 method = "parse", 446 args = {java.lang.String.class} 447 ) 448 public void test_parseLjava_lang_String() { 449 // Test for method long java.util.Date.parse(java.lang.String) 450 Date d = new Date(Date.parse("13 October 1998")); 451 GregorianCalendar cal = new GregorianCalendar(); 452 cal.setTime(d); 453 assertEquals("Parsed incorrect month", 9, cal.get(Calendar.MONTH)); 454 assertEquals("Parsed incorrect year", 1998, cal.get(Calendar.YEAR)); 455 assertEquals("Parsed incorrect date", 13, cal.get(Calendar.DATE)); 456 457 d = new Date(Date.parse("Jan-12 1999")); 458 assertTrue("Wrong parsed date 1", d.equals(new GregorianCalendar(1999, 459 0, 12).getTime())); 460 d = new Date(Date.parse("Jan12-1999")); 461 assertTrue("Wrong parsed date 2", d.equals(new GregorianCalendar(1999, 462 0, 12).getTime())); 463 d = new Date(Date.parse("Jan12 69-1")); 464 cal.setTimeZone(TimeZone.getTimeZone("GMT")); 465 cal.clear(); 466 cal.set(1969, Calendar.JANUARY, 12, 1, 0); 467 assertTrue("Wrong parsed date 3", d.equals(cal.getTime())); 468 d = new Date(Date.parse("6:45:13 3/2/1200 MST")); 469 cal.setTimeZone(TimeZone.getTimeZone("MST")); 470 cal.clear(); 471 cal.set(1200, 2, 2, 6, 45, 13); 472 assertTrue("Wrong parsed date 4", d.equals(cal.getTime())); 473 d = new Date(Date.parse("Mon, 22 Nov 1999 12:52:06 GMT")); 474 cal.setTimeZone(TimeZone.getTimeZone("GMT")); 475 cal.clear(); 476 cal.set(1999, Calendar.NOVEMBER, 22, 12, 52, 06); 477 assertTrue("Wrong parsed date 5", d.equals(cal.getTime())); 478 479 try { 480 // Regression for HARMONY-259 481 Date.parse(null); 482 fail("Date.parse(null) should throw IllegalArgumentException"); 483 } catch (IllegalArgumentException e) { 484 // expected 485 } 486 } 487 488 /** 489 * @tests java.util.Date#setDate(int) 490 */ 491 @TestTargetNew( 492 level = TestLevel.COMPLETE, 493 notes = "", 494 method = "setDate", 495 args = {int.class} 496 ) 497 public void test_setDateI() { 498 // Test for method void java.util.Date.setDate(int) 499 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 500 .getTime(); 501 d.setDate(23); 502 assertEquals("Set incorrect date", 23, d.getDate()); 503 } 504 505 /** 506 * @tests java.util.Date#setHours(int) 507 */ 508 @TestTargetNew( 509 level = TestLevel.COMPLETE, 510 notes = "", 511 method = "setHours", 512 args = {int.class} 513 ) 514 public void test_setHoursI() { 515 // Test for method void java.util.Date.setHours(int) 516 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 517 .getTime(); 518 d.setHours(23); 519 assertEquals("Set incorrect hours", 23, d.getHours()); 520 } 521 522 /** 523 * @tests java.util.Date#setMinutes(int) 524 */ 525 @TestTargetNew( 526 level = TestLevel.COMPLETE, 527 notes = "", 528 method = "setMinutes", 529 args = {int.class} 530 ) 531 public void test_setMinutesI() { 532 // Test for method void java.util.Date.setMinutes(int) 533 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 534 .getTime(); 535 d.setMinutes(45); 536 assertEquals("Set incorrect mins", 45, d.getMinutes()); 537 } 538 539 /** 540 * @tests java.util.Date#setMonth(int) 541 */ 542 @TestTargetNew( 543 level = TestLevel.COMPLETE, 544 notes = "", 545 method = "setMonth", 546 args = {int.class} 547 ) 548 public void test_setMonthI() { 549 // Test for method void java.util.Date.setMonth(int) 550 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 551 .getTime(); 552 d.setMonth(0); 553 assertEquals("Set incorrect month", 0, d.getMonth()); 554 } 555 556 /** 557 * @tests java.util.Date#setSeconds(int) 558 */ 559 @TestTargetNew( 560 level = TestLevel.COMPLETE, 561 notes = "", 562 method = "setSeconds", 563 args = {int.class} 564 ) 565 public void test_setSecondsI() { 566 // Test for method void java.util.Date.setSeconds(int) 567 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 568 .getTime(); 569 d.setSeconds(13); 570 assertEquals("Set incorrect seconds", 13, d.getSeconds()); 571 } 572 573 /** 574 * @tests java.util.Date#setTime(long) 575 */ 576 @TestTargetNew( 577 level = TestLevel.COMPLETE, 578 notes = "", 579 method = "setTime", 580 args = {long.class} 581 ) 582 public void test_setTimeJ() { 583 // Test for method void java.util.Date.setTime(long) 584 Date d1 = new Date(0); 585 Date d2 = new Date(1900000); 586 d1.setTime(900); 587 d2.setTime(890000); 588 assertEquals("Returned incorrect time", 890000, d2.getTime()); 589 assertEquals("Returned incorrect time", 900, d1.getTime()); 590 } 591 592 /** 593 * @tests java.util.Date#setYear(int) 594 */ 595 @TestTargetNew( 596 level = TestLevel.COMPLETE, 597 notes = "", 598 method = "setYear", 599 args = {int.class} 600 ) 601 public void test_setYearI() { 602 // Test for method void java.util.Date.setYear(int) 603 Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) 604 .getTime(); 605 d.setYear(8); 606 assertEquals("Set incorrect year", 8, d.getYear()); 607 } 608 609 /** 610 * @tests java.util.Date#toGMTString() 611 */ 612 @TestTargetNew( 613 level = TestLevel.COMPLETE, 614 notes = "", 615 method = "toGMTString", 616 args = {} 617 ) 618 public void test_toGMTString() { 619 // Test for method java.lang.String java.util.Date.toGMTString() 620 assertEquals("Did not convert epoch to GMT string correctly", "1 Jan 1970 00:00:00 GMT", new Date(0) 621 .toGMTString()); 622 assertEquals("Did not convert epoch + 1yr to GMT string correctly", 623 "1 Jan 1971 00:00:00 GMT", new Date((long) 365 * 24 * 60 * 60 * 1000).toGMTString() 624 ); 625 } 626 627 /** 628 * @tests java.util.Date#toString() 629 */ 630 @TestTargetNew( 631 level = TestLevel.COMPLETE, 632 notes = "", 633 method = "toString", 634 args = {} 635 ) 636 public void test_toString() { 637 // Test for method java.lang.String java.util.Date.toString() 638 Calendar cal = Calendar.getInstance(); 639 cal.set(Calendar.DATE, 1); 640 cal.set(Calendar.MONTH, Calendar.JANUARY); 641 cal.set(Calendar.YEAR, 1970); 642 cal.set(Calendar.HOUR_OF_DAY, 0); 643 cal.set(Calendar.MINUTE, 0); 644 cal.set(Calendar.SECOND, 0); 645 Date d = cal.getTime(); 646 String result = d.toString(); 647 assertTrue("Incorrect result: " + d, result 648 .startsWith("Thu Jan 01 00:00:00") 649 && result.endsWith("1970")); 650 651 TimeZone tz = TimeZone.getDefault(); 652 TimeZone.setDefault(TimeZone.getTimeZone("GMT-5")); 653 try { 654 Date d1 = new Date(0); 655 assertTrue("Returned incorrect string: " + d1, d1.toString() 656 .equals("Wed Dec 31 19:00:00 GMT-05:00 1969")); 657 } finally { 658 TimeZone.setDefault(tz); 659 } 660 } 661 662 /** 663 * @tests java.util.Date#UTC(int, int, int, int, int, int) 664 */ 665 @TestTargetNew( 666 level = TestLevel.COMPLETE, 667 notes = "", 668 method = "UTC", 669 args = {int.class, int.class, int.class, int.class, int.class, int.class} 670 ) 671 public void test_UTCIIIIII() { 672 // Test for method long java.util.Date.UTC(int, int, int, int, int, int) 673 assertTrue("Returned incorrect UTC value for epoch", Date.UTC(70, 0, 1, 674 0, 0, 0) == (long) 0); 675 assertTrue("Returned incorrect UTC value for epoch +1yr", Date.UTC(71, 676 0, 1, 0, 0, 0) == (long) 365 * 24 * 60 * 60 * 1000); 677 } 678 /** 679 * @tests java.util.Date#toLocaleString() Test for method java.lang.String 680 * java.util.Date.toGMTString() 681 */ 682 @TestTargetNew( 683 level = TestLevel.COMPLETE, 684 notes = "", 685 method = "toLocaleString", 686 args = {} 687 ) 688 public void test_toLocaleString() { 689 Locale loc = Locale.getDefault(); 690 Locale.setDefault(Locale.US); 691 TimeZone tz = TimeZone.getDefault(); 692 TimeZone.setDefault(TimeZone.getTimeZone("GMT")); 693 try { 694 assertEquals("Did not convert epoch to GMT string correctly", "Jan 1, 1970 12:00:00 AM", 695 new Date(0).toLocaleString()); 696 assertEquals("Did not convert epoch + 1yr to GMT string correctly", 697 "Jan 1, 1971 12:00:00 AM", new Date((long)365 * 24 * 60 * 60 * 1000) 698 .toLocaleString()); 699 } finally { 700 Locale.setDefault(loc); 701 TimeZone.setDefault(tz); 702 } 703 } 704 705 /** 706 * Sets up the fixture, for example, open a network connection. This method 707 * is called before a test is executed. 708 */ 709 protected void setUp() { 710 } 711 712 /** 713 * Tears down the fixture, for example, close a network connection. This 714 * method is called after a test is executed. 715 */ 716 protected void tearDown() { 717 } 718} 719