protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(zone); java.util.TimeZone.setDefault(zone.toTimeZone()); Locale.setDefault(locale); zone = null; }
protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); zone = DateTimeZone.getDefault(); locale = Locale.getDefault(); DateTimeZone.setDefault(LONDON); java.util.TimeZone.setDefault(LONDON.toTimeZone()); Locale.setDefault(Locale.UK); }
protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); originalDateTimeZone = DateTimeZone.getDefault(); originalTimeZone = TimeZone.getDefault(); originalLocale = Locale.getDefault(); DateTimeZone.setDefault(PARIS); TimeZone.setDefault(PARIS.toTimeZone()); Locale.setDefault(Locale.FRANCE); }
protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); originalDateTimeZone = DateTimeZone.getDefault(); originalTimeZone = TimeZone.getDefault(); originalLocale = Locale.getDefault(); DateTimeZone.setDefault(LONDON); TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); Locale.setDefault(Locale.UK); }
/** * Set the time from another instant. The date part of this object will be unaffected. * * @param instant an instant to copy the time from, date part ignored * @throws IllegalArgumentException if the object is invalid */ public void setTime(final ReadableInstant instant) { long instantMillis = DateTimeUtils.getInstantMillis(instant); Chronology instantChrono = DateTimeUtils.getInstantChronology(instant); DateTimeZone zone = instantChrono.getZone(); if (zone != null) { instantMillis = zone.getMillisKeepLocal(DateTimeZone.UTC, instantMillis); } setTime(instantMillis); }
/** * Sets the time zone of the datetime, changing the chronology and millisecond. * * <p>Changing the zone using this method retains the field values. The millisecond instant is * adjusted in the new zone to compensate. * * <p>If the chronology already has this time zone, no change occurs. * * @param newZone the time zone to use, null means default zone * @see #setZone */ public void setZoneRetainFields(DateTimeZone newZone) { newZone = DateTimeUtils.getZone(newZone); DateTimeZone originalZone = DateTimeUtils.getZone(getZone()); if (newZone == originalZone) { return; } long millis = originalZone.getMillisKeepLocal(newZone, getMillis()); setChronology(getChronology().withZone(newZone)); // set via this class not super setMillis(millis); }
/** * Set the date from another instant. The time part of this object will be unaffected. * * <p>If the input is a {@code ReadableDateTime} then it is converted to the same time-zone as * this object before using the instant millis. * * @param instant an instant to copy the date from, time part ignored * @throws IllegalArgumentException if the object is invalid */ public void setDate(final ReadableInstant instant) { long instantMillis = DateTimeUtils.getInstantMillis(instant); if (instant instanceof ReadableDateTime) { ReadableDateTime rdt = (ReadableDateTime) instant; Chronology instantChrono = DateTimeUtils.getChronology(rdt.getChronology()); DateTimeZone zone = instantChrono.getZone(); if (zone != null) { instantMillis = zone.getMillisKeepLocal(getZone(), instantMillis); } } setDate(instantMillis); }
public void setTimeZone(Env env, DateTimeZone dateTimeZone) { _dateTimeZone = dateTimeZone; long time = _qDate.getGMTTime(); _qDate = new QDate(dateTimeZone.getTimeZone(), env.getCurrentTime()); _qDate.setGMTTime(time); }
protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(originalDateTimeZone); TimeZone.setDefault(originalTimeZone); Locale.setDefault(originalLocale); originalDateTimeZone = null; originalTimeZone = null; originalLocale = null; }
protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(zone); zone = null; }
protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); zone = DateTimeZone.getDefault(); DateTimeZone.setDefault(LONDON); }
/** * This class is a Junit unit test for LocalDate. * * @author Stephen Colebourne */ public class TestLocalDate_Constructors extends TestCase { private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC(); private static final Chronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC(); private static final Chronology GREGORIAN_UTC = GregorianChronology.getInstanceUTC(); private static final Chronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS); private long TEST_TIME_NOW = (31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY; private long TEST_TIME1 = (31L + 28L + 31L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 12L * DateTimeConstants.MILLIS_PER_HOUR + 24L * DateTimeConstants.MILLIS_PER_MINUTE; private long TEST_TIME1_ROUNDED = (31L + 28L + 31L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY; private long TEST_TIME2 = (365L + 31L + 28L + 31L + 30L + 7L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 14L * DateTimeConstants.MILLIS_PER_HOUR + 28L * DateTimeConstants.MILLIS_PER_MINUTE; private DateTimeZone zone = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestLocalDate_Constructors.class); } public TestLocalDate_Constructors(String name) { super(name); } protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); zone = DateTimeZone.getDefault(); DateTimeZone.setDefault(LONDON); } protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(zone); zone = null; } // ----------------------------------------------------------------------- public void testParse_noFormatter() throws Throwable { assertEquals(new LocalDate(2010, 6, 30), LocalDate.parse("2010-06-30")); assertEquals(new LocalDate(2010, 1, 2), LocalDate.parse("2010-002")); } public void testParse_formatter() throws Throwable { DateTimeFormatter f = DateTimeFormat.forPattern("yyyy--dd MM").withChronology(ISOChronology.getInstance(PARIS)); assertEquals(new LocalDate(2010, 6, 30), LocalDate.parse("2010--30 06", f)); } // ----------------------------------------------------------------------- public void testFactory_FromCalendarFields() throws Exception { GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6); cal.set(Calendar.MILLISECOND, 7); LocalDate expected = new LocalDate(1970, 2, 3); assertEquals(expected, LocalDate.fromCalendarFields(cal)); try { LocalDate.fromCalendarFields((Calendar) null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testFactory_FromDateFields() throws Exception { GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6); cal.set(Calendar.MILLISECOND, 7); LocalDate expected = new LocalDate(1970, 2, 3); assertEquals(expected, LocalDate.fromDateFields(cal.getTime())); try { LocalDate.fromDateFields((Date) null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor() throws Throwable { LocalDate test = new LocalDate(); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); assertEquals(test, LocalDate.now()); } public void testConstructor_DateTimeZone() throws Throwable { DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON); DateTimeUtils.setCurrentMillisFixed(dt.getMillis()); // 23:59 in London is 00:59 the following day in Paris LocalDate test = new LocalDate(LONDON); assertEquals(ISO_UTC, test.getChronology()); assertEquals(2005, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(8, test.getDayOfMonth()); assertEquals(test, LocalDate.now(LONDON)); test = new LocalDate(PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(2005, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); assertEquals(test, LocalDate.now(PARIS)); } public void testConstructor_nullDateTimeZone() throws Throwable { DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON); DateTimeUtils.setCurrentMillisFixed(dt.getMillis()); // 23:59 in London is 00:59 the following day in Paris LocalDate test = new LocalDate((DateTimeZone) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(2005, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(8, test.getDayOfMonth()); } public void testConstructor_Chronology() throws Throwable { LocalDate test = new LocalDate(GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); assertEquals(test, LocalDate.now(GREGORIAN_PARIS)); } public void testConstructor_nullChronology() throws Throwable { LocalDate test = new LocalDate((Chronology) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } // ----------------------------------------------------------------------- public void testConstructor_long1() throws Throwable { LocalDate test = new LocalDate(TEST_TIME1); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_long2() throws Throwable { LocalDate test = new LocalDate(TEST_TIME2); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1971, test.getYear()); assertEquals(5, test.getMonthOfYear()); assertEquals(7, test.getDayOfMonth()); } public void testConstructor_long1_DateTimeZone() throws Throwable { LocalDate test = new LocalDate(TEST_TIME1, PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); assertEquals(TEST_TIME1_ROUNDED, test.getLocalMillis()); } public void testConstructor_long2_DateTimeZone() throws Throwable { LocalDate test = new LocalDate(TEST_TIME2, PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1971, test.getYear()); assertEquals(5, test.getMonthOfYear()); assertEquals(7, test.getDayOfMonth()); } public void testConstructor_long3_DateTimeZone() throws Throwable { DateTime dt = new DateTime(2006, 6, 9, 0, 0, 0, 0, PARIS); DateTime dtUTC = new DateTime(2006, 6, 9, 0, 0, 0, 0, DateTimeZone.UTC); LocalDate test = new LocalDate(dt.getMillis(), PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(2006, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); assertEquals(dtUTC.getMillis(), test.getLocalMillis()); } public void testConstructor_long4_DateTimeZone() throws Throwable { DateTime dt = new DateTime(2006, 6, 9, 23, 59, 59, 999, PARIS); DateTime dtUTC = new DateTime(2006, 6, 9, 0, 0, 0, 0, DateTimeZone.UTC); LocalDate test = new LocalDate(dt.getMillis(), PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(2006, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); assertEquals(dtUTC.getMillis(), test.getLocalMillis()); } public void testConstructor_long_nullDateTimeZone() throws Throwable { LocalDate test = new LocalDate(TEST_TIME1, (DateTimeZone) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_long1_Chronology() throws Throwable { LocalDate test = new LocalDate(TEST_TIME1, GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_long2_Chronology() throws Throwable { LocalDate test = new LocalDate(TEST_TIME2, GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1971, test.getYear()); assertEquals(5, test.getMonthOfYear()); assertEquals(7, test.getDayOfMonth()); } public void testConstructor_long_nullChronology() throws Throwable { LocalDate test = new LocalDate(TEST_TIME1, (Chronology) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } // ----------------------------------------------------------------------- public void testConstructor_Object1() throws Throwable { Date date = new Date(TEST_TIME1); LocalDate test = new LocalDate(date); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_nullObject() throws Throwable { LocalDate test = new LocalDate((Object) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } public void testConstructor_ObjectString1() throws Throwable { LocalDate test = new LocalDate("1972-04-06"); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1972, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_ObjectString2() throws Throwable { LocalDate test = new LocalDate("1972-037"); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1972, test.getYear()); assertEquals(2, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_ObjectString3() throws Throwable { LocalDate test = new LocalDate("1972-02"); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1972, test.getYear()); assertEquals(2, test.getMonthOfYear()); assertEquals(1, test.getDayOfMonth()); } public void testConstructor_ObjectStringEx1() throws Throwable { try { new LocalDate("1970-04-06T+14:00"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx2() throws Throwable { try { new LocalDate("1970-04-06T10:20:30.040"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx3() throws Throwable { try { new LocalDate("1970-04-06T10:20:30.040+14:00"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx4() throws Throwable { try { new LocalDate("T10:20:30.040"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx5() throws Throwable { try { new LocalDate("T10:20:30.040+14:00"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx6() throws Throwable { try { new LocalDate("10:20:30.040"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectStringEx7() throws Throwable { try { new LocalDate("10:20:30.040+14:00"); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectLocalDate() throws Throwable { LocalDate date = new LocalDate(1970, 4, 6, BUDDHIST_UTC); LocalDate test = new LocalDate(date); assertEquals(BUDDHIST_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_ObjectLocalTime() throws Throwable { LocalTime time = new LocalTime(10, 20, 30, 40, BUDDHIST_UTC); try { new LocalDate(time); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_ObjectLocalDateTime() throws Throwable { LocalDateTime dt = new LocalDateTime(1970, 5, 6, 10, 20, 30, 40, BUDDHIST_UTC); LocalDate test = new LocalDate(dt); assertEquals(BUDDHIST_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(5, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_ObjectYearMonthDay() throws Throwable { YearMonthDay date = new YearMonthDay(1970, 4, 6, BUDDHIST_UTC); LocalDate test = new LocalDate(date); assertEquals(BUDDHIST_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } // ----------------------------------------------------------------------- public void testConstructor_Object_DateTimeZone() throws Throwable { Date date = new Date(TEST_TIME1); LocalDate test = new LocalDate(date, PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_nullObject_DateTimeZone() throws Throwable { LocalDate test = new LocalDate((Object) null, PARIS); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } public void testConstructor_Object_nullDateTimeZone() throws Throwable { Date date = new Date(TEST_TIME1); LocalDate test = new LocalDate(date, (DateTimeZone) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_nullObject_nullDateTimeZone() throws Throwable { LocalDate test = new LocalDate((Object) null, (DateTimeZone) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } public void testConstructor_Object_Chronology() throws Throwable { Date date = new Date(TEST_TIME1); LocalDate test = new LocalDate(date, GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_nullObject_Chronology() throws Throwable { LocalDate test = new LocalDate((Object) null, GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } public void testConstructor_Object_nullChronology() throws Throwable { Date date = new Date(TEST_TIME1); LocalDate test = new LocalDate(date, (Chronology) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(4, test.getMonthOfYear()); assertEquals(6, test.getDayOfMonth()); } public void testConstructor_nullObject_nullChronology() throws Throwable { LocalDate test = new LocalDate((Object) null, (Chronology) null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } // ----------------------------------------------------------------------- public void testConstructor_int_int_int() throws Throwable { LocalDate test = new LocalDate(1970, 6, 9); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); try { new LocalDate(Integer.MIN_VALUE, 6, 9); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(Integer.MAX_VALUE, 6, 9); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 0, 9); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 13, 9); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 6, 0); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 6, 31); fail(); } catch (IllegalArgumentException ex) { } new LocalDate(1970, 7, 31); try { new LocalDate(1970, 7, 32); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_int_int_int_Chronology() throws Throwable { LocalDate test = new LocalDate(1970, 6, 9, GREGORIAN_PARIS); assertEquals(GREGORIAN_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); try { new LocalDate(Integer.MIN_VALUE, 6, 9, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(Integer.MAX_VALUE, 6, 9, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 0, 9, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 13, 9, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 6, 0, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } try { new LocalDate(1970, 6, 31, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } new LocalDate(1970, 7, 31, GREGORIAN_PARIS); try { new LocalDate(1970, 7, 32, GREGORIAN_PARIS); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_int_int_int_nullChronology() throws Throwable { LocalDate test = new LocalDate(1970, 6, 9, null); assertEquals(ISO_UTC, test.getChronology()); assertEquals(1970, test.getYear()); assertEquals(6, test.getMonthOfYear()); assertEquals(9, test.getDayOfMonth()); } }
/** * This class is a Junit unit test for Instant. * * @author Stephen Colebourne */ public class TestMutableInterval_Updates extends GWTTestCase { @Override public String getModuleName() { return "org.goda.Goda"; } // Test in 2002/03 as time zones are more well known // (before the late 90's they were all over the place) private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365; long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365; // 2002-06-09 private long TEST_TIME_NOW = (y2002days + 31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY; // 2002-04-05 private long TEST_TIME1 = (y2002days + 31L + 28L + 31L + 5L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 12L * DateTimeConstants.MILLIS_PER_HOUR + 24L * DateTimeConstants.MILLIS_PER_MINUTE; // 2003-05-06 private long TEST_TIME2 = (y2003days + 31L + 28L + 31L + 30L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 14L * DateTimeConstants.MILLIS_PER_HOUR + 28L * DateTimeConstants.MILLIS_PER_MINUTE; private DateTimeZone originalDateTimeZone = null; private TimeZone originalTimeZone = null; private Locale originalLocale = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestMutableInterval_Updates.class); } @Override protected void gwtSetUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); originalDateTimeZone = DateTimeZone.getDefault(); originalTimeZone = TimeZone.getDefault(); originalLocale = Locale.getDefault(); DateTimeZone.setDefault(LONDON); TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); Locale.setDefault(Locale.UK); } @Override protected void gwtTearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(originalDateTimeZone); TimeZone.setDefault(originalTimeZone); Locale.setDefault(originalLocale); originalDateTimeZone = null; originalTimeZone = null; originalLocale = null; } // ----------------------------------------------------------------------- public void testTest() { assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString()); assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString()); assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString()); } // ----------------------------------------------------------------------- public void testSetInterval_long_long1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(TEST_TIME1 - 1, TEST_TIME2 + 1); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetInterval_long_long2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setInterval(TEST_TIME1 - 1, TEST_TIME1 - 2); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetInterval_RI_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(new Instant(TEST_TIME1 - 1), new Instant(TEST_TIME2 + 1)); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetInterval_RI_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setInterval(new Instant(TEST_TIME1 - 1), new Instant(TEST_TIME1 - 2)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetInterval_RI_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(null, new Instant(TEST_TIME2 + 1)); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetInterval_RI_RI4() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(new Instant(TEST_TIME1 - 1), null); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testSetInterval_RI_RI5() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(null, null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetInterval_RInterval1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setInterval(new Interval(TEST_TIME1 - 1, TEST_TIME2 + 1)); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetInterval_RInterval2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setInterval(new MockBadInterval()); fail(); } catch (IllegalArgumentException ex) { } } class MockBadInterval extends AbstractInterval { public Chronology getChronology() { return ISOChronology.getInstance(); } public long getStartMillis() { return TEST_TIME1 - 1; } public long getEndMillis() { return TEST_TIME1 - 2; } } public void testSetInterval_RInterval3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setInterval(null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetStartMillis_long1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setStartMillis(TEST_TIME1 - 1); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } public void testSetStartMillis_long2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setStartMillis(TEST_TIME2 + 1); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetStart_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setStart(new Instant(TEST_TIME1 - 1)); assertEquals(TEST_TIME1 - 1, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } public void testSetStart_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setStart(new Instant(TEST_TIME2 + 1)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetStart_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setStart(null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetEndMillis_long1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setEndMillis(TEST_TIME2 + 1); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetEndMillis_long2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setEndMillis(TEST_TIME1 - 1); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetEnd_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setEnd(new Instant(TEST_TIME2 + 1)); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME2 + 1, test.getEndMillis()); } public void testSetEnd_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setEnd(new Instant(TEST_TIME1 - 1)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetEnd_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setEnd(null); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetDurationAfterStart_long1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationAfterStart(123L); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1 + 123L, test.getEndMillis()); } public void testSeDurationAfterStart_long2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setDurationAfterStart(-1); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetDurationAfterStart_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationAfterStart(new Duration(123L)); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1 + 123L, test.getEndMillis()); } public void testSeDurationAfterStart_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setDurationAfterStart(new Duration(-1)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetDurationAfterStart_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationAfterStart(null); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetDurationBeforeEnd_long1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationBeforeEnd(123L); assertEquals(TEST_TIME2 - 123L, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } public void testSeDurationBeforeEnd_long2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setDurationBeforeEnd(-1); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSetDurationBeforeEnd_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationBeforeEnd(new Duration(123L)); assertEquals(TEST_TIME2 - 123L, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } public void testSeDurationBeforeEnd_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setDurationBeforeEnd(new Duration(-1)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetDurationBeforeEnd_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setDurationBeforeEnd(null); assertEquals(TEST_TIME2, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetPeriodAfterStart_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setPeriodAfterStart(new Period(123L)); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1 + 123L, test.getEndMillis()); } public void testSePeriodAfterStart_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setPeriodAfterStart(new Period(-1L)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetPeriodAfterStart_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setPeriodAfterStart(null); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1, test.getEndMillis()); } // ----------------------------------------------------------------------- public void testSetPeriodBeforeEnd_RI1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setPeriodBeforeEnd(new Period(123L)); assertEquals(TEST_TIME2 - 123L, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } public void testSePeriodBeforeEnd_RI2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); try { test.setPeriodBeforeEnd(new Period(-1L)); fail(); } catch (IllegalArgumentException ex) { } } public void testSetPeriodBeforeEnd_RI3() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); test.setPeriodBeforeEnd(null); assertEquals(TEST_TIME2, test.getStartMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); } }
/** * This class is a Junit unit test for Instant. * * @author Stephen Colebourne */ public class TestInstant_Constructors extends TestCase { private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); // 1970-06-09 private long TEST_TIME_NOW = (31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY; // 1970-04-05 private long TEST_TIME1 = (31L + 28L + 31L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 12L * DateTimeConstants.MILLIS_PER_HOUR + 24L * DateTimeConstants.MILLIS_PER_MINUTE; // 1971-05-06 private long TEST_TIME2 = (365L + 31L + 28L + 31L + 30L + 7L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 14L * DateTimeConstants.MILLIS_PER_HOUR + 28L * DateTimeConstants.MILLIS_PER_MINUTE; private DateTimeZone zone = null; private Locale locale = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestInstant_Constructors.class); } public TestInstant_Constructors(String name) { super(name); } protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); zone = DateTimeZone.getDefault(); locale = Locale.getDefault(); DateTimeZone.setDefault(LONDON); java.util.TimeZone.setDefault(LONDON.toTimeZone()); Locale.setDefault(Locale.UK); } protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(zone); java.util.TimeZone.setDefault(zone.toTimeZone()); Locale.setDefault(locale); zone = null; } // ----------------------------------------------------------------------- /** Test now () */ public void test_now() throws Throwable { Instant test = Instant.now(); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME_NOW, test.getMillis()); } // ----------------------------------------------------------------------- public void testParse_noFormatter() throws Throwable { assertEquals( new DateTime(2010, 6, 30, 0, 20, ISOChronology.getInstance(LONDON)).toInstant(), Instant.parse("2010-06-30T01:20+02:00")); assertEquals( new DateTime(2010, 1, 2, 14, 50, ISOChronology.getInstance(LONDON)).toInstant(), Instant.parse("2010-002T14:50")); } public void testParse_formatter() throws Throwable { DateTimeFormatter f = DateTimeFormat.forPattern("yyyy--dd MM HH") .withChronology(ISOChronology.getInstance(PARIS)); assertEquals( new DateTime(2010, 6, 30, 13, 0, ISOChronology.getInstance(PARIS)).toInstant(), Instant.parse("2010--30 06 13", f)); } // ----------------------------------------------------------------------- /** Test constructor () */ public void testConstructor() throws Throwable { Instant test = new Instant(); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME_NOW, test.getMillis()); } // ----------------------------------------------------------------------- /** Test constructor (long) */ public void testConstructor_long1() throws Throwable { Instant test = new Instant(TEST_TIME1); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME1, test.getMillis()); } /** Test constructor (long) */ public void testConstructor_long2() throws Throwable { Instant test = new Instant(TEST_TIME2); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME2, test.getMillis()); } // ----------------------------------------------------------------------- /** Test constructor (Object) */ public void testConstructor_Object() throws Throwable { Date date = new Date(TEST_TIME1); Instant test = new Instant(date); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME1, test.getMillis()); } /** Test constructor (Object) */ public void testConstructor_invalidObject() throws Throwable { try { new Instant(new Object()); fail(); } catch (IllegalArgumentException ex) { } } /** Test constructor (Object=null) */ public void testConstructor_nullObject() throws Throwable { Instant test = new Instant((Object) null); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(TEST_TIME_NOW, test.getMillis()); } /** Test constructor (Object=null) */ public void testConstructor_badconverterObject() throws Throwable { try { ConverterManager.getInstance().addInstantConverter(MockZeroNullIntegerConverter.INSTANCE); Instant test = new Instant(new Integer(0)); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); assertEquals(0L, test.getMillis()); } finally { ConverterManager.getInstance().removeInstantConverter(MockZeroNullIntegerConverter.INSTANCE); } } }
protected DateTime(Env env, String timeString, DateTimeZone dateTimeZone) { _qDate = new QDate(dateTimeZone.getTimeZone(), env.getCurrentTime()); _dateTimeZone = dateTimeZone; init(env, timeString); }
/** * This class is a JUnit test for Interval. * * @author Stephen Colebourne */ public class TestInterval_Constructors extends TestCase { // Test in 2002/03 as time zones are more well known // (before the late 90's they were all over the place) private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); private static final DateTimeZone OFFSET_04_00 = DateTimeZone.forOffsetHours(4); long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365; long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365; // 2002-06-09 private long TEST_TIME_NOW = (y2002days + 31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY; // // 2002-04-05 // private long TEST_TIME1 = // (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY // + 12L * DateTimeConstants.MILLIS_PER_HOUR // + 24L * DateTimeConstants.MILLIS_PER_MINUTE; // // // 2003-05-06 // private long TEST_TIME2 = // (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY // + 14L * DateTimeConstants.MILLIS_PER_HOUR // + 28L * DateTimeConstants.MILLIS_PER_MINUTE; private DateTimeZone originalDateTimeZone = null; private TimeZone originalTimeZone = null; private Locale originalLocale = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestInterval_Constructors.class); } public TestInterval_Constructors(String name) { super(name); } protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); originalDateTimeZone = DateTimeZone.getDefault(); originalTimeZone = TimeZone.getDefault(); originalLocale = Locale.getDefault(); DateTimeZone.setDefault(PARIS); TimeZone.setDefault(PARIS.toTimeZone()); Locale.setDefault(Locale.FRANCE); } protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(originalDateTimeZone); TimeZone.setDefault(originalTimeZone); Locale.setDefault(originalLocale); originalDateTimeZone = null; originalTimeZone = null; originalLocale = null; } // ----------------------------------------------------------------------- public void testParse_noOffsetInString() throws Throwable { DateTime start = new DateTime(2010, 6, 30, 12, 30, ISOChronology.getInstance(PARIS)); DateTime end = new DateTime(2010, 7, 1, 14, 30, ISOChronology.getInstance(PARIS)); assertEquals(new Interval(start, end), Interval.parse("2010-06-30T12:30/2010-07-01T14:30")); assertEquals(new Interval(start, end), Interval.parse("2010-06-30T12:30/P1DT2H")); assertEquals(new Interval(start, end), Interval.parse("P1DT2H/2010-07-01T14:30")); } public void testParse_offsetInString() throws Throwable { DateTime start = new DateTime(2010, 6, 30, 10, 30, ISOChronology.getInstance(PARIS)); DateTime end = new DateTime(2010, 7, 1, 12, 30, ISOChronology.getInstance(PARIS)); assertEquals( new Interval(start, end), Interval.parse("2010-06-30T12:30+04:00/2010-07-01T14:30+04:00")); assertEquals(new Interval(start, end), Interval.parse("2010-06-30T12:30+04:00/P1DT2H")); assertEquals(new Interval(start, end), Interval.parse("P1DT2H/2010-07-01T14:30+04:00")); } public void testParseWithOffset_noOffsetInString() throws Throwable { DateTime start = new DateTime(2010, 6, 30, 12, 30, ISOChronology.getInstance(PARIS)); DateTime end = new DateTime(2010, 7, 1, 14, 30, ISOChronology.getInstance(PARIS)); assertEquals( new Interval(start, end), Interval.parseWithOffset("2010-06-30T12:30/2010-07-01T14:30")); assertEquals(new Interval(start, end), Interval.parseWithOffset("2010-06-30T12:30/P1DT2H")); assertEquals(new Interval(start, end), Interval.parseWithOffset("P1DT2H/2010-07-01T14:30")); } public void testParseWithOffset_offsetInString() throws Throwable { DateTime start = new DateTime(2010, 6, 30, 12, 30, ISOChronology.getInstance(OFFSET_04_00)); DateTime end = new DateTime(2010, 7, 1, 14, 30, ISOChronology.getInstance(OFFSET_04_00)); assertEquals( new Interval(start, end), Interval.parseWithOffset("2010-06-30T12:30+04:00/2010-07-01T14:30+04:00")); assertEquals( new Interval(start, end), Interval.parseWithOffset("2010-06-30T12:30+04:00/p1DT2H")); assertEquals( new Interval(start, end), Interval.parseWithOffset("p1DT2H/2010-07-01T14:30+04:00")); } public void testParseWithOffset_invalid() throws Throwable { try { Interval.parseWithOffset("2010-06-30T12:30"); fail(); } catch (IllegalArgumentException ex) { // expected } try { Interval.parseWithOffset("P1D/P1D"); fail(); } catch (IllegalArgumentException ex) { // expected } } // ----------------------------------------------------------------------- public void testConstructor_long_long1() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.getMillis(), dt2.getMillis()); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } public void testConstructor_long_long2() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); Interval test = new Interval(dt1.getMillis(), dt1.getMillis()); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt1.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } public void testConstructor_long_long3() throws Throwable { DateTime dt1 = new DateTime(2005, 7, 10, 1, 1, 1, 1); DateTime dt2 = new DateTime(2004, 6, 9, 0, 0, 0, 0); try { new Interval(dt1.getMillis(), dt2.getMillis()); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor_long_long_Zone() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.getMillis(), dt2.getMillis(), LONDON); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(LONDON), test.getChronology()); } public void testConstructor_long_long_nullZone() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.getMillis(), dt2.getMillis(), (DateTimeZone) null); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } // ----------------------------------------------------------------------- public void testConstructor_long_long_Chronology() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.getMillis(), dt2.getMillis(), GJChronology.getInstance()); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(GJChronology.getInstance(), test.getChronology()); } public void testConstructor_long_long_nullChronology() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.getMillis(), dt2.getMillis(), (Chronology) null); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } // ----------------------------------------------------------------------- public void testConstructor_RI_RI1() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1, dt2); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RI2() throws Throwable { Instant dt1 = new Instant(new DateTime(2004, 6, 9, 0, 0, 0, 0)); Instant dt2 = new Instant(new DateTime(2005, 7, 10, 1, 1, 1, 1)); Interval test = new Interval(dt1, dt2); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RI3() throws Throwable { Interval test = new Interval((ReadableInstant) null, (ReadableInstant) null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RI_RI4() throws Throwable { DateTime dt1 = new DateTime(2000, 6, 9, 0, 0, 0, 0); Interval test = new Interval(dt1, (ReadableInstant) null); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RI_RI5() throws Throwable { DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval((ReadableInstant) null, dt2); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RI6() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); Interval test = new Interval(dt1, dt1); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt1.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RI7() throws Throwable { DateTime dt1 = new DateTime(2005, 7, 10, 1, 1, 1, 1); DateTime dt2 = new DateTime(2004, 6, 9, 0, 0, 0, 0); try { new Interval(dt1, dt2); fail(); } catch (IllegalArgumentException ex) { } } public void testConstructor_RI_RI_chronoStart() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, GJChronology.getInstance()); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1, dt2); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(GJChronology.getInstance(), test.getChronology()); } public void testConstructor_RI_RI_chronoEnd() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, GJChronology.getInstance()); Interval test = new Interval(dt1, dt2); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } public void testConstructor_RI_RI_zones() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, LONDON); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, PARIS); Interval test = new Interval(dt1, dt2); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(LONDON), test.getChronology()); } public void testConstructor_RI_RI_instant() throws Throwable { Instant dt1 = new Instant(12345678L); Instant dt2 = new Instant(22345678L); Interval test = new Interval(dt1, dt2); assertEquals(12345678L, test.getStartMillis()); assertEquals(22345678L, test.getEndMillis()); assertEquals(ISOChronology.getInstanceUTC(), test.getChronology()); } // ----------------------------------------------------------------------- public void testConstructor_RI_RP1() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().months().add(result, 6); result = ISOChronology.getInstance().hours().add(result, 1); Interval test = new Interval(dt, dur); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RP2() throws Throwable { Instant dt = new Instant(new DateTime(TEST_TIME_NOW)); Period dur = new Period(0, 6, 0, 3, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstanceUTC().months().add(result, 6); result = ISOChronology.getInstanceUTC().days().add(result, 3); result = ISOChronology.getInstanceUTC().hours().add(result, 1); Interval test = new Interval(dt, dur); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RP3() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW, CopticChronology.getInstanceUTC()); Period dur = new Period(0, 6, 0, 3, 1, 0, 0, 0, PeriodType.standard()); long result = TEST_TIME_NOW; result = CopticChronology.getInstanceUTC().months().add(result, 6); result = CopticChronology.getInstanceUTC().days().add(result, 3); result = CopticChronology.getInstanceUTC().hours().add(result, 1); Interval test = new Interval(dt, dur); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RP4() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(1 * DateTimeConstants.MILLIS_PER_HOUR + 23L); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().hours().add(result, 1); result = ISOChronology.getInstance().millis().add(result, 23); Interval test = new Interval(dt, dur); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RP5() throws Throwable { Interval test = new Interval((ReadableInstant) null, (ReadablePeriod) null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RI_RP6() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Interval test = new Interval(dt, (ReadablePeriod) null); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RP7() throws Throwable { Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().monthOfYear().add(result, 6); result = ISOChronology.getInstance().hourOfDay().add(result, 1); Interval test = new Interval((ReadableInstant) null, dur); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RP8() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(0, 0, 0, 0, 0, 0, 0, -1); try { new Interval(dt, dur); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor_RP_RI1() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().months().add(result, -6); result = ISOChronology.getInstance().hours().add(result, -1); Interval test = new Interval(dur, dt); assertEquals(result, test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RP_RI2() throws Throwable { Instant dt = new Instant(new DateTime(TEST_TIME_NOW)); Period dur = new Period(0, 6, 0, 3, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstanceUTC().months().add(result, -6); result = ISOChronology.getInstanceUTC().days().add(result, -3); result = ISOChronology.getInstanceUTC().hours().add(result, -1); Interval test = new Interval(dur, dt); assertEquals(result, test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RP_RI3() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW, CopticChronology.getInstanceUTC()); Period dur = new Period(0, 6, 0, 3, 1, 0, 0, 0, PeriodType.standard()); long result = TEST_TIME_NOW; result = CopticChronology.getInstanceUTC().months().add(result, -6); result = CopticChronology.getInstanceUTC().days().add(result, -3); result = CopticChronology.getInstanceUTC().hours().add(result, -1); Interval test = new Interval(dur, dt); assertEquals(result, test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RP_RI4() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(1 * DateTimeConstants.MILLIS_PER_HOUR + 23L); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().hours().add(result, -1); result = ISOChronology.getInstance().millis().add(result, -23); Interval test = new Interval(dur, dt); assertEquals(result, test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RP_RI5() throws Throwable { Interval test = new Interval((ReadablePeriod) null, (ReadableInstant) null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RP_RI6() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Interval test = new Interval((ReadablePeriod) null, dt); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RP_RI7() throws Throwable { Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0); long result = TEST_TIME_NOW; result = ISOChronology.getInstance().monthOfYear().add(result, -6); result = ISOChronology.getInstance().hourOfDay().add(result, -1); Interval test = new Interval(dur, (ReadableInstant) null); assertEquals(result, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RP_RI8() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Period dur = new Period(0, 0, 0, 0, 0, 0, 0, -1); try { new Interval(dur, dt); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor_RI_RD1() throws Throwable { long result = TEST_TIME_NOW; result = ISOChronology.getInstance().months().add(result, 6); result = ISOChronology.getInstance().hours().add(result, 1); DateTime dt = new DateTime(TEST_TIME_NOW); Duration dur = new Duration(result - TEST_TIME_NOW); Interval test = new Interval(dt, dur); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RD2() throws Throwable { Interval test = new Interval((ReadableInstant) null, (ReadableDuration) null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RI_RD3() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Interval test = new Interval(dt, (ReadableDuration) null); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RI_RD4() throws Throwable { long result = TEST_TIME_NOW; result = ISOChronology.getInstance().monthOfYear().add(result, 6); result = ISOChronology.getInstance().hourOfDay().add(result, 1); Duration dur = new Duration(result - TEST_TIME_NOW); Interval test = new Interval((ReadableInstant) null, dur); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(result, test.getEndMillis()); } public void testConstructor_RI_RD5() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Duration dur = new Duration(-1); try { new Interval(dt, dur); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor_RD_RI1() throws Throwable { long result = TEST_TIME_NOW; result = ISOChronology.getInstance().months().add(result, -6); result = ISOChronology.getInstance().hours().add(result, -1); DateTime dt = new DateTime(TEST_TIME_NOW); Duration dur = new Duration(TEST_TIME_NOW - result); Interval test = new Interval(dur, dt); assertEquals(result, test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RD_RI2() throws Throwable { Interval test = new Interval((ReadableDuration) null, (ReadableInstant) null); assertEquals(TEST_TIME_NOW, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RD_RI3() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Interval test = new Interval((ReadableDuration) null, dt); assertEquals(dt.getMillis(), test.getStartMillis()); assertEquals(dt.getMillis(), test.getEndMillis()); } public void testConstructor_RD_RI4() throws Throwable { long result = TEST_TIME_NOW; result = ISOChronology.getInstance().monthOfYear().add(result, -6); result = ISOChronology.getInstance().hourOfDay().add(result, -1); Duration dur = new Duration(TEST_TIME_NOW - result); Interval test = new Interval(dur, (ReadableInstant) null); assertEquals(result, test.getStartMillis()); assertEquals(TEST_TIME_NOW, test.getEndMillis()); } public void testConstructor_RD_RI5() throws Throwable { DateTime dt = new DateTime(TEST_TIME_NOW); Duration dur = new Duration(-1); try { new Interval(dur, dt); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testConstructor_Object1() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.toString() + '/' + dt2.toString()); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_Object2() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval base = new Interval(dt1, dt2); Interval test = new Interval(base); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_Object3() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); MutableInterval base = new MutableInterval(dt1, dt2); Interval test = new Interval(base); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); } public void testConstructor_Object4() throws Throwable { MockInterval base = new MockInterval(); Interval test = new Interval(base); assertEquals(base.getStartMillis(), test.getStartMillis()); assertEquals(base.getEndMillis(), test.getEndMillis()); } public void testConstructor_Object5() throws Throwable { IntervalConverter oldConv = ConverterManager.getInstance().getIntervalConverter(""); IntervalConverter conv = new IntervalConverter() { public boolean isReadableInterval(Object object, Chronology chrono) { return false; } public void setInto(ReadWritableInterval interval, Object object, Chronology chrono) { interval.setChronology(chrono); interval.setInterval(1234L, 5678L); } public Class<?> getSupportedType() { return String.class; } }; try { ConverterManager.getInstance().addIntervalConverter(conv); DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval test = new Interval(dt1.toString() + '/' + dt2.toString()); assertEquals(1234L, test.getStartMillis()); assertEquals(5678L, test.getEndMillis()); } finally { ConverterManager.getInstance().addIntervalConverter(oldConv); } } public void testConstructor_Object6() throws Throwable { IntervalConverter oldConv = ConverterManager.getInstance().getIntervalConverter(new Interval(0L, 0L)); IntervalConverter conv = new IntervalConverter() { public boolean isReadableInterval(Object object, Chronology chrono) { return false; } public void setInto(ReadWritableInterval interval, Object object, Chronology chrono) { interval.setChronology(chrono); interval.setInterval(1234L, 5678L); } public Class<?> getSupportedType() { return ReadableInterval.class; } }; try { ConverterManager.getInstance().addIntervalConverter(conv); Interval base = new Interval(-1000L, 1000L); Interval test = new Interval(base); assertEquals(1234L, test.getStartMillis()); assertEquals(5678L, test.getEndMillis()); } finally { ConverterManager.getInstance().addIntervalConverter(oldConv); } } class MockInterval implements ReadableInterval { public Chronology getChronology() { return ISOChronology.getInstance(); } public long getStartMillis() { return 1234L; } public DateTime getStart() { return new DateTime(1234L); } public long getEndMillis() { return 5678L; } public DateTime getEnd() { return new DateTime(5678L); } public long toDurationMillis() { return (5678L - 1234L); } public Duration toDuration() { return new Duration(5678L - 1234L); } public boolean contains(long millisInstant) { return false; } public boolean containsNow() { return false; } public boolean contains(ReadableInstant instant) { return false; } public boolean contains(ReadableInterval interval) { return false; } public boolean overlaps(ReadableInterval interval) { return false; } public boolean isBefore(ReadableInstant instant) { return false; } public boolean isBefore(ReadableInterval interval) { return false; } public boolean isAfter(ReadableInstant instant) { return false; } public boolean isAfter(ReadableInterval interval) { return false; } public Interval toInterval() { return null; } public MutableInterval toMutableInterval() { return null; } public Period toPeriod() { return null; } public Period toPeriod(PeriodType type) { return null; } } // ----------------------------------------------------------------------- public void testConstructor_Object_Chronology1() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval base = new Interval(dt1, dt2); Interval test = new Interval(base, BuddhistChronology.getInstance()); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(BuddhistChronology.getInstance(), test.getChronology()); } public void testConstructor_Object_Chronology2() throws Throwable { DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); Interval base = new Interval(dt1, dt2); Interval test = new Interval(base, null); assertEquals(dt1.getMillis(), test.getStartMillis()); assertEquals(dt2.getMillis(), test.getEndMillis()); assertEquals(ISOChronology.getInstance(), test.getChronology()); } }
/** * This class is a Junit unit test for Minutes. * * @author Stephen Colebourne */ public class TestMinutes extends TestCase { // Test in 2002/03 as time zones are more well known // (before the late 90's they were all over the place) private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestMinutes.class); } public TestMinutes(String name) { super(name); } protected void setUp() throws Exception {} protected void tearDown() throws Exception {} // ----------------------------------------------------------------------- public void testConstants() { assertEquals(0, Minutes.ZERO.getMinutes()); assertEquals(1, Minutes.ONE.getMinutes()); assertEquals(2, Minutes.TWO.getMinutes()); assertEquals(3, Minutes.THREE.getMinutes()); assertEquals(Integer.MAX_VALUE, Minutes.MAX_VALUE.getMinutes()); assertEquals(Integer.MIN_VALUE, Minutes.MIN_VALUE.getMinutes()); } // ----------------------------------------------------------------------- public void testFactory_minutes_int() { assertSame(Minutes.ZERO, Minutes.minutes(0)); assertSame(Minutes.ONE, Minutes.minutes(1)); assertSame(Minutes.TWO, Minutes.minutes(2)); assertSame(Minutes.THREE, Minutes.minutes(3)); assertSame(Minutes.MAX_VALUE, Minutes.minutes(Integer.MAX_VALUE)); assertSame(Minutes.MIN_VALUE, Minutes.minutes(Integer.MIN_VALUE)); assertEquals(-1, Minutes.minutes(-1).getMinutes()); assertEquals(4, Minutes.minutes(4).getMinutes()); } // ----------------------------------------------------------------------- public void testFactory_minutesBetween_RInstant() { DateTime start = new DateTime(2006, 6, 9, 12, 3, 0, 0, PARIS); DateTime end1 = new DateTime(2006, 6, 9, 12, 6, 0, 0, PARIS); DateTime end2 = new DateTime(2006, 6, 9, 12, 9, 0, 0, PARIS); assertEquals(3, Minutes.minutesBetween(start, end1).getMinutes()); assertEquals(0, Minutes.minutesBetween(start, start).getMinutes()); assertEquals(0, Minutes.minutesBetween(end1, end1).getMinutes()); assertEquals(-3, Minutes.minutesBetween(end1, start).getMinutes()); assertEquals(6, Minutes.minutesBetween(start, end2).getMinutes()); } public void testFactory_minutesBetween_RPartial() { LocalTime start = new LocalTime(12, 3); LocalTime end1 = new LocalTime(12, 6); TimeOfDay end2 = new TimeOfDay(12, 9); assertEquals(3, Minutes.minutesBetween(start, end1).getMinutes()); assertEquals(0, Minutes.minutesBetween(start, start).getMinutes()); assertEquals(0, Minutes.minutesBetween(end1, end1).getMinutes()); assertEquals(-3, Minutes.minutesBetween(end1, start).getMinutes()); assertEquals(6, Minutes.minutesBetween(start, end2).getMinutes()); } public void testFactory_minutesIn_RInterval() { DateTime start = new DateTime(2006, 6, 9, 12, 3, 0, 0, PARIS); DateTime end1 = new DateTime(2006, 6, 9, 12, 6, 0, 0, PARIS); DateTime end2 = new DateTime(2006, 6, 9, 12, 9, 0, 0, PARIS); assertEquals(0, Minutes.minutesIn((ReadableInterval) null).getMinutes()); assertEquals(3, Minutes.minutesIn(new Interval(start, end1)).getMinutes()); assertEquals(0, Minutes.minutesIn(new Interval(start, start)).getMinutes()); assertEquals(0, Minutes.minutesIn(new Interval(end1, end1)).getMinutes()); assertEquals(6, Minutes.minutesIn(new Interval(start, end2)).getMinutes()); } public void testFactory_standardMinutesIn_RPeriod() { assertEquals(0, Minutes.standardMinutesIn((ReadablePeriod) null).getMinutes()); assertEquals(0, Minutes.standardMinutesIn(Period.ZERO).getMinutes()); assertEquals(1, Minutes.standardMinutesIn(new Period(0, 0, 0, 0, 0, 1, 0, 0)).getMinutes()); assertEquals(123, Minutes.standardMinutesIn(Period.minutes(123)).getMinutes()); assertEquals(-987, Minutes.standardMinutesIn(Period.minutes(-987)).getMinutes()); assertEquals(1, Minutes.standardMinutesIn(Period.seconds(119)).getMinutes()); assertEquals(2, Minutes.standardMinutesIn(Period.seconds(120)).getMinutes()); assertEquals(2, Minutes.standardMinutesIn(Period.seconds(121)).getMinutes()); assertEquals(120, Minutes.standardMinutesIn(Period.hours(2)).getMinutes()); try { Minutes.standardMinutesIn(Period.months(1)); fail(); } catch (IllegalArgumentException ex) { // expeceted } } public void testFactory_parseMinutes_String() { assertEquals(0, Minutes.parseMinutes((String) null).getMinutes()); assertEquals(0, Minutes.parseMinutes("PT0M").getMinutes()); assertEquals(1, Minutes.parseMinutes("PT1M").getMinutes()); assertEquals(-3, Minutes.parseMinutes("PT-3M").getMinutes()); assertEquals(2, Minutes.parseMinutes("P0Y0M0DT2M").getMinutes()); assertEquals(2, Minutes.parseMinutes("PT0H2M").getMinutes()); try { Minutes.parseMinutes("P1Y1D"); fail(); } catch (IllegalArgumentException ex) { // expeceted } try { Minutes.parseMinutes("P1DT1M"); fail(); } catch (IllegalArgumentException ex) { // expeceted } } // ----------------------------------------------------------------------- public void testGetMethods() { Minutes test = Minutes.minutes(20); assertEquals(20, test.getMinutes()); } public void testGetFieldType() { Minutes test = Minutes.minutes(20); assertEquals(DurationFieldType.minutes(), test.getFieldType()); } public void testGetPeriodType() { Minutes test = Minutes.minutes(20); assertEquals(PeriodType.minutes(), test.getPeriodType()); } // ----------------------------------------------------------------------- public void testIsGreaterThan() { assertEquals(true, Minutes.THREE.isGreaterThan(Minutes.TWO)); assertEquals(false, Minutes.THREE.isGreaterThan(Minutes.THREE)); assertEquals(false, Minutes.TWO.isGreaterThan(Minutes.THREE)); assertEquals(true, Minutes.ONE.isGreaterThan(null)); assertEquals(false, Minutes.minutes(-1).isGreaterThan(null)); } public void testIsLessThan() { assertEquals(false, Minutes.THREE.isLessThan(Minutes.TWO)); assertEquals(false, Minutes.THREE.isLessThan(Minutes.THREE)); assertEquals(true, Minutes.TWO.isLessThan(Minutes.THREE)); assertEquals(false, Minutes.ONE.isLessThan(null)); assertEquals(true, Minutes.minutes(-1).isLessThan(null)); } // ----------------------------------------------------------------------- public void testToString() { Minutes test = Minutes.minutes(20); assertEquals("PT20M", test.toString()); test = Minutes.minutes(-20); assertEquals("PT-20M", test.toString()); } // ----------------------------------------------------------------------- public void testSerialization() throws Exception { Minutes test = Minutes.THREE; ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(test); byte[] bytes = baos.toByteArray(); oos.close(); ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bais); Minutes result = (Minutes) ois.readObject(); ois.close(); assertSame(test, result); } // ----------------------------------------------------------------------- public void testToStandardWeeks() { Minutes test = Minutes.minutes(60 * 24 * 7 * 2); Weeks expected = Weeks.weeks(2); assertEquals(expected, test.toStandardWeeks()); } public void testToStandardDays() { Minutes test = Minutes.minutes(60 * 24 * 2); Days expected = Days.days(2); assertEquals(expected, test.toStandardDays()); } public void testToStandardHours() { Minutes test = Minutes.minutes(3 * 60); Hours expected = Hours.hours(3); assertEquals(expected, test.toStandardHours()); } public void testToStandardSeconds() { Minutes test = Minutes.minutes(3); Seconds expected = Seconds.seconds(3 * 60); assertEquals(expected, test.toStandardSeconds()); try { Minutes.MAX_VALUE.toStandardSeconds(); fail(); } catch (ArithmeticException ex) { // expected } } public void testToStandardDuration() { Minutes test = Minutes.minutes(20); Duration expected = new Duration(20L * DateTimeConstants.MILLIS_PER_MINUTE); assertEquals(expected, test.toStandardDuration()); expected = new Duration(((long) Integer.MAX_VALUE) * DateTimeConstants.MILLIS_PER_MINUTE); assertEquals(expected, Minutes.MAX_VALUE.toStandardDuration()); } // ----------------------------------------------------------------------- public void testPlus_int() { Minutes test2 = Minutes.minutes(2); Minutes result = test2.plus(3); assertEquals(2, test2.getMinutes()); assertEquals(5, result.getMinutes()); assertEquals(1, Minutes.ONE.plus(0).getMinutes()); try { Minutes.MAX_VALUE.plus(1); fail(); } catch (ArithmeticException ex) { // expected } } public void testPlus_Minutes() { Minutes test2 = Minutes.minutes(2); Minutes test3 = Minutes.minutes(3); Minutes result = test2.plus(test3); assertEquals(2, test2.getMinutes()); assertEquals(3, test3.getMinutes()); assertEquals(5, result.getMinutes()); assertEquals(1, Minutes.ONE.plus(Minutes.ZERO).getMinutes()); assertEquals(1, Minutes.ONE.plus((Minutes) null).getMinutes()); try { Minutes.MAX_VALUE.plus(Minutes.ONE); fail(); } catch (ArithmeticException ex) { // expected } } public void testMinus_int() { Minutes test2 = Minutes.minutes(2); Minutes result = test2.minus(3); assertEquals(2, test2.getMinutes()); assertEquals(-1, result.getMinutes()); assertEquals(1, Minutes.ONE.minus(0).getMinutes()); try { Minutes.MIN_VALUE.minus(1); fail(); } catch (ArithmeticException ex) { // expected } } public void testMinus_Minutes() { Minutes test2 = Minutes.minutes(2); Minutes test3 = Minutes.minutes(3); Minutes result = test2.minus(test3); assertEquals(2, test2.getMinutes()); assertEquals(3, test3.getMinutes()); assertEquals(-1, result.getMinutes()); assertEquals(1, Minutes.ONE.minus(Minutes.ZERO).getMinutes()); assertEquals(1, Minutes.ONE.minus((Minutes) null).getMinutes()); try { Minutes.MIN_VALUE.minus(Minutes.ONE); fail(); } catch (ArithmeticException ex) { // expected } } public void testMultipliedBy_int() { Minutes test = Minutes.minutes(2); assertEquals(6, test.multipliedBy(3).getMinutes()); assertEquals(2, test.getMinutes()); assertEquals(-6, test.multipliedBy(-3).getMinutes()); assertSame(test, test.multipliedBy(1)); Minutes halfMax = Minutes.minutes(Integer.MAX_VALUE / 2 + 1); try { halfMax.multipliedBy(2); fail(); } catch (ArithmeticException ex) { // expected } } public void testDividedBy_int() { Minutes test = Minutes.minutes(12); assertEquals(6, test.dividedBy(2).getMinutes()); assertEquals(12, test.getMinutes()); assertEquals(4, test.dividedBy(3).getMinutes()); assertEquals(3, test.dividedBy(4).getMinutes()); assertEquals(2, test.dividedBy(5).getMinutes()); assertEquals(2, test.dividedBy(6).getMinutes()); assertSame(test, test.dividedBy(1)); try { Minutes.ONE.dividedBy(0); fail(); } catch (ArithmeticException ex) { // expected } } public void testNegated() { Minutes test = Minutes.minutes(12); assertEquals(-12, test.negated().getMinutes()); assertEquals(12, test.getMinutes()); try { Minutes.MIN_VALUE.negated(); fail(); } catch (ArithmeticException ex) { // expected } } // ----------------------------------------------------------------------- public void testAddToLocalDate() { Minutes test = Minutes.minutes(26); LocalDateTime date = new LocalDateTime(2006, 6, 1, 0, 0, 0, 0); LocalDateTime expected = new LocalDateTime(2006, 6, 1, 0, 26, 0, 0); assertEquals(expected, date.plus(test)); } }
/** * This class is a Junit unit test for Instant. * * @author Stephen Colebourne */ public class TestMutableInterval_Basics extends TestCase { // Test in 2002/03 as time zones are more well known // (before the late 90's they were all over the place) private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS); long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365; long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365; // 2002-06-09 private long TEST_TIME_NOW = (y2002days + 31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY; // 2002-04-05 private long TEST_TIME1 = (y2002days + 31L + 28L + 31L + 5L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 12L * DateTimeConstants.MILLIS_PER_HOUR + 24L * DateTimeConstants.MILLIS_PER_MINUTE; // 2003-05-06 private long TEST_TIME2 = (y2003days + 31L + 28L + 31L + 30L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY + 14L * DateTimeConstants.MILLIS_PER_HOUR + 28L * DateTimeConstants.MILLIS_PER_MINUTE; private DateTimeZone originalDateTimeZone = null; private TimeZone originalTimeZone = null; private Locale originalLocale = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestMutableInterval_Basics.class); } public TestMutableInterval_Basics(String name) { super(name); } protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); originalDateTimeZone = DateTimeZone.getDefault(); originalTimeZone = TimeZone.getDefault(); originalLocale = Locale.getDefault(); DateTimeZone.setDefault(LONDON); TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); Locale.setDefault(Locale.UK); } protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(originalDateTimeZone); TimeZone.setDefault(originalTimeZone); Locale.setDefault(originalLocale); originalDateTimeZone = null; originalTimeZone = null; originalLocale = null; } // ----------------------------------------------------------------------- public void testTest() { assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString()); assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString()); assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString()); } // ----------------------------------------------------------------------- public void testGetMillis() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(TEST_TIME1, test.getStartMillis()); assertEquals(TEST_TIME1, test.getStart().getMillis()); assertEquals(TEST_TIME2, test.getEndMillis()); assertEquals(TEST_TIME2, test.getEnd().getMillis()); assertEquals(TEST_TIME2 - TEST_TIME1, test.toDurationMillis()); assertEquals(TEST_TIME2 - TEST_TIME1, test.toDuration().getMillis()); } public void testGetDuration1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(TEST_TIME2 - TEST_TIME1, test.toDurationMillis()); assertEquals(TEST_TIME2 - TEST_TIME1, test.toDuration().getMillis()); } public void testGetDuration2() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME1); assertSame(Duration.ZERO, test.toDuration()); } public void testEqualsHashCode() { MutableInterval test1 = new MutableInterval(TEST_TIME1, TEST_TIME2); MutableInterval test2 = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test1.equals(test2)); assertEquals(true, test2.equals(test1)); assertEquals(true, test1.equals(test1)); assertEquals(true, test2.equals(test2)); assertEquals(true, test1.hashCode() == test2.hashCode()); assertEquals(true, test1.hashCode() == test1.hashCode()); assertEquals(true, test2.hashCode() == test2.hashCode()); MutableInterval test3 = new MutableInterval(TEST_TIME_NOW, TEST_TIME2); assertEquals(false, test1.equals(test3)); assertEquals(false, test2.equals(test3)); assertEquals(false, test3.equals(test1)); assertEquals(false, test3.equals(test2)); assertEquals(false, test1.hashCode() == test3.hashCode()); assertEquals(false, test2.hashCode() == test3.hashCode()); MutableInterval test4 = new MutableInterval(TEST_TIME1, TEST_TIME2, GJChronology.getInstance()); assertEquals(true, test4.equals(test4)); assertEquals(false, test1.equals(test4)); assertEquals(false, test2.equals(test4)); assertEquals(false, test4.equals(test1)); assertEquals(false, test4.equals(test2)); assertEquals(false, test1.hashCode() == test4.hashCode()); assertEquals(false, test2.hashCode() == test4.hashCode()); MutableInterval test5 = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test1.equals(test5)); assertEquals(true, test2.equals(test5)); assertEquals(false, test3.equals(test5)); assertEquals(true, test5.equals(test1)); assertEquals(true, test5.equals(test2)); assertEquals(false, test5.equals(test3)); assertEquals(true, test1.hashCode() == test5.hashCode()); assertEquals(true, test2.hashCode() == test5.hashCode()); assertEquals(false, test3.hashCode() == test5.hashCode()); assertEquals(false, test1.equals("Hello")); assertEquals(true, test1.equals(new MockInterval())); assertEquals(false, test1.equals(new DateTime(TEST_TIME1))); } class MockInterval extends AbstractInterval { public MockInterval() { super(); } public Chronology getChronology() { return ISOChronology.getInstance(); } public long getStartMillis() { return TEST_TIME1; } public long getEndMillis() { return TEST_TIME2; } } // ----------------------------------------------------------------------- public void testContains_long() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.contains(TEST_TIME1)); assertEquals(false, test.contains(TEST_TIME1 - 1)); assertEquals(true, test.contains(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2)); assertEquals(false, test.contains(TEST_TIME2)); assertEquals(true, test.contains(TEST_TIME2 - 1)); } public void testContainsNow() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1); assertEquals(true, test.containsNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1 - 1); assertEquals(false, test.containsNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2); assertEquals(true, test.containsNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2); assertEquals(false, test.containsNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2 - 1); assertEquals(true, test.containsNow()); } public void testContains_RI() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.contains(new Instant(TEST_TIME1))); assertEquals(false, test.contains(new Instant(TEST_TIME1 - 1))); assertEquals(true, test.contains(new Instant(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2))); assertEquals(false, test.contains(new Instant(TEST_TIME2))); assertEquals(true, test.contains(new Instant(TEST_TIME2 - 1))); assertEquals(true, test.contains((ReadableInstant) null)); } // ----------------------------------------------------------------------- public void testContains_RInterval() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.contains(new Interval(TEST_TIME1, TEST_TIME1))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 1, TEST_TIME1))); assertEquals(true, test.contains(new Interval(TEST_TIME1, TEST_TIME1 + 1))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 1, TEST_TIME1 + 1))); assertEquals(true, test.contains(new Interval(TEST_TIME1 + 1, TEST_TIME1 + 1))); assertEquals(true, test.contains(new Interval(TEST_TIME1, TEST_TIME2))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 1, TEST_TIME2))); assertEquals( true, test.contains(new Interval(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2, TEST_TIME2))); assertEquals(false, test.contains(new Interval(TEST_TIME2, TEST_TIME2))); assertEquals(true, test.contains(new Interval(TEST_TIME2 - 1, TEST_TIME2))); assertEquals(true, test.contains(new Interval(TEST_TIME1, TEST_TIME2 - 1))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 1, TEST_TIME2 - 1))); assertEquals( true, test.contains(new Interval(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2, TEST_TIME2 - 1))); assertEquals(true, test.contains(new Interval(TEST_TIME2 - 1, TEST_TIME2 - 1))); assertEquals(true, test.contains(new Interval(TEST_TIME2 - 2, TEST_TIME2 - 1))); assertEquals(false, test.contains(new Interval(TEST_TIME1, TEST_TIME2 + 1))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 1, TEST_TIME2 + 1))); assertEquals( false, test.contains(new Interval(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2, TEST_TIME2 + 1))); assertEquals(false, test.contains(new Interval(TEST_TIME2, TEST_TIME2 + 1))); assertEquals(false, test.contains(new Interval(TEST_TIME2 - 1, TEST_TIME2 + 1))); assertEquals(false, test.contains(new Interval(TEST_TIME1 - 2, TEST_TIME1 - 1))); assertEquals(true, test.contains((ReadableInterval) null)); } public void testOverlaps_RInterval() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(false, test.overlaps(new Interval(TEST_TIME1, TEST_TIME1))); assertEquals(false, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1, TEST_TIME1 + 1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME1 + 1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1 + 1, TEST_TIME1 + 1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1, TEST_TIME2))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME2))); assertEquals( true, test.overlaps(new Interval(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2, TEST_TIME2))); assertEquals(false, test.overlaps(new Interval(TEST_TIME2, TEST_TIME2))); assertEquals(true, test.overlaps(new Interval(TEST_TIME2 - 1, TEST_TIME2))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1, TEST_TIME2 + 1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME2 + 1))); assertEquals( true, test.overlaps(new Interval(TEST_TIME1 + (TEST_TIME2 - TEST_TIME1) / 2, TEST_TIME2 + 1))); assertEquals(false, test.overlaps(new Interval(TEST_TIME2, TEST_TIME2 + 1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME2 - 1, TEST_TIME2 + 1))); assertEquals(false, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME1 - 1))); assertEquals(false, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME1))); assertEquals(true, test.overlaps(new Interval(TEST_TIME1 - 1, TEST_TIME1 + 1))); assertEquals(true, test.overlaps((ReadableInterval) null)); MutableInterval empty = new MutableInterval(TEST_TIME1, TEST_TIME1); assertEquals(false, empty.overlaps(empty)); assertEquals(false, empty.overlaps(test)); assertEquals(false, test.overlaps(empty)); } // ----------------------------------------------------------------------- public void testIsBefore_long() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(false, test.isBefore(TEST_TIME1 - 1)); assertEquals(false, test.isBefore(TEST_TIME1)); assertEquals(false, test.isBefore(TEST_TIME1 + 1)); assertEquals(false, test.isBefore(TEST_TIME2 - 1)); assertEquals(true, test.isBefore(TEST_TIME2)); assertEquals(true, test.isBefore(TEST_TIME2 + 1)); } public void testIsBeforeNow() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2 - 1); assertEquals(false, test.isBeforeNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2); assertEquals(true, test.isBeforeNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2 + 1); assertEquals(true, test.isBeforeNow()); } public void testIsBefore_RI() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(false, test.isBefore(new Instant(TEST_TIME1 - 1))); assertEquals(false, test.isBefore(new Instant(TEST_TIME1))); assertEquals(false, test.isBefore(new Instant(TEST_TIME1 + 1))); assertEquals(false, test.isBefore(new Instant(TEST_TIME2 - 1))); assertEquals(true, test.isBefore(new Instant(TEST_TIME2))); assertEquals(true, test.isBefore(new Instant(TEST_TIME2 + 1))); assertEquals(false, test.isBefore((ReadableInstant) null)); } public void testIsBefore_RInterval() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(false, test.isBefore(new Interval(Long.MIN_VALUE, TEST_TIME1 - 1))); assertEquals(false, test.isBefore(new Interval(Long.MIN_VALUE, TEST_TIME1))); assertEquals(false, test.isBefore(new Interval(Long.MIN_VALUE, TEST_TIME1 + 1))); assertEquals(false, test.isBefore(new Interval(TEST_TIME2 - 1, Long.MAX_VALUE))); assertEquals(true, test.isBefore(new Interval(TEST_TIME2, Long.MAX_VALUE))); assertEquals(true, test.isBefore(new Interval(TEST_TIME2 + 1, Long.MAX_VALUE))); assertEquals(false, test.isBefore((ReadableInterval) null)); } // ----------------------------------------------------------------------- public void testIsAfter_long() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.isAfter(TEST_TIME1 - 1)); assertEquals(false, test.isAfter(TEST_TIME1)); assertEquals(false, test.isAfter(TEST_TIME1 + 1)); assertEquals(false, test.isAfter(TEST_TIME2 - 1)); assertEquals(false, test.isAfter(TEST_TIME2)); assertEquals(false, test.isAfter(TEST_TIME2 + 1)); } public void testIsAfterNow() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1 - 1); assertEquals(true, test.isAfterNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1); assertEquals(false, test.isAfterNow()); DateTimeUtils.setCurrentMillisFixed(TEST_TIME1 + 1); assertEquals(false, test.isAfterNow()); } public void testIsAfter_RI() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.isAfter(new Instant(TEST_TIME1 - 1))); assertEquals(false, test.isAfter(new Instant(TEST_TIME1))); assertEquals(false, test.isAfter(new Instant(TEST_TIME1 + 1))); assertEquals(false, test.isAfter(new Instant(TEST_TIME2 - 1))); assertEquals(false, test.isAfter(new Instant(TEST_TIME2))); assertEquals(false, test.isAfter(new Instant(TEST_TIME2 + 1))); assertEquals(false, test.isAfter((ReadableInstant) null)); } public void testIsAfter_RInterval() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); assertEquals(true, test.isAfter(new Interval(Long.MIN_VALUE, TEST_TIME1 - 1))); assertEquals(true, test.isAfter(new Interval(Long.MIN_VALUE, TEST_TIME1))); assertEquals(false, test.isAfter(new Interval(Long.MIN_VALUE, TEST_TIME1 + 1))); assertEquals(false, test.isAfter(new Interval(TEST_TIME2 - 1, Long.MAX_VALUE))); assertEquals(false, test.isAfter(new Interval(TEST_TIME2, Long.MAX_VALUE))); assertEquals(false, test.isAfter(new Interval(TEST_TIME2 + 1, Long.MAX_VALUE))); assertEquals(false, test.isAfter((ReadableInterval) null)); } // ----------------------------------------------------------------------- public void testToInterval1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS); Interval result = test.toInterval(); assertEquals(test, result); } // ----------------------------------------------------------------------- public void testToMutableInterval1() { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS); MutableInterval result = test.toMutableInterval(); assertEquals(test, result); assertNotSame(test, result); } // ----------------------------------------------------------------------- public void testToPeriod() { DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, COPTIC_PARIS); DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, COPTIC_PARIS); MutableInterval base = new MutableInterval(dt1, dt2); Period test = base.toPeriod(); Period expected = new Period(dt1, dt2, PeriodType.standard()); assertEquals(expected, test); } // ----------------------------------------------------------------------- public void testToPeriod_PeriodType1() { DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, COPTIC_PARIS); DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, COPTIC_PARIS); MutableInterval base = new MutableInterval(dt1, dt2); Period test = base.toPeriod(null); Period expected = new Period(dt1, dt2, PeriodType.standard()); assertEquals(expected, test); } public void testToPeriod_PeriodType2() { DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10); DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18); MutableInterval base = new MutableInterval(dt1, dt2); Period test = base.toPeriod(PeriodType.yearWeekDayTime()); Period expected = new Period(dt1, dt2, PeriodType.yearWeekDayTime()); assertEquals(expected, test); } // ----------------------------------------------------------------------- public void testSerialization() throws Exception { MutableInterval test = new MutableInterval(TEST_TIME1, TEST_TIME2); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(test); byte[] bytes = baos.toByteArray(); oos.close(); ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bais); MutableInterval result = (MutableInterval) ois.readObject(); ois.close(); assertEquals(test, result); } // ----------------------------------------------------------------------- public void testToString() { DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, DateTimeZone.UTC); DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, DateTimeZone.UTC); MutableInterval test = new MutableInterval(dt1, dt2); assertEquals("2004-06-09T07:08:09.010Z/2005-08-13T12:14:16.018Z", test.toString()); } // ----------------------------------------------------------------------- public void testCopy() { MutableInterval test = new MutableInterval(123L, 456L, COPTIC_PARIS); MutableInterval cloned = test.copy(); assertEquals(test, cloned); assertNotSame(test, cloned); } public void testClone() { MutableInterval test = new MutableInterval(123L, 456L, COPTIC_PARIS); MutableInterval cloned = (MutableInterval) test.clone(); assertEquals(test, cloned); assertNotSame(test, cloned); } }
/** * This class is a Junit unit test for LocalTime. * * @author Stephen Colebourne */ public class TestLocalTime_Basics extends TestCase { private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); private static final DateTimeZone TOKYO = DateTimeZone.forID("Asia/Tokyo"); private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS); private static final Chronology COPTIC_LONDON = CopticChronology.getInstance(LONDON); private static final Chronology COPTIC_TOKYO = CopticChronology.getInstance(TOKYO); private static final Chronology COPTIC_UTC = CopticChronology.getInstanceUTC(); private static final Chronology BUDDHIST_LONDON = BuddhistChronology.getInstance(LONDON); private long TEST_TIME_NOW = 10L * DateTimeConstants.MILLIS_PER_HOUR + 20L * DateTimeConstants.MILLIS_PER_MINUTE + 30L * DateTimeConstants.MILLIS_PER_SECOND + 40L; // private long TEST_TIME1 = // 1L * DateTimeConstants.MILLIS_PER_HOUR // + 2L * DateTimeConstants.MILLIS_PER_MINUTE // + 3L * DateTimeConstants.MILLIS_PER_SECOND // + 4L; private long TEST_TIME2 = 1L * DateTimeConstants.MILLIS_PER_DAY + 5L * DateTimeConstants.MILLIS_PER_HOUR + 6L * DateTimeConstants.MILLIS_PER_MINUTE + 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; private DateTimeZone zone = null; public static void main(String[] args) { junit.textui.TestRunner.run(suite()); } public static TestSuite suite() { return new TestSuite(TestLocalTime_Basics.class); } public TestLocalTime_Basics(String name) { super(name); } protected void setUp() throws Exception { DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); zone = DateTimeZone.getDefault(); DateTimeZone.setDefault(LONDON); } protected void tearDown() throws Exception { DateTimeUtils.setCurrentMillisSystem(); DateTimeZone.setDefault(zone); zone = null; } // ----------------------------------------------------------------------- public void testGet_DateTimeFieldType() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(10, test.get(DateTimeFieldType.hourOfDay())); assertEquals(20, test.get(DateTimeFieldType.minuteOfHour())); assertEquals(30, test.get(DateTimeFieldType.secondOfMinute())); assertEquals(40, test.get(DateTimeFieldType.millisOfSecond())); assertEquals(TEST_TIME_NOW / 60000, test.get(DateTimeFieldType.minuteOfDay())); assertEquals(TEST_TIME_NOW / 1000, test.get(DateTimeFieldType.secondOfDay())); assertEquals(TEST_TIME_NOW, test.get(DateTimeFieldType.millisOfDay())); assertEquals(10, test.get(DateTimeFieldType.hourOfHalfday())); assertEquals(DateTimeConstants.AM, test.get(DateTimeFieldType.halfdayOfDay())); test = new LocalTime(12, 30); assertEquals(0, test.get(DateTimeFieldType.hourOfHalfday())); assertEquals(12, test.get(DateTimeFieldType.clockhourOfHalfday())); assertEquals(12, test.get(DateTimeFieldType.clockhourOfDay())); assertEquals(DateTimeConstants.PM, test.get(DateTimeFieldType.halfdayOfDay())); test = new LocalTime(14, 30); assertEquals(2, test.get(DateTimeFieldType.hourOfHalfday())); assertEquals(2, test.get(DateTimeFieldType.clockhourOfHalfday())); assertEquals(14, test.get(DateTimeFieldType.clockhourOfDay())); assertEquals(DateTimeConstants.PM, test.get(DateTimeFieldType.halfdayOfDay())); test = new LocalTime(0, 30); assertEquals(0, test.get(DateTimeFieldType.hourOfHalfday())); assertEquals(12, test.get(DateTimeFieldType.clockhourOfHalfday())); assertEquals(24, test.get(DateTimeFieldType.clockhourOfDay())); assertEquals(DateTimeConstants.AM, test.get(DateTimeFieldType.halfdayOfDay())); try { test.get(null); fail(); } catch (IllegalArgumentException ex) { } try { test.get(DateTimeFieldType.dayOfMonth()); fail(); } catch (IllegalArgumentException ex) { } } public void testSize() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(4, test.size()); } public void testGetFieldType_int() { LocalTime test = new LocalTime(10, 20, 30, 40); assertSame(DateTimeFieldType.hourOfDay(), test.getFieldType(0)); assertSame(DateTimeFieldType.minuteOfHour(), test.getFieldType(1)); assertSame(DateTimeFieldType.secondOfMinute(), test.getFieldType(2)); assertSame(DateTimeFieldType.millisOfSecond(), test.getFieldType(3)); try { test.getFieldType(-1); } catch (IndexOutOfBoundsException ex) { } try { test.getFieldType(5); } catch (IndexOutOfBoundsException ex) { } } public void testGetFieldTypes() { LocalTime test = new LocalTime(10, 20, 30, 40); DateTimeFieldType[] fields = test.getFieldTypes(); assertSame(DateTimeFieldType.hourOfDay(), fields[0]); assertSame(DateTimeFieldType.minuteOfHour(), fields[1]); assertSame(DateTimeFieldType.secondOfMinute(), fields[2]); assertSame(DateTimeFieldType.millisOfSecond(), fields[3]); assertNotSame(test.getFieldTypes(), test.getFieldTypes()); } public void testGetField_int() { LocalTime test = new LocalTime(10, 20, 30, 40, COPTIC_UTC); assertSame(COPTIC_UTC.hourOfDay(), test.getField(0)); assertSame(COPTIC_UTC.minuteOfHour(), test.getField(1)); assertSame(COPTIC_UTC.secondOfMinute(), test.getField(2)); assertSame(COPTIC_UTC.millisOfSecond(), test.getField(3)); try { test.getField(-1); } catch (IndexOutOfBoundsException ex) { } try { test.getField(5); } catch (IndexOutOfBoundsException ex) { } } public void testGetFields() { LocalTime test = new LocalTime(10, 20, 30, 40, COPTIC_UTC); DateTimeField[] fields = test.getFields(); assertSame(COPTIC_UTC.hourOfDay(), fields[0]); assertSame(COPTIC_UTC.minuteOfHour(), fields[1]); assertSame(COPTIC_UTC.secondOfMinute(), fields[2]); assertSame(COPTIC_UTC.millisOfSecond(), fields[3]); assertNotSame(test.getFields(), test.getFields()); } public void testGetValue_int() { LocalTime test = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); assertEquals(10, test.getValue(0)); assertEquals(20, test.getValue(1)); assertEquals(30, test.getValue(2)); assertEquals(40, test.getValue(3)); try { test.getValue(-1); } catch (IndexOutOfBoundsException ex) { } try { test.getValue(5); } catch (IndexOutOfBoundsException ex) { } } public void testGetValues() { LocalTime test = new LocalTime(10, 20, 30, 40, COPTIC_UTC); int[] values = test.getValues(); assertEquals(10, values[0]); assertEquals(20, values[1]); assertEquals(30, values[2]); assertEquals(40, values[3]); assertNotSame(test.getValues(), test.getValues()); } public void testIsSupported_DateTimeFieldType() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(true, test.isSupported(DateTimeFieldType.hourOfDay())); assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfHour())); assertEquals(true, test.isSupported(DateTimeFieldType.secondOfMinute())); assertEquals(true, test.isSupported(DateTimeFieldType.millisOfSecond())); assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfDay())); assertEquals(true, test.isSupported(DateTimeFieldType.secondOfDay())); assertEquals(true, test.isSupported(DateTimeFieldType.millisOfDay())); assertEquals(true, test.isSupported(DateTimeFieldType.hourOfHalfday())); assertEquals(true, test.isSupported(DateTimeFieldType.halfdayOfDay())); assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfHalfday())); assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfDay())); assertEquals(false, test.isSupported(DateTimeFieldType.dayOfMonth())); assertEquals(false, test.isSupported((DateTimeFieldType) null)); DateTimeFieldType d = new DateTimeFieldType("hours") { private static final long serialVersionUID = 1L; public DurationFieldType getDurationType() { return DurationFieldType.hours(); } public DurationFieldType getRangeDurationType() { return null; } public DateTimeField getField(Chronology chronology) { return chronology.hourOfDay(); } }; assertEquals(false, test.isSupported(d)); d = new DateTimeFieldType("hourOfYear") { private static final long serialVersionUID = 1L; public DurationFieldType getDurationType() { return DurationFieldType.hours(); } public DurationFieldType getRangeDurationType() { return DurationFieldType.years(); } public DateTimeField getField(Chronology chronology) { return chronology.hourOfDay(); } }; assertEquals(false, test.isSupported(d)); } public void testIsSupported_DurationFieldType() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(true, test.isSupported(DurationFieldType.hours())); assertEquals(true, test.isSupported(DurationFieldType.minutes())); assertEquals(true, test.isSupported(DurationFieldType.seconds())); assertEquals(true, test.isSupported(DurationFieldType.millis())); assertEquals(true, test.isSupported(DurationFieldType.halfdays())); assertEquals(false, test.isSupported(DurationFieldType.days())); assertEquals(false, test.isSupported((DurationFieldType) null)); } @SuppressWarnings("deprecation") public void testEqualsHashCode() { LocalTime test1 = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); LocalTime test2 = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); assertEquals(true, test1.equals(test2)); assertEquals(true, test2.equals(test1)); assertEquals(true, test1.equals(test1)); assertEquals(true, test2.equals(test2)); assertEquals(true, test1.hashCode() == test2.hashCode()); assertEquals(true, test1.hashCode() == test1.hashCode()); assertEquals(true, test2.hashCode() == test2.hashCode()); LocalTime test3 = new LocalTime(15, 20, 30, 40); assertEquals(false, test1.equals(test3)); assertEquals(false, test2.equals(test3)); assertEquals(false, test3.equals(test1)); assertEquals(false, test3.equals(test2)); assertEquals(false, test1.hashCode() == test3.hashCode()); assertEquals(false, test2.hashCode() == test3.hashCode()); assertEquals(false, test1.equals("Hello")); assertEquals(true, test1.equals(new TimeOfDay(10, 20, 30, 40, COPTIC_UTC))); assertEquals(true, test1.hashCode() == new TimeOfDay(10, 20, 30, 40, COPTIC_UTC).hashCode()); assertEquals(true, test1.equals(new MockInstant())); assertEquals(false, test1.equals(MockPartial.EMPTY_INSTANCE)); } class MockInstant extends MockPartial { public Chronology getChronology() { return COPTIC_UTC; } public DateTimeField[] getFields() { return new DateTimeField[] { COPTIC_UTC.hourOfDay(), COPTIC_UTC.minuteOfHour(), COPTIC_UTC.secondOfMinute(), COPTIC_UTC.millisOfSecond(), }; } public int[] getValues() { return new int[] {10, 20, 30, 40}; } } // ----------------------------------------------------------------------- @SuppressWarnings("deprecation") public void testCompareTo() { LocalTime test1 = new LocalTime(10, 20, 30, 40); LocalTime test1a = new LocalTime(10, 20, 30, 40); assertEquals(0, test1.compareTo(test1a)); assertEquals(0, test1a.compareTo(test1)); assertEquals(0, test1.compareTo(test1)); assertEquals(0, test1a.compareTo(test1a)); LocalTime test2 = new LocalTime(10, 20, 35, 40); assertEquals(-1, test1.compareTo(test2)); assertEquals(+1, test2.compareTo(test1)); LocalTime test3 = new LocalTime(10, 20, 35, 40, GregorianChronology.getInstanceUTC()); assertEquals(-1, test1.compareTo(test3)); assertEquals(+1, test3.compareTo(test1)); assertEquals(0, test3.compareTo(test2)); DateTimeFieldType[] types = new DateTimeFieldType[] { DateTimeFieldType.hourOfDay(), DateTimeFieldType.minuteOfHour(), DateTimeFieldType.secondOfMinute(), DateTimeFieldType.millisOfSecond(), }; int[] values = new int[] {10, 20, 30, 40}; Partial p = new Partial(types, values); assertEquals(0, test1.compareTo(p)); assertEquals(0, test1.compareTo(new TimeOfDay(10, 20, 30, 40))); try { test1.compareTo(null); fail(); } catch (NullPointerException ex) { } // try { // test1.compareTo(new Date()); // fail(); // } catch (ClassCastException ex) {} } // ----------------------------------------------------------------------- public void testIsEqual_LocalTime() { LocalTime test1 = new LocalTime(10, 20, 30, 40); LocalTime test1a = new LocalTime(10, 20, 30, 40); assertEquals(true, test1.isEqual(test1a)); assertEquals(true, test1a.isEqual(test1)); assertEquals(true, test1.isEqual(test1)); assertEquals(true, test1a.isEqual(test1a)); LocalTime test2 = new LocalTime(10, 20, 35, 40); assertEquals(false, test1.isEqual(test2)); assertEquals(false, test2.isEqual(test1)); LocalTime test3 = new LocalTime(10, 20, 35, 40, GregorianChronology.getInstanceUTC()); assertEquals(false, test1.isEqual(test3)); assertEquals(false, test3.isEqual(test1)); assertEquals(true, test3.isEqual(test2)); try { new LocalTime(10, 20, 35, 40).isEqual(null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testIsBefore_LocalTime() { LocalTime test1 = new LocalTime(10, 20, 30, 40); LocalTime test1a = new LocalTime(10, 20, 30, 40); assertEquals(false, test1.isBefore(test1a)); assertEquals(false, test1a.isBefore(test1)); assertEquals(false, test1.isBefore(test1)); assertEquals(false, test1a.isBefore(test1a)); LocalTime test2 = new LocalTime(10, 20, 35, 40); assertEquals(true, test1.isBefore(test2)); assertEquals(false, test2.isBefore(test1)); LocalTime test3 = new LocalTime(10, 20, 35, 40, GregorianChronology.getInstanceUTC()); assertEquals(true, test1.isBefore(test3)); assertEquals(false, test3.isBefore(test1)); assertEquals(false, test3.isBefore(test2)); try { new LocalTime(10, 20, 35, 40).isBefore(null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testIsAfter_LocalTime() { LocalTime test1 = new LocalTime(10, 20, 30, 40); LocalTime test1a = new LocalTime(10, 20, 30, 40); assertEquals(false, test1.isAfter(test1a)); assertEquals(false, test1a.isAfter(test1)); assertEquals(false, test1.isAfter(test1)); assertEquals(false, test1a.isAfter(test1a)); LocalTime test2 = new LocalTime(10, 20, 35, 40); assertEquals(false, test1.isAfter(test2)); assertEquals(true, test2.isAfter(test1)); LocalTime test3 = new LocalTime(10, 20, 35, 40, GregorianChronology.getInstanceUTC()); assertEquals(false, test1.isAfter(test3)); assertEquals(true, test3.isAfter(test1)); assertEquals(false, test3.isAfter(test2)); try { new LocalTime(10, 20, 35, 40).isAfter(null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testWithField_DateTimeFieldType_int_1() { LocalTime test = new LocalTime(10, 20, 30, 40); LocalTime result = test.withField(DateTimeFieldType.hourOfDay(), 15); assertEquals(new LocalTime(10, 20, 30, 40), test); assertEquals(new LocalTime(15, 20, 30, 40), result); } public void testWithField_DateTimeFieldType_int_2() { LocalTime test = new LocalTime(10, 20, 30, 40); try { test.withField(null, 6); fail(); } catch (IllegalArgumentException ex) { } } public void testWithField_DateTimeFieldType_int_3() { LocalTime test = new LocalTime(10, 20, 30, 40); try { test.withField(DateTimeFieldType.dayOfMonth(), 6); fail(); } catch (IllegalArgumentException ex) { } } public void testWithField_DateTimeFieldType_int_4() { LocalTime test = new LocalTime(10, 20, 30, 40); LocalTime result = test.withField(DateTimeFieldType.hourOfDay(), 10); assertSame(test, result); } // ----------------------------------------------------------------------- public void testWithFieldAdded_DurationFieldType_int_1() { LocalTime test = new LocalTime(10, 20, 30, 40); LocalTime result = test.withFieldAdded(DurationFieldType.hours(), 6); assertEquals(new LocalTime(10, 20, 30, 40), test); assertEquals(new LocalTime(16, 20, 30, 40), result); } public void testWithFieldAdded_DurationFieldType_int_2() { LocalTime test = new LocalTime(10, 20, 30, 40); try { test.withFieldAdded(null, 0); fail(); } catch (IllegalArgumentException ex) { } } public void testWithFieldAdded_DurationFieldType_int_3() { LocalTime test = new LocalTime(10, 20, 30, 40); try { test.withFieldAdded(null, 6); fail(); } catch (IllegalArgumentException ex) { } } public void testWithFieldAdded_DurationFieldType_int_4() { LocalTime test = new LocalTime(10, 20, 30, 40); LocalTime result = test.withFieldAdded(DurationFieldType.hours(), 0); assertSame(test, result); } public void testWithFieldAdded_DurationFieldType_int_5() { LocalTime test = new LocalTime(10, 20, 30, 40); try { test.withFieldAdded(DurationFieldType.days(), 6); fail(); } catch (IllegalArgumentException ex) { } } public void testWithFieldAdded_DurationFieldType_int_6() { LocalTime test = new LocalTime(10, 20, 30, 40); LocalTime result = test.withFieldAdded(DurationFieldType.hours(), 16); assertEquals(new LocalTime(10, 20, 30, 40), test); assertEquals(new LocalTime(2, 20, 30, 40), result); } public void testWithFieldAdded_DurationFieldType_int_7() { LocalTime test = new LocalTime(23, 59, 59, 999); LocalTime result = test.withFieldAdded(DurationFieldType.millis(), 1); assertEquals(new LocalTime(0, 0, 0, 0), result); test = new LocalTime(23, 59, 59, 999); result = test.withFieldAdded(DurationFieldType.seconds(), 1); assertEquals(new LocalTime(0, 0, 0, 999), result); test = new LocalTime(23, 59, 59, 999); result = test.withFieldAdded(DurationFieldType.minutes(), 1); assertEquals(new LocalTime(0, 0, 59, 999), result); test = new LocalTime(23, 59, 59, 999); result = test.withFieldAdded(DurationFieldType.hours(), 1); assertEquals(new LocalTime(0, 59, 59, 999), result); } public void testWithFieldAdded_DurationFieldType_int_8() { LocalTime test = new LocalTime(0, 0, 0, 0); LocalTime result = test.withFieldAdded(DurationFieldType.millis(), -1); assertEquals(new LocalTime(23, 59, 59, 999), result); test = new LocalTime(0, 0, 0, 0); result = test.withFieldAdded(DurationFieldType.seconds(), -1); assertEquals(new LocalTime(23, 59, 59, 0), result); test = new LocalTime(0, 0, 0, 0); result = test.withFieldAdded(DurationFieldType.minutes(), -1); assertEquals(new LocalTime(23, 59, 0, 0), result); test = new LocalTime(0, 0, 0, 0); result = test.withFieldAdded(DurationFieldType.hours(), -1); assertEquals(new LocalTime(23, 0, 0, 0), result); } // ----------------------------------------------------------------------- public void testPlus_RP() { LocalTime test = new LocalTime(10, 20, 30, 40, BUDDHIST_LONDON); LocalTime result = test.plus(new Period(1, 2, 3, 4, 5, 6, 7, 8)); LocalTime expected = new LocalTime(15, 26, 37, 48, BUDDHIST_LONDON); assertEquals(expected, result); result = test.plus((ReadablePeriod) null); assertSame(test, result); } public void testPlusHours_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.plusHours(1); LocalTime expected = new LocalTime(2, 2, 3, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.plusHours(0); assertSame(test, result); } public void testPlusMinutes_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.plusMinutes(1); LocalTime expected = new LocalTime(1, 3, 3, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.plusMinutes(0); assertSame(test, result); } public void testPlusSeconds_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.plusSeconds(1); LocalTime expected = new LocalTime(1, 2, 4, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.plusSeconds(0); assertSame(test, result); } public void testPlusMillis_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.plusMillis(1); LocalTime expected = new LocalTime(1, 2, 3, 5, BUDDHIST_LONDON); assertEquals(expected, result); result = test.plusMillis(0); assertSame(test, result); } // ----------------------------------------------------------------------- public void testMinus_RP() { LocalTime test = new LocalTime(10, 20, 30, 40, BUDDHIST_LONDON); LocalTime result = test.minus(new Period(1, 1, 1, 1, 1, 1, 1, 1)); LocalTime expected = new LocalTime(9, 19, 29, 39, BUDDHIST_LONDON); assertEquals(expected, result); result = test.minus((ReadablePeriod) null); assertSame(test, result); } public void testMinusHours_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.minusHours(1); LocalTime expected = new LocalTime(0, 2, 3, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.minusHours(0); assertSame(test, result); } public void testMinusMinutes_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.minusMinutes(1); LocalTime expected = new LocalTime(1, 1, 3, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.minusMinutes(0); assertSame(test, result); } public void testMinusSeconds_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.minusSeconds(1); LocalTime expected = new LocalTime(1, 2, 2, 4, BUDDHIST_LONDON); assertEquals(expected, result); result = test.minusSeconds(0); assertSame(test, result); } public void testMinusMillis_int() { LocalTime test = new LocalTime(1, 2, 3, 4, BUDDHIST_LONDON); LocalTime result = test.minusMillis(1); LocalTime expected = new LocalTime(1, 2, 3, 3, BUDDHIST_LONDON); assertEquals(expected, result); result = test.minusMillis(0); assertSame(test, result); } // ----------------------------------------------------------------------- public void testGetters() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(10, test.getHourOfDay()); assertEquals(20, test.getMinuteOfHour()); assertEquals(30, test.getSecondOfMinute()); assertEquals(40, test.getMillisOfSecond()); assertEquals(TEST_TIME_NOW, test.getMillisOfDay()); } // ----------------------------------------------------------------------- public void testWithers() { LocalTime test = new LocalTime(10, 20, 30, 40); check(test.withHourOfDay(6), 6, 20, 30, 40); check(test.withMinuteOfHour(6), 10, 6, 30, 40); check(test.withSecondOfMinute(6), 10, 20, 6, 40); check(test.withMillisOfSecond(6), 10, 20, 30, 6); check(test.withMillisOfDay(61234), 0, 1, 1, 234); try { test.withHourOfDay(-1); fail(); } catch (IllegalArgumentException ex) { } try { test.withHourOfDay(24); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testToDateTimeTodayDefaultZone() { LocalTime base = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); // PARIS irrelevant DateTime dt = new DateTime(2004, 6, 9, 6, 7, 8, 9); DateTimeUtils.setCurrentMillisFixed(dt.getMillis()); DateTime test = base.toDateTimeToday(); check(base, 10, 20, 30, 40); DateTime expected = new DateTime(dt.getMillis(), COPTIC_LONDON); expected = expected.hourOfDay().setCopy(10); expected = expected.minuteOfHour().setCopy(20); expected = expected.secondOfMinute().setCopy(30); expected = expected.millisOfSecond().setCopy(40); assertEquals(expected, test); } // ----------------------------------------------------------------------- public void testToDateTimeToday_Zone() { LocalTime base = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); // PARIS irrelevant DateTime dt = new DateTime(2004, 6, 9, 6, 7, 8, 9); DateTimeUtils.setCurrentMillisFixed(dt.getMillis()); DateTime test = base.toDateTimeToday(TOKYO); check(base, 10, 20, 30, 40); DateTime expected = new DateTime(dt.getMillis(), COPTIC_TOKYO); expected = expected.hourOfDay().setCopy(10); expected = expected.minuteOfHour().setCopy(20); expected = expected.secondOfMinute().setCopy(30); expected = expected.millisOfSecond().setCopy(40); assertEquals(expected, test); } public void testToDateTimeToday_nullZone() { LocalTime base = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); // PARIS irrelevant DateTime dt = new DateTime(2004, 6, 9, 6, 7, 8, 9); DateTimeUtils.setCurrentMillisFixed(dt.getMillis()); DateTime test = base.toDateTimeToday((DateTimeZone) null); check(base, 10, 20, 30, 40); DateTime expected = new DateTime(dt.getMillis(), COPTIC_LONDON); expected = expected.hourOfDay().setCopy(10); expected = expected.minuteOfHour().setCopy(20); expected = expected.secondOfMinute().setCopy(30); expected = expected.millisOfSecond().setCopy(40); assertEquals(expected, test); } // ----------------------------------------------------------------------- public void testToDateTime_RI() { LocalTime base = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); DateTime dt = new DateTime(0L); // LONDON zone assertEquals("1970-01-01T01:00:00.000+01:00", dt.toString()); DateTime test = base.toDateTime(dt); check(base, 10, 20, 30, 40); assertEquals("1970-01-01T01:00:00.000+01:00", dt.toString()); assertEquals("1970-01-01T10:20:30.040+01:00", test.toString()); } public void testToDateTime_nullRI() { LocalTime base = new LocalTime(1, 2, 3, 4); DateTimeUtils.setCurrentMillisFixed(TEST_TIME2); DateTime test = base.toDateTime((ReadableInstant) null); check(base, 1, 2, 3, 4); assertEquals("1970-01-02T01:02:03.004+01:00", test.toString()); } // ----------------------------------------------------------------------- public void testProperty() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals(test.hourOfDay(), test.property(DateTimeFieldType.hourOfDay())); assertEquals(test.minuteOfHour(), test.property(DateTimeFieldType.minuteOfHour())); assertEquals(test.secondOfMinute(), test.property(DateTimeFieldType.secondOfMinute())); assertEquals(test.millisOfSecond(), test.property(DateTimeFieldType.millisOfSecond())); assertEquals(test.millisOfDay(), test.property(DateTimeFieldType.millisOfDay())); assertEquals(test, test.property(DateTimeFieldType.minuteOfDay()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.secondOfDay()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.millisOfDay()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.hourOfHalfday()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.halfdayOfDay()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.clockhourOfHalfday()).getLocalTime()); assertEquals(test, test.property(DateTimeFieldType.clockhourOfDay()).getLocalTime()); try { test.property(DateTimeFieldType.dayOfWeek()); fail(); } catch (IllegalArgumentException ex) { } try { test.property(null); fail(); } catch (IllegalArgumentException ex) { } } // ----------------------------------------------------------------------- public void testSerialization() throws Exception { LocalTime test = new LocalTime(10, 20, 30, 40, COPTIC_PARIS); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(test); oos.close(); byte[] bytes = baos.toByteArray(); ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bais); LocalTime result = (LocalTime) ois.readObject(); ois.close(); assertEquals(test, result); assertTrue(Arrays.equals(test.getValues(), result.getValues())); assertTrue(Arrays.equals(test.getFields(), result.getFields())); assertEquals(test.getChronology(), result.getChronology()); } // ----------------------------------------------------------------------- public void testToString() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals("10:20:30.040", test.toString()); } // ----------------------------------------------------------------------- public void testToString_String() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals("\ufffd\ufffd\ufffd\ufffd 10", test.toString("yyyy HH")); assertEquals("10:20:30.040", test.toString((String) null)); } // ----------------------------------------------------------------------- public void testToString_String_Locale() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals("10 20", test.toString("H m", Locale.ENGLISH)); assertEquals("10:20:30.040", test.toString(null, Locale.ENGLISH)); assertEquals("10 20", test.toString("H m", null)); assertEquals("10:20:30.040", test.toString(null, null)); } // ----------------------------------------------------------------------- public void testToString_DTFormatter() { LocalTime test = new LocalTime(10, 20, 30, 40); assertEquals( "\ufffd\ufffd\ufffd\ufffd 10", test.toString(DateTimeFormat.forPattern("yyyy HH"))); assertEquals("10:20:30.040", test.toString((DateTimeFormatter) null)); } // ----------------------------------------------------------------------- private void check(LocalTime test, int hour, int min, int sec, int milli) { assertEquals(hour, test.getHourOfDay()); assertEquals(min, test.getMinuteOfHour()); assertEquals(sec, test.getSecondOfMinute()); assertEquals(milli, test.getMillisOfSecond()); } }