/** * Determines if a given day contains a leap second. * @param julianDayNumber The day, specified as a Julian day number. * @return true if the day contains a leap second, otherwise false. */ public final boolean doesDayHaveLeapSecond(int julianDayNumber) { LeapSecond potentialLeapSecond = new LeapSecond(new JulianDate(julianDayNumber, 43200D, TimeStandard.COORDINATED_UNIVERSAL_TIME), 0.0); return Collections.binarySearch(m_leapSeconds, potentialLeapSecond, s_leapSecondComparer) >= 0; }
/** * Gets the {@link JulianDate} that represents the current date and time. The time standard will be Coordinated Universal Time (UTC). */ @Nonnull public static JulianDate getNow() { return new JulianDate(DateTimeHelper.utcNow()); }
@Nonnull private final JulianDate getDateForIndex(int index) { if (index < 0) { return new JulianDate(0, 0.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); } return m_leapSeconds.get(index).getDate(); }
/** * Tests the IsEmpty property. */ @Test public final void testIsEmpty() { TimeInterval interval = new TimeInterval(new JulianDate(1.0), new JulianDate(1.0)); Assert.assertTrue(interval.getIsEmpty()); interval = new TimeInterval(new JulianDate(5.0), new JulianDate(4.0)); Assert.assertTrue(interval.getIsEmpty()); }
@Nonnull private final JulianDate addIgnoringTimeStandard(@Nonnull Duration duration) { int days = getDay() + duration.getDays(); double seconds = getSecondsOfDay() + duration.getSeconds(); return new JulianDate(days, seconds, getStandard()); }
/** * Tests the {@link TimeInterval#toString} method */ @Test public final void testToString() { TimeInterval interval = new TimeInterval(new JulianDate(2451545, 0.00), new JulianDate(2451546, 0.00)); Assert.assertEquals("[2451545:0 TAI (1/1/2000 11:59:28 AM), 2451546:0 TAI (1/2/2000 11:59:28 AM)]", interval.toString()); }
/** * Converts this date to {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI). * @return An equivalent date expressed in TAI. */ @Nonnull public final JulianDate toInternationalAtomicTime() { if (getStandard() == TimeStandard.INTERNATIONAL_ATOMIC_TIME) { return this; } return new JulianDate(getDay(), getSecondsOfDay() + LeapSeconds.getInstance().getTaiMinusUtc(this), TimeStandard.INTERNATIONAL_ATOMIC_TIME); }
/** * Tests that the {@link JulianDate#equalsEpsilon} method returns true when the difference is exactly epsilon. */ @Test public final void testEqualsEpsilonExact() { JulianDate first = new JulianDate(2451545, 0.2); JulianDate second = new JulianDate(2451545, 0.2); Assert.assertTrue(second.equalsEpsilon(first, 0D)); }
@Test public final void testConstructorRequiresUTC() { ExpectedExceptionHelper.expectException(getRule$expectedException(), ArgumentException.class, "The given date must be in the UTC time standard", MessageMatch.CONTAINS); // ReSharper disable once UnusedVariable cesiumlanguagewriter.LeapSecond leapSecond = new LeapSecond(new JulianDate(2451545.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME), 100.0); }
@Test public final void testJulianSecondsOfDay() { final double julianSecondsOfDay = 0.05486; GregorianDate gd = new GregorianDate(new JulianDate(2046050, julianSecondsOfDay, TimeStandard.COORDINATED_UNIVERSAL_TIME)); Assert.assertEquals(julianSecondsOfDay, gd.getJulianSecondsOfDay(), Constants.Epsilon11); }
@Test public final void testEqualityOfLeapSeconds() { JulianDate leapSecond = new JulianDate(2453736, 43233D, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate utcDate = new JulianDate(2453736, 43233D, TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertFalse(utcDate.equalsType(leapSecond)); Assert.assertFalse(leapSecond.equalsType(utcDate)); }
/** * Tests the JulianDate override of the {@link Object#toString} method. */ @Test public final void testToString() { JulianDate date = new JulianDate(2451545.5); Assert.assertEquals("2451545:43200 TAI (1/1/2000 11:59:28 PM)", date.toString()); }
/** * Tests the ToString of LeapSecond. */ @Test public final void testToString() { LeapSecond leapSecond = new LeapSecond(2451545.0, 100.0); String expected = StringHelper.format("2451545:0 UTC ({0}), 100", new GregorianDate(new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME))); Assert.assertEquals(expected, leapSecond.toString()); }
@Before public final void setUp() { m_startDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 0, 0D)); m_isoStartString = CesiumFormattingHelper.toIso8601(m_startDate, Iso8601Format.COMPACT); m_stopDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 1, 0D)); m_isoIntervalString = CesiumFormattingHelper.toIso8601Interval(m_startDate, m_stopDate, Iso8601Format.COMPACT); }
/** * Tests that the look-up operation produces the correct result when using the {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} standard. */ @Test public final void testGetOffsetTai() { JulianDate date = new JulianDate(2453736, 43222.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); LeapSeconds leapSeconds = new LeapSeconds(); Assert.assertEquals(32, leapSeconds.getTaiMinusUtc(date), 0d); }
/** * Tests that a {@link JulianDate} in the {@link TimeStandard#COORDINATED_UNIVERSAL_TIME} standard cannot correctly represent a day containing a leap second. */ @Test public final void testJulianDateCannotRepresentMomentOfLeapSecond() { ExpectedExceptionHelper.expectException(getRule$expectedException(), ArgumentOutOfRangeException.class); JulianDate momentOfLeapSecond = new JulianDate(2453736, 43232.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); momentOfLeapSecond.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); }
/** * Tests that initialization of and access to the structure day and time elements is performed correctly. */ @Test public final void testRetainValue() { JulianDate date = new JulianDate(100, 123.456789012); Assert.assertEquals((int) 100, (int) date.getDay()); Assert.assertEquals(123.456789012, date.getSecondsOfDay(), 0d); }
@Test public final void testSecondsDifferenceAtLeapSecond() { JulianDate leapSecond = new JulianDate(2453736, 43232D, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate utcDate = new JulianDate(2453736, 43232D, TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(-33, utcDate.secondsDifference(leapSecond), 0d); Assert.assertEquals(33, leapSecond.secondsDifference(utcDate), 0d); JulianDate secondBeforeLeapSecondUTC = leapSecond.subtractSeconds(1D).toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); JulianDate secondAfterLeapSecondUTC = leapSecond.addSeconds(1D).toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(2, secondBeforeLeapSecondUTC.secondsDifference(secondAfterLeapSecondUTC), 0d); Assert.assertEquals(2, secondAfterLeapSecondUTC.subtract(secondBeforeLeapSecondUTC).getSeconds(), 0d); }
/** * Tests that the Duration of an Interval is calculated correctly. */ @Test public final void testCalculateDuration() { JulianDate start = new JulianDate(2451545.0); JulianDate stop = JulianDate.add(start, Duration.fromDays(1.5)); TimeInterval interval = new TimeInterval(start, stop); AssertHelper.assertEquals(Duration.fromDays(1.5), interval.toDuration()); }
@Test public final void julianDateGregorianDateRoundTrip() { GregorianDate gregorianDate = new GregorianDate(2008, 1, 1, 1, 1, 1.00000000008); JulianDate julianDate = new JulianDate(gregorianDate); GregorianDate roundTrip = julianDate.toGregorianDate(); Assert.assertEquals((int) gregorianDate.getYear(), (int) roundTrip.getYear()); Assert.assertEquals((int) gregorianDate.getMonth(), (int) roundTrip.getMonth()); Assert.assertEquals((int) gregorianDate.getDay(), (int) roundTrip.getDay()); Assert.assertEquals((int) gregorianDate.getHour(), (int) roundTrip.getHour()); Assert.assertEquals((int) gregorianDate.getMinute(), (int) roundTrip.getMinute()); Assert.assertEquals(gregorianDate.getSecond(), roundTrip.getSecond(), Constants.Epsilon13); }