/** * Initializes a {@link JulianDate} from a {@link GregorianDate}. The time standard will be {@link TimeStandard#COORDINATED_UNIVERSAL_TIME} (UTC), except when the {@code gregorianDate} represents time during a leap second. During a leap second, the {@link JulianDate} will be in the {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI) standard. * @param gregorianDate The {@link GregorianDate} to use to specify the {@link JulianDate}. */ public JulianDate(@Nonnull GregorianDate gregorianDate) { JulianDate converted = gregorianDate.toJulianDate(); m_day = converted.m_day; m_secondsOfDay = converted.m_secondsOfDay; m_timeStandard = converted.m_timeStandard; }
/** * Convert this {@link GregorianDate} to a {@link JulianDate}. The time standard will be {@link TimeStandard#COORDINATED_UNIVERSAL_TIME} (UTC), unless this {@link GregorianDate} represents the instant of a leap second, in which case the {@link JulianDate} will be in {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI). * @return A {@link JulianDate} representing this date. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final JulianDate toJulianDate() { return toJulianDate(TimeStandard.COORDINATED_UNIVERSAL_TIME); }
/** * Initializes a {@link JulianDate} from a {@link GregorianDate} where the {@link GregorianDate} is expressed in the given {@link TimeStandard}. If the date is during a leap second, the {@link JulianDate} will be expressed in {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI). * @param gregorianDate The {@link GregorianDate}. * @param standard The time standard in which the {@code gregorianDate} is expressed. */ public JulianDate(@Nonnull GregorianDate gregorianDate, @Nonnull TimeStandard standard) { JulianDate converted = gregorianDate.toJulianDate(standard); m_day = converted.m_day; m_secondsOfDay = converted.m_secondsOfDay; m_timeStandard = converted.getStandard(); }
@Nonnull private final GregorianDate rolloverTime(double days, double hours, double minutes, double seconds, @Nonnull TimeStandard timeStandard) { int wholeDays = (int) days; seconds += (days - wholeDays) * TimeConstants.SecondsPerDay; int wholeHours = (int) hours; seconds += (hours - wholeHours) * TimeConstants.SecondsPerHour; int wholeMinutes = (int) minutes; seconds += (minutes - wholeMinutes) * TimeConstants.SecondsPerMinute; Duration timeToAdd = new Duration(wholeDays, wholeHours, wholeMinutes, seconds); JulianDate julianResult = toJulianDate(timeStandard).add(timeToAdd); return new GregorianDate(julianResult, timeStandard); }
/** * Returns the value of this {@link JulianDate} in the standard format. * @return The string. */ @Override public String toString() { StringBuilder builder = new StringBuilder(); StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), "{0}:{1} ", m_day, m_secondsOfDay); builder.append(getStandard() == TimeStandard.COORDINATED_UNIVERSAL_TIME ? "UTC" : "TAI"); if (JulianDate.lessThan(this, GregorianDate.MinValue.toJulianDate())) { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " (before {0})", GregorianDate.MinValue); } else if (JulianDate.greaterThan(this, GregorianDate.MaxValue.toJulianDate())) { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " (after {0})", GregorianDate.MaxValue); } else { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " ({0})", toGregorianDate()); } return builder.toString(); }
@Test public final void testConversionToJulianDate() { GregorianDate date = new GregorianDate(2008, 12, 31, 23, 59, 0D); JulianDate julianDate = date.toJulianDate(); GregorianDate oneSecondLater = new GregorianDate(2008, 12, 31, 23, 59, 1D); GregorianDate oneSecondBefore = new GregorianDate(2008, 12, 31, 23, 58, 59D); Assert.assertEquals(1, oneSecondLater.toJulianDate().subtract(julianDate).getSeconds(), 0d); Assert.assertEquals(1, julianDate.subtract(oneSecondBefore.toJulianDate()).getSeconds(), 0d); }
@Test public final void canConvertGregorianDateRepresentingLeapSecondToJulianDate() { GregorianDate leapSecondGregorianDate = new GregorianDate(2008, 12, 31, 23, 59, 60D); JulianDate leapSecondJulianDate = leapSecondGregorianDate.toJulianDate(); AssertHelper.assertEquals(leapSecondGregorianDate, leapSecondJulianDate.toGregorianDate()); GregorianDate oneSecondLater = new GregorianDate(2009, 1, 1, 0, 0, 0D); GregorianDate oneSecondBefore = new GregorianDate(2008, 12, 31, 23, 59, 59D); Assert.assertEquals(1, oneSecondLater.toJulianDate().subtract(leapSecondJulianDate).getSeconds(), 0d); Assert.assertEquals(1, leapSecondJulianDate.subtract(oneSecondBefore.toJulianDate()).getSeconds(), 0d); }
@Test public final void testRoundTripDefaultConstructed() { GregorianDate gd = new GregorianDate(); GregorianDate gd2 = new GregorianDate(gd.toJulianDate()); AssertHelper.assertEquals(gd, gd2); }
@Test public final void maxValueRoundTripsThroughJulianDate() { JulianDate max = GregorianDate.MaxValue.toJulianDate(); GregorianDate date = max.toGregorianDate(); String iso = date.toIso8601String(Iso8601Format.EXTENDED, 6); String expected = GregorianDate.MaxValue.toIso8601String(Iso8601Format.EXTENDED, 6); Assert.assertEquals(expected, iso); }
@Test public final void booleanCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { BooleanCesiumWriter writer = new BooleanCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeBoolean(false); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"boolean\":false}}", getStringWriter().toString()); }
@Test public final void labelStyleCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_11 = (getPacket()); try { { LabelStyleCesiumWriter writer = new LabelStyleCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeLabelStyle(CesiumLabelStyle.FILL_AND_OUTLINE); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_11); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"labelStyle\":\"FILL_AND_OUTLINE\"}}", getStringWriter().toString()); }
@Test public final void doubleCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { DoubleCesiumWriter writer = new DoubleCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeNumber(1.23); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"number\":1.23}}", getStringWriter().toString()); }
@Test public final void verticalOriginCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { VerticalOriginCesiumWriter writer = new VerticalOriginCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeVerticalOrigin(CesiumVerticalOrigin.CENTER); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"verticalOrigin\":\"CENTER\"}}", getStringWriter().toString()); }
@Test public final void labelStyleCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { LabelStyleCesiumWriter writer = new LabelStyleCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeLabelStyle(CesiumLabelStyle.FILL_AND_OUTLINE); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"labelStyle\":\"FILL_AND_OUTLINE\"}}", getStringWriter().toString()); }
@Test public final void horizontalOriginCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { HorizontalOriginCesiumWriter writer = new HorizontalOriginCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeHorizontalOrigin(CesiumHorizontalOrigin.CENTER); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"horizontalOrigin\":\"CENTER\"}}", getStringWriter().toString()); }
@Test public final void stringCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_1 = (getPacket()); try { { StringCesiumWriter writer = new StringCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeString("bar"); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_1); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"string\":\"bar\"}}", getStringWriter().toString()); }
@Test public final void doubleCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_3 = (getPacket()); try { { DoubleCesiumWriter writer = new DoubleCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeNumber(1.23); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_3); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"number\":1.23}}", getStringWriter().toString()); }
@Test public final void verticalOriginCanBeWrittenInsideInterval() { JulianDate startDate = new GregorianDate(2012, 6, 7, 12, 0, 0D).toJulianDate(); { final PacketCesiumWriter usingExpression_7 = (getPacket()); try { { VerticalOriginCesiumWriter writer = new VerticalOriginCesiumWriter("foo"); try { writer.open(getOutputStream()); writer.writeInterval(startDate, startDate.addSeconds(100.0)); writer.writeVerticalOrigin(CesiumVerticalOrigin.CENTER); } finally { DisposeHelper.dispose(writer); } } } finally { DisposeHelper.dispose(usingExpression_7); } } Assert.assertEquals("{\"foo\":{\"interval\":\"20120607T12Z/20120607T120140Z\",\"verticalOrigin\":\"CENTER\"}}", getStringWriter().toString()); }
@Test public final void testNonStandardTimeStandard() { GregorianDate gregorianDate = new GregorianDate(2008, 12, 31, 23, 59, 40D); JulianDate jd = gregorianDate.toJulianDate(TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, jd.getStandard()); GregorianDate roundTrip1 = jd.toGregorianDate(TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(gregorianDate, roundTrip1); GregorianDate roundTrip = new GregorianDate(jd); AssertHelper.assertNotEqual(gregorianDate, roundTrip); double expectedDifference = LeapSeconds.getInstance().getTaiMinusUtc(jd); Assert.assertEquals(expectedDifference, gregorianDate.getSecond() - roundTrip.getSecond(), 0d); }
@Test public final void passClampToIso8601() { String expected = GregorianDate.MinValue.toIso8601String(Iso8601Format.BASIC); String actual = CesiumFormattingHelper.toIso8601(JulianDate.getMinValue(), Iso8601Format.BASIC); Assert.assertEquals(expected, actual); actual = CesiumFormattingHelper.toIso8601(GregorianDate.MinValue.toJulianDate(), Iso8601Format.BASIC); Assert.assertEquals(expected, actual); expected = GregorianDate.MaxValue.toIso8601String(Iso8601Format.BASIC); actual = CesiumFormattingHelper.toIso8601(JulianDate.getMaxValue(), Iso8601Format.BASIC); Assert.assertEquals(expected, actual); actual = CesiumFormattingHelper.toIso8601(GregorianDate.MaxValue.toJulianDate(), Iso8601Format.BASIC); Assert.assertEquals(expected, actual); expected = GregorianDate.MinValue.toIso8601String(Iso8601Format.EXTENDED); actual = CesiumFormattingHelper.toIso8601(JulianDate.getMinValue(), Iso8601Format.EXTENDED); Assert.assertEquals(expected, actual); expected = GregorianDate.MaxValue.toIso8601String(Iso8601Format.EXTENDED); actual = CesiumFormattingHelper.toIso8601(JulianDate.getMaxValue(), Iso8601Format.EXTENDED); Assert.assertEquals(expected, actual); expected = GregorianDate.MinValue.toIso8601String(Iso8601Format.COMPACT); actual = CesiumFormattingHelper.toIso8601(JulianDate.getMinValue(), Iso8601Format.COMPACT); Assert.assertEquals(expected, actual); expected = GregorianDate.MaxValue.toIso8601String(Iso8601Format.COMPACT); actual = CesiumFormattingHelper.toIso8601(JulianDate.getMaxValue(), Iso8601Format.COMPACT); Assert.assertEquals(expected, actual); }