| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package tests.api.java.util; |
| |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.GregorianCalendar; |
| import java.util.Locale; |
| import java.util.TimeZone; |
| |
| @TestTargetClass(Date.class) |
| public class DateTest extends junit.framework.TestCase { |
| |
| /** |
| * @tests java.util.Date#Date() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {} |
| ) |
| public void test_Constructor() { |
| // Test for method java.util.Date() |
| GregorianCalendar gc = new GregorianCalendar(1998, Calendar.OCTOBER, |
| 13, 19, 9); |
| long oldTime = gc.getTime().getTime(); |
| long now = new Date().getTime(); |
| assertTrue("Created incorrect date: " + oldTime + " now: " + now, |
| oldTime < now); |
| } |
| |
| /** |
| * @tests java.util.Date#Date(int, int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {int.class, int.class, int.class} |
| ) |
| public void test_ConstructorIII() { |
| // Test for method java.util.Date(int, int, int) |
| Date d1 = new Date(70, 0, 1); // the epoch + local time |
| |
| // the epoch + local time |
| Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000); |
| |
| assertTrue("Created incorrect date", d1.equals(d2)); |
| |
| Date date = new Date(99, 5, 22); |
| Calendar cal = new GregorianCalendar(1999, Calendar.JUNE, 22); |
| assertTrue("Wrong time zone", date.equals(cal.getTime())); |
| } |
| |
| /** |
| * @tests java.util.Date#Date(int, int, int, int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {int.class, int.class, int.class, int.class, int.class} |
| ) |
| public void test_ConstructorIIIII() { |
| // Test for method java.util.Date(int, int, int, int, int) |
| |
| // the epoch + local time + (1 hour and 1 minute) |
| Date d1 = new Date(70, 0, 1, 1, 1); |
| |
| // the epoch + local time + (1 hour and 1 minute) |
| Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60 |
| * 1000 + 60 * 1000); |
| |
| assertTrue("Created incorrect date", d1.equals(d2)); |
| } |
| |
| /** |
| * @tests java.util.Date#Date(int, int, int, int, int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {int.class, int.class, int.class, int.class, int.class, int.class} |
| ) |
| public void test_ConstructorIIIIII() { |
| // Test for method java.util.Date(int, int, int, int, int, int) |
| |
| // the epoch + local time + (1 hour and 1 minute + 1 second) |
| Date d1 = new Date(70, 0, 1, 1, 1, 1); |
| |
| // the epoch + local time + (1 hour and 1 minute + 1 second) |
| Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60 |
| * 1000 + 60 * 1000 + 1000); |
| |
| assertTrue("Created incorrect date", d1.equals(d2)); |
| } |
| |
| /** |
| * @tests java.util.Date#Date(long) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {long.class} |
| ) |
| public void test_ConstructorJ() { |
| // Test for method java.util.Date(long) |
| assertTrue("Used to test", true); |
| } |
| |
| /** |
| * @tests java.util.Date#Date(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Date", |
| args = {java.lang.String.class} |
| ) |
| public void test_ConstructorLjava_lang_String() { |
| // Test for method java.util.Date(java.lang.String) |
| Date d1 = new Date("January 1, 1970, 00:00:00 GMT"); // the epoch |
| Date d2 = new Date(0); // the epoch |
| assertTrue("Created incorrect date", d1.equals(d2)); |
| |
| try { |
| // Regression for HARMONY-238 |
| new Date(null); |
| fail("Constructor Date((String)null) should " |
| + "throw IllegalArgumentException"); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#after(java.util.Date) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "after", |
| args = {java.util.Date.class} |
| ) |
| public void test_afterLjava_util_Date() { |
| // Test for method boolean java.util.Date.after(java.util.Date) |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| assertTrue("Older was returned as newer", d2.after(d1)); |
| assertTrue("Newer was returned as older", !d1.after(d2)); |
| |
| try { |
| d1.after(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#before(java.util.Date) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "before", |
| args = {java.util.Date.class} |
| ) |
| public void test_beforeLjava_util_Date() { |
| // Test for method boolean java.util.Date.before(java.util.Date) |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| assertTrue("Older was returned as newer", !d2.before(d1)); |
| assertTrue("Newer was returned as older", d1.before(d2)); |
| |
| try { |
| d1.before(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#clone() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "clone", |
| args = {} |
| ) |
| public void test_clone() { |
| // Test for method java.lang.Object java.util.Date.clone() |
| Date d1 = new Date(100000); |
| Date d2 = (Date) d1.clone(); |
| assertTrue( |
| "Cloning date results in same reference--new date is equivalent", |
| d1 != d2); |
| assertTrue("Cloning date results unequal date", d1.equals(d2)); |
| } |
| |
| /** |
| * @tests java.util.Date#compareTo(java.util.Date) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "compareTo", |
| args = {java.util.Date.class} |
| ) |
| public void test_compareToLjava_util_Date() { |
| // Test for method int java.util.Date.compareTo(java.util.Date) |
| final int someNumber = 10000; |
| Date d1 = new Date(someNumber); |
| Date d2 = new Date(someNumber); |
| Date d3 = new Date(someNumber + 1); |
| Date d4 = new Date(someNumber - 1); |
| assertEquals("Comparing a date to itself did not answer zero", 0, d1 |
| .compareTo(d1)); |
| assertEquals("Comparing equal dates did not answer zero", 0, d1 |
| .compareTo(d2)); |
| assertEquals("date1.compareTo(date2), where date1 > date2, did not result in 1", |
| 1, d1.compareTo(d4)); |
| assertEquals("date1.compareTo(date2), where date1 < date2, did not result in -1", |
| -1, d1.compareTo(d3)); |
| |
| try { |
| d1.compareTo(null); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#equals(java.lang.Object) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "equals", |
| args = {java.lang.Object.class} |
| ) |
| public void test_equalsLjava_lang_Object() { |
| // Test for method boolean java.util.Date.equals(java.lang.Object) |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| Date d3 = new Date(1900000); |
| assertTrue("Equality test failed", d2.equals(d3)); |
| assertTrue("Equality test failed", !d1.equals(d2)); |
| } |
| |
| /** |
| * @tests java.util.Date#getDate() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDate", |
| args = {} |
| ) |
| public void test_getDate() { |
| // Test for method int java.util.Date.getDate() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect date", 13, d.getDate()); |
| } |
| |
| /** |
| * @tests java.util.Date#getDay() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDay", |
| args = {} |
| ) |
| public void test_getDay() { |
| // Test for method int java.util.Date.getDay() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect day", 2, d.getDay()); |
| } |
| |
| /** |
| * @tests java.util.Date#getHours() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getHours", |
| args = {} |
| ) |
| public void test_getHours() { |
| // Test for method int java.util.Date.getHours() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect hours", 19, d.getHours()); |
| } |
| |
| /** |
| * @tests java.util.Date#getMinutes() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getMinutes", |
| args = {} |
| ) |
| public void test_getMinutes() { |
| // Test for method int java.util.Date.getMinutes() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect minutes", 9, d.getMinutes()); |
| } |
| |
| /** |
| * @tests java.util.Date#getMonth() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getMonth", |
| args = {} |
| ) |
| public void test_getMonth() { |
| // Test for method int java.util.Date.getMonth() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect month", 9, d.getMonth()); |
| } |
| |
| /** |
| * @tests java.util.Date#getSeconds() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSeconds", |
| args = {} |
| ) |
| public void test_getSeconds() { |
| // Test for method int java.util.Date.getSeconds() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect seconds", 0, d.getSeconds()); |
| } |
| |
| /** |
| * @tests java.util.Date#getTime() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTime", |
| args = {} |
| ) |
| public void test_getTime() { |
| // Test for method long java.util.Date.getTime() |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| assertEquals("Returned incorrect time", 1900000, d2.getTime()); |
| assertEquals("Returned incorrect time", 0, d1.getTime()); |
| } |
| |
| /** |
| * @tests java.util.Date#getTimezoneOffset() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getTimezoneOffset", |
| args = {} |
| ) |
| public void test_getTimezoneOffset() { |
| // Test for method int java.util.Date.getTimezoneOffset() |
| assertTrue("Used to test", true); |
| int offset = new Date(96, 1, 14).getTimezoneOffset(); |
| assertTrue(offset > -720 && offset < 720); |
| } |
| |
| /** |
| * @tests java.util.Date#getYear() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getYear", |
| args = {} |
| ) |
| public void test_getYear() { |
| // Test for method int java.util.Date.getYear() |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| assertEquals("Returned incorrect year", 98, d.getYear()); |
| } |
| |
| /** |
| * @tests java.util.Date#hashCode() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "hashCode", |
| args = {} |
| ) |
| public void test_hashCode() { |
| // Test for method int java.util.Date.hashCode() |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| assertEquals("Returned incorrect hash", 1900000, d2.hashCode()); |
| assertEquals("Returned incorrect hash", 0, d1.hashCode()); |
| } |
| |
| /** |
| * @tests java.util.Date#parse(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "parse", |
| args = {java.lang.String.class} |
| ) |
| public void test_parseLjava_lang_String() { |
| // Test for method long java.util.Date.parse(java.lang.String) |
| Date d = new Date(Date.parse("13 October 1998")); |
| GregorianCalendar cal = new GregorianCalendar(); |
| cal.setTime(d); |
| assertEquals("Parsed incorrect month", 9, cal.get(Calendar.MONTH)); |
| assertEquals("Parsed incorrect year", 1998, cal.get(Calendar.YEAR)); |
| assertEquals("Parsed incorrect date", 13, cal.get(Calendar.DATE)); |
| |
| d = new Date(Date.parse("Jan-12 1999")); |
| assertTrue("Wrong parsed date 1", d.equals(new GregorianCalendar(1999, |
| 0, 12).getTime())); |
| d = new Date(Date.parse("Jan12-1999")); |
| assertTrue("Wrong parsed date 2", d.equals(new GregorianCalendar(1999, |
| 0, 12).getTime())); |
| d = new Date(Date.parse("Jan12 69-1")); |
| cal.setTimeZone(TimeZone.getTimeZone("GMT")); |
| cal.clear(); |
| cal.set(1969, Calendar.JANUARY, 12, 1, 0); |
| assertTrue("Wrong parsed date 3", d.equals(cal.getTime())); |
| d = new Date(Date.parse("6:45:13 3/2/1200 MST")); |
| cal.setTimeZone(TimeZone.getTimeZone("MST")); |
| cal.clear(); |
| cal.set(1200, 2, 2, 6, 45, 13); |
| assertTrue("Wrong parsed date 4", d.equals(cal.getTime())); |
| d = new Date(Date.parse("Mon, 22 Nov 1999 12:52:06 GMT")); |
| cal.setTimeZone(TimeZone.getTimeZone("GMT")); |
| cal.clear(); |
| cal.set(1999, Calendar.NOVEMBER, 22, 12, 52, 06); |
| assertTrue("Wrong parsed date 5", d.equals(cal.getTime())); |
| |
| try { |
| // Regression for HARMONY-259 |
| Date.parse(null); |
| fail("Date.parse(null) should throw IllegalArgumentException"); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#setDate(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setDate", |
| args = {int.class} |
| ) |
| public void test_setDateI() { |
| // Test for method void java.util.Date.setDate(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setDate(23); |
| assertEquals("Set incorrect date", 23, d.getDate()); |
| } |
| |
| /** |
| * @tests java.util.Date#setHours(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setHours", |
| args = {int.class} |
| ) |
| public void test_setHoursI() { |
| // Test for method void java.util.Date.setHours(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setHours(23); |
| assertEquals("Set incorrect hours", 23, d.getHours()); |
| } |
| |
| /** |
| * @tests java.util.Date#setMinutes(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setMinutes", |
| args = {int.class} |
| ) |
| public void test_setMinutesI() { |
| // Test for method void java.util.Date.setMinutes(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setMinutes(45); |
| assertEquals("Set incorrect mins", 45, d.getMinutes()); |
| } |
| |
| /** |
| * @tests java.util.Date#setMonth(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setMonth", |
| args = {int.class} |
| ) |
| public void test_setMonthI() { |
| // Test for method void java.util.Date.setMonth(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setMonth(0); |
| assertEquals("Set incorrect month", 0, d.getMonth()); |
| } |
| |
| /** |
| * @tests java.util.Date#setSeconds(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setSeconds", |
| args = {int.class} |
| ) |
| public void test_setSecondsI() { |
| // Test for method void java.util.Date.setSeconds(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setSeconds(13); |
| assertEquals("Set incorrect seconds", 13, d.getSeconds()); |
| } |
| |
| /** |
| * @tests java.util.Date#setTime(long) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setTime", |
| args = {long.class} |
| ) |
| public void test_setTimeJ() { |
| // Test for method void java.util.Date.setTime(long) |
| Date d1 = new Date(0); |
| Date d2 = new Date(1900000); |
| d1.setTime(900); |
| d2.setTime(890000); |
| assertEquals("Returned incorrect time", 890000, d2.getTime()); |
| assertEquals("Returned incorrect time", 900, d1.getTime()); |
| } |
| |
| /** |
| * @tests java.util.Date#setYear(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setYear", |
| args = {int.class} |
| ) |
| public void test_setYearI() { |
| // Test for method void java.util.Date.setYear(int) |
| Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9) |
| .getTime(); |
| d.setYear(8); |
| assertEquals("Set incorrect year", 8, d.getYear()); |
| } |
| |
| /** |
| * @tests java.util.Date#toGMTString() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toGMTString", |
| args = {} |
| ) |
| public void test_toGMTString() { |
| // Test for method java.lang.String java.util.Date.toGMTString() |
| assertEquals("Did not convert epoch to GMT string correctly", "1 Jan 1970 00:00:00 GMT", new Date(0) |
| .toGMTString()); |
| assertEquals("Did not convert epoch + 1yr to GMT string correctly", |
| "1 Jan 1971 00:00:00 GMT", new Date((long) 365 * 24 * 60 * 60 * 1000).toGMTString() |
| ); |
| } |
| |
| /** |
| * @tests java.util.Date#toString() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toString", |
| args = {} |
| ) |
| public void test_toString() { |
| // Test for method java.lang.String java.util.Date.toString() |
| Calendar cal = Calendar.getInstance(); |
| cal.set(Calendar.DATE, 1); |
| cal.set(Calendar.MONTH, Calendar.JANUARY); |
| cal.set(Calendar.YEAR, 1970); |
| cal.set(Calendar.HOUR_OF_DAY, 0); |
| cal.set(Calendar.MINUTE, 0); |
| cal.set(Calendar.SECOND, 0); |
| Date d = cal.getTime(); |
| String result = d.toString(); |
| assertTrue("Incorrect result: " + d, result |
| .startsWith("Thu Jan 01 00:00:00") |
| && result.endsWith("1970")); |
| |
| TimeZone tz = TimeZone.getDefault(); |
| TimeZone.setDefault(TimeZone.getTimeZone("GMT-5")); |
| try { |
| Date d1 = new Date(0); |
| assertTrue("Returned incorrect string: " + d1, d1.toString() |
| .equals("Wed Dec 31 19:00:00 GMT-05:00 1969")); |
| } finally { |
| TimeZone.setDefault(tz); |
| } |
| } |
| |
| /** |
| * @tests java.util.Date#UTC(int, int, int, int, int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "UTC", |
| args = {int.class, int.class, int.class, int.class, int.class, int.class} |
| ) |
| public void test_UTCIIIIII() { |
| // Test for method long java.util.Date.UTC(int, int, int, int, int, int) |
| assertTrue("Returned incorrect UTC value for epoch", Date.UTC(70, 0, 1, |
| 0, 0, 0) == (long) 0); |
| assertTrue("Returned incorrect UTC value for epoch +1yr", Date.UTC(71, |
| 0, 1, 0, 0, 0) == (long) 365 * 24 * 60 * 60 * 1000); |
| } |
| /** |
| * @tests java.util.Date#toLocaleString() Test for method java.lang.String |
| * java.util.Date.toGMTString() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toLocaleString", |
| args = {} |
| ) |
| public void test_toLocaleString() { |
| Locale loc = Locale.getDefault(); |
| Locale.setDefault(Locale.US); |
| TimeZone tz = TimeZone.getDefault(); |
| TimeZone.setDefault(TimeZone.getTimeZone("GMT")); |
| try { |
| assertEquals("Did not convert epoch to GMT string correctly", "Jan 1, 1970 12:00:00 AM", |
| new Date(0).toLocaleString()); |
| assertEquals("Did not convert epoch + 1yr to GMT string correctly", |
| "Jan 1, 1971 12:00:00 AM", new Date((long)365 * 24 * 60 * 60 * 1000) |
| .toLocaleString()); |
| } finally { |
| Locale.setDefault(loc); |
| TimeZone.setDefault(tz); |
| } |
| } |
| |
| /** |
| * Sets up the fixture, for example, open a network connection. This method |
| * is called before a test is executed. |
| */ |
| protected void setUp() { |
| } |
| |
| /** |
| * Tears down the fixture, for example, close a network connection. This |
| * method is called after a test is executed. |
| */ |
| protected void tearDown() { |
| } |
| } |