8013730: JSR 310 DateTime API Updates III
Summary: Integration of JSR310 Date/Time API update III
Reviewed-by: naoto
Contributed-by: scolebourne@joda.org, roger.riggs@oracle.com, masayoshi.okutsu@oracle.com, patrick.zhang@oracle.com
--- a/jdk/src/share/classes/java/time/Clock.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Clock.java Wed May 15 07:48:57 2013 -0700
@@ -103,7 +103,7 @@
* system clock This may use {@link System#currentTimeMillis()}, or a higher
* resolution clock if one is available.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This abstract class must be implemented with care to ensure other operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* <p>
@@ -112,13 +112,23 @@
* obtain the time from a central time server across the network. Obviously, in this case the
* lookup could fail, and so the method is permitted to throw an exception.
* <p>
- * The returned instants from {@code Clock} work on a time-scale that ignores leap seconds.
- * If the implementation wraps a source that provides leap second information, then a mechanism
- * should be used to "smooth" the leap second, such as UTC-SLS.
+ * The returned instants from {@code Clock} work on a time-scale that ignores leap seconds,
+ * as described in {@link Instant}. If the implementation wraps a source that provides leap
+ * second information, then a mechanism should be used to "smooth" the leap second.
+ * The Java Time-Scale mandates the use of UTC-SLS, however clock implementations may choose
+ * how accurate they are with the time-scale so long as they document how they work.
+ * Implementations are therefore not required to actually perform the UTC-SLS slew or to
+ * otherwise be aware of leap seconds.
* <p>
* Implementations should implement {@code Serializable} wherever possible and must
* document whether or not they do support serialization.
*
+ * @implNote
+ * The clock implementation provided here is based on {@link System#currentTimeMillis()}.
+ * That method provides little to no guarantee about the accuracy of the clock.
+ * Applications requiring a more accurate clock must implement this abstract class
+ * themselves using a different external clock, such as an NTP server.
+ *
* @since 1.8
*/
public abstract class Clock {
@@ -370,7 +380,7 @@
/**
* Gets the current millisecond instant of the clock.
* <p>
- * This returns the millisecond-based instant, measured from 1970-01-01T00:00 UTC.
+ * This returns the millisecond-based instant, measured from 1970-01-01T00:00Z (UTC).
* This is equivalent to the definition of {@link System#currentTimeMillis()}.
* <p>
* Most applications should avoid this method and use {@link Instant} to represent
@@ -381,7 +391,7 @@
* The default implementation currently calls {@link #instant}.
*
* @return the current millisecond instant from this clock, measured from
- * the Java epoch of 1970-01-01T00:00 UTC, not null
+ * the Java epoch of 1970-01-01T00:00Z (UTC), not null
* @throws DateTimeException if the instant cannot be obtained, not thrown by most implementations
*/
public long millis() {
--- a/jdk/src/share/classes/java/time/DateTimeException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/DateTimeException.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
* This exception is used to indicate problems with creating, querying
* and manipulating date-time objects.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/DayOfWeek.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/DayOfWeek.java Wed May 15 07:48:57 2013 -0700
@@ -100,7 +100,7 @@
* As such, this enum may be used by any calendar system that has the day-of-week
* concept defined exactly equivalent to the ISO calendar system.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/Duration.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Duration.java Wed May 15 07:48:57 2013 -0700
@@ -118,7 +118,7 @@
* most applications.
* See {@link Instant} for a discussion as to the meaning of the second and time-scales.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/Instant.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Instant.java Wed May 15 07:48:57 2013 -0700
@@ -142,47 +142,60 @@
* introduce other changes.
* <p>
* Given the complexity of accurate timekeeping described above, this Java API defines
- * its own time-scale with a simplification. The Java time-scale is defined as follows:
+ * its own time-scale, the <i>Java Time-Scale</i>.
+ * <p>
+ * The Java Time-Scale divides each calendar day into exactly 86400
+ * subdivisions, known as seconds. These seconds may differ from the
+ * SI second. It closely matches the de facto international civil time
+ * scale, the definition of which changes from time to time.
+ * <p>
+ * The Java Time-Scale has slightly different definitions for different
+ * segments of the time-line, each based on the consensus international
+ * time scale that is used as the basis for civil time. Whenever the
+ * internationally-agreed time scale is modified or replaced, a new
+ * segment of the Java Time-Scale must be defined for it. Each segment
+ * must meet these requirements:
* <p><ul>
- * <li>midday will always be exactly as defined by the agreed international civil time</li>
- * <li>other times during the day will be broadly in line with the agreed international civil time</li>
- * <li>the day will be divided into exactly 86400 subdivisions, referred to as "seconds"</li>
- * <li>the Java "second" may differ from an SI second</li>
- * <li>a well-defined algorithm must be specified to map each second in the accurate agreed
- * international civil time to each "second" in this time-scale</li>
+ * <li>the Java Time-Scale shall closely match the underlying international
+ * civil time scale;</li>
+ * <li>the Java Time-Scale shall exactly match the international civil
+ * time scale at noon each day;</li>
+ * <li>the Java Time-Scale shall have a precisely-defined relationship to
+ * the international civil time scale.</li>
* </ul><p>
- * Agreed international civil time is the base time-scale agreed by international convention,
- * which in 2012 is UTC (with leap-seconds).
- * <p>
- * In 2012, the definition of the Java time-scale is the same as UTC for all days except
- * those where a leap-second occurs. On days where a leap-second does occur, the time-scale
- * effectively eliminates the leap-second, maintaining the fiction of 86400 seconds in the day.
- * The approved well-defined algorithm to eliminate leap-seconds is specified as
- * <a href="http://www.cl.cam.ac.uk/~mgk25/time/utc-sls/">UTC-SLS</a>.
+ * There are currently, as of 2013, two segments in the Java time-scale.
* <p>
- * UTC-SLS is a simple algorithm that smoothes the leap-second over the last 1000 seconds of
- * the day, making each of the last 1000 seconds 1/1000th longer or shorter than an SI second.
- * Implementations built on an accurate leap-second aware time source should use UTC-SLS.
- * Use of a different algorithm risks confusion and misinterpretation of instants around a
- * leap-second and is discouraged.
+ * For the segment from 1972-11-03 (exact boundary discussed below) until
+ * further notice, the consensus international time scale is UTC (with
+ * leap seconds). In this segment, the Java Time-Scale is identical to
+ * <a href="http://www.cl.cam.ac.uk/~mgk25/time/utc-sls/">UTC-SLS</a>.
+ * This is identical to UTC on days that do not have a leap second.
+ * On days that do have a leap second, the leap second is spread equally
+ * over the last 1000 seconds of the day, maintaining the appearance of
+ * exactly 86400 seconds per day.
* <p>
- * The main benefit of always dividing the day into 86400 subdivisions is that it matches the
- * expectations of most users of the API. The alternative is to force every user to understand
- * what a leap second is and to force them to have special logic to handle them.
- * Most applications do not have access to a clock that is accurate enough to record leap-seconds.
- * Most applications also do not have a problem with a second being a very small amount longer or
- * shorter than a real SI second during a leap-second.
+ * For the segment prior to 1972-11-03, extending back arbitrarily far,
+ * the consensus international time scale is defined to be UT1, applied
+ * proleptically, which is equivalent to the (mean) solar time on the
+ * prime meridian (Greenwich). In this segment, the Java Time-Scale is
+ * identical to the consensus international time scale. The exact
+ * boundary between the two segments is the instant where UT1 = UTC
+ * between 1972-11-03T00:00 and 1972-11-04T12:00.
* <p>
- * One final problem is the definition of the agreed international civil time before the
- * introduction of modern UTC in 1972. This includes the Java epoch of {@code 1970-01-01}.
- * It is intended that instants before 1972 be interpreted based on the solar day divided
- * into 86400 subdivisions, as per the principles of UT1.
+ * Implementations of the Java time-scale using the JSR-310 API are not
+ * required to provide any clock that is sub-second accurate, or that
+ * progresses monotonically or smoothly. Implementations are therefore
+ * not required to actually perform the UTC-SLS slew or to otherwise be
+ * aware of leap seconds. JSR-310 does, however, require that
+ * implementations must document the approach they use when defining a
+ * clock representing the current instant.
+ * See {@link Clock} for details on the available clocks.
* <p>
* The Java time-scale is used for all date-time classes.
* This includes {@code Instant}, {@code LocalDate}, {@code LocalTime}, {@code OffsetDateTime},
* {@code ZonedDateTime} and {@code Duration}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -1030,16 +1043,16 @@
}
/**
- * Calculates the period between this instant and another instant in
- * terms of the specified unit.
+ * Calculates the amount of time until another instant in terms of the specified unit.
* <p>
- * This calculates the period between two instants in terms of a single unit.
+ * This calculates the amount of time between two {@code Instant}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified instant.
* The result will be negative if the end is before the start.
* The calculation returns a whole number, representing the number of
* complete units between the two instants.
* The {@code Temporal} passed to this method must be an {@code Instant}.
- * For example, the period in days between two dates can be calculated
+ * For example, the amount in days between two dates can be calculated
* using {@code startInstant.periodUntil(endInstant, SECONDS)}.
* <p>
* There are two equivalent ways of using this method.
@@ -1064,10 +1077,10 @@
* <p>
* This instance is immutable and unaffected by this method call.
*
- * @param endInstant the end date, which must be a {@code LocalDate}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date and the end date
- * @throws DateTimeException if the period cannot be calculated
+ * @param endInstant the end date, which must be an {@code Instant}, not null
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this instant and the end instant
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1075,7 +1088,7 @@
public long periodUntil(Temporal endInstant, TemporalUnit unit) {
if (endInstant instanceof Instant == false) {
Objects.requireNonNull(endInstant, "endInstant");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
Instant end = (Instant) endInstant;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/LocalDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/LocalDate.java Wed May 15 07:48:57 2013 -0700
@@ -121,7 +121,7 @@
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -1489,19 +1489,19 @@
}
/**
- * Calculates the period between this date and another date in
- * terms of the specified unit.
+ * Calculates the amount of time until another date in terms of the specified unit.
* <p>
- * This calculates the period between two dates in terms of a single unit.
+ * This calculates the amount of time between two {@code LocalDate}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified date.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a {@code LocalDate}.
- * For example, the period in days between two dates can be calculated
+ * For example, the amount in days between two dates can be calculated
* using {@code startDate.periodUntil(endDate, DAYS)}.
* <p>
* The calculation returns a whole number, representing the number of
* complete units between the two dates.
- * For example, the period in months between 2012-06-15 and 2012-08-14
+ * For example, the amount in months between 2012-06-15 and 2012-08-14
* will only be one month as it is one day short of two months.
* <p>
* There are two equivalent ways of using this method.
@@ -1527,9 +1527,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endDate the end date, which must be a {@code LocalDate}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date and the end date
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this date and the end date
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1538,7 +1538,7 @@
Objects.requireNonNull(unit, "unit");
if (endDate instanceof LocalDate == false) {
Objects.requireNonNull(endDate, "endDate");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
LocalDate end = (LocalDate) endDate;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/LocalDateTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/LocalDateTime.java Wed May 15 07:48:57 2013 -0700
@@ -119,7 +119,7 @@
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -1562,19 +1562,19 @@
}
/**
- * Calculates the period between this date-time and another date-time in
- * terms of the specified unit.
+ * Calculates the amount of time until another date-time in terms of the specified unit.
* <p>
- * This calculates the period between two date-times in terms of a single unit.
+ * This calculates the amount of time between two {@code LocalDateTime}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified date-time.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a {@code LocalDateTime}.
- * For example, the period in days between two date-times can be calculated
+ * For example, the amount in days between two date-times can be calculated
* using {@code startDateTime.periodUntil(endDateTime, DAYS)}.
* <p>
* The calculation returns a whole number, representing the number of
* complete units between the two date-times.
- * For example, the period in months between 2012-06-15T00:00 and 2012-08-14T23:59
+ * For example, the amount in months between 2012-06-15T00:00 and 2012-08-14T23:59
* will only be one month as it is one minute short of two months.
* <p>
* There are two equivalent ways of using this method.
@@ -1602,9 +1602,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endDateTime the end date-time, which must be a {@code LocalDateTime}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date-time and the end date-time
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this date-time and the end date-time
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1612,7 +1612,7 @@
public long periodUntil(Temporal endDateTime, TemporalUnit unit) {
if (endDateTime instanceof LocalDateTime == false) {
Objects.requireNonNull(endDateTime, "endDateTime");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
LocalDateTime end = (LocalDateTime) endDateTime;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/LocalTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/LocalTime.java Wed May 15 07:48:57 2013 -0700
@@ -109,7 +109,7 @@
* in most of the world. This API assumes that all calendar systems use the same
* representation, this class, for time-of-day.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -974,9 +974,6 @@
* Returns a {@code LocalTime} with the specified number of half-days added.
* This is equivalent to {@link #plusHours(long)} with the amount
* multiplied by 12.
- * <li>{@code DAYS} -
- * Returns a {@code LocalTime} with the specified number of days added.
- * This returns {@code this} time.
* </ul>
* <p>
* All other {@code ChronoUnit} instances will throw an {@code UnsupportedTemporalTypeException}.
@@ -1007,7 +1004,6 @@
case MINUTES: return plusMinutes(amountToAdd);
case HOURS: return plusHours(amountToAdd);
case HALF_DAYS: return plusHours((amountToAdd % 2) * 12);
- case DAYS: return this;
}
throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit.getName());
}
@@ -1291,19 +1287,19 @@
}
/**
- * Calculates the period between this time and another time in
- * terms of the specified unit.
+ * Calculates the amount of time until another time in terms of the specified unit.
* <p>
- * This calculates the period between two times in terms of a single unit.
+ * This calculates the amount of time between two {@code LocalTime}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified time.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a {@code LocalTime}.
- * For example, the period in hours between two times can be calculated
+ * For example, the amount in hours between two times can be calculated
* using {@code startTime.periodUntil(endTime, HOURS)}.
* <p>
* The calculation returns a whole number, representing the number of
* complete units between the two times.
- * For example, the period in hours between 11:30 and 13:29 will only
+ * For example, the amount in hours between 11:30 and 13:29 will only
* be one hour as it is one minute short of two hours.
* <p>
* There are two equivalent ways of using this method.
@@ -1329,9 +1325,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endTime the end time, which must be a {@code LocalTime}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this time and the end time
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this time and the end time
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1339,7 +1335,7 @@
public long periodUntil(Temporal endTime, TemporalUnit unit) {
if (endTime instanceof LocalTime == false) {
Objects.requireNonNull(endTime, "endTime");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
LocalTime end = (LocalTime) endTime;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/Month.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Month.java Wed May 15 07:48:57 2013 -0700
@@ -97,7 +97,7 @@
* As such, this enum may be used by any calendar system that has the month-of-year
* concept defined exactly equivalent to the ISO-8601 calendar system.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/MonthDay.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/MonthDay.java Wed May 15 07:48:57 2013 -0700
@@ -111,7 +111,7 @@
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/OffsetDateTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/OffsetDateTime.java Wed May 15 07:48:57 2013 -0700
@@ -111,7 +111,7 @@
* in simpler applications. This class may be used when modeling date-time concepts in
* more detail, or when communicating to a database or in a network protocol.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -1521,10 +1521,10 @@
}
/**
- * Calculates the period between this date-time and another date-time in
- * terms of the specified unit.
+ * Calculates the amount of time until another date-time in terms of the specified unit.
* <p>
- * This calculates the period between two date-times in terms of a single unit.
+ * This calculates the amount of time between two {@code OffsetDateTime}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified date-time.
* The result will be negative if the end is before the start.
* For example, the period in days between two date-times can be calculated
@@ -1564,9 +1564,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endDateTime the end date-time, which must be an {@code OffsetDateTime}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date-time and the end date-time
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this date-time and the end date-time
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1574,7 +1574,7 @@
public long periodUntil(Temporal endDateTime, TemporalUnit unit) {
if (endDateTime instanceof OffsetDateTime == false) {
Objects.requireNonNull(endDateTime, "endDateTime");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
if (unit instanceof ChronoUnit) {
OffsetDateTime end = (OffsetDateTime) endDateTime;
--- a/jdk/src/share/classes/java/time/OffsetTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/OffsetTime.java Wed May 15 07:48:57 2013 -0700
@@ -102,7 +102,7 @@
* For example, the value "13:45.30.123456789+02:00" can be stored
* in an {@code OffsetTime}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -1077,10 +1077,10 @@
}
/**
- * Calculates the period between this time and another time in
- * terms of the specified unit.
+ * Calculates the amount of time until another time in terms of the specified unit.
* <p>
- * This calculates the period between two times in terms of a single unit.
+ * This calculates the amount of time between two {@code OffsetTime}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified time.
* The result will be negative if the end is before the start.
* For example, the period in hours between two times can be calculated
@@ -1118,9 +1118,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endTime the end time, which must be an {@code OffsetTime}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this time and the end time
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this time and the end time
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -1128,7 +1128,7 @@
public long periodUntil(Temporal endTime, TemporalUnit unit) {
if (endTime instanceof OffsetTime == false) {
Objects.requireNonNull(endTime, "endTime");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
if (unit instanceof ChronoUnit) {
OffsetTime end = (OffsetTime) endTime;
--- a/jdk/src/share/classes/java/time/Period.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Period.java Wed May 15 07:48:57 2013 -0700
@@ -119,7 +119,7 @@
* The months and years fields may be {@linkplain #normalized() normalized}.
* The normalization assumes a 12 month year, so is not appropriate for all calendar systems.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/Ser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Ser.java Wed May 15 07:48:57 2013 -0700
@@ -66,7 +66,7 @@
/**
* The shared serialization delegate for this package.
*
- * <h3>Implementation notes</h3>
+ * @implNote
* This class wraps the object being serialized, and takes a byte representing the type of the class to
* be serialized. This byte can also be used for versioning the serialization format. In this case another
* byte flag would be used in order to specify an alternative version of the type format.
--- a/jdk/src/share/classes/java/time/Year.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/Year.java Wed May 15 07:48:57 2013 -0700
@@ -115,7 +115,7 @@
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -813,10 +813,10 @@
}
/**
- * Calculates the period between this year and another year in
- * terms of the specified unit.
+ * Calculates the amount of time until another year in terms of the specified unit.
* <p>
- * This calculates the period between two years in terms of a single unit.
+ * This calculates the amount of time between two {@code Year}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified year.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a {@code Year}.
@@ -851,9 +851,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endYear the end year, which must be a {@code Year}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this year and the end year
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this year and the end year
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -861,7 +861,7 @@
public long periodUntil(Temporal endYear, TemporalUnit unit) {
if (endYear instanceof Year == false) {
Objects.requireNonNull(endYear, "endYear");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
Year end = (Year) endYear;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/YearMonth.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/YearMonth.java Wed May 15 07:48:57 2013 -0700
@@ -110,7 +110,7 @@
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -944,10 +944,10 @@
}
/**
- * Calculates the period between this year-month and another year-month in
- * terms of the specified unit.
+ * Calculates the amount of time until another year-month in terms of the specified unit.
* <p>
- * This calculates the period between two year-months in terms of a single unit.
+ * This calculates the amount of time between two {@code YearMonth}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified year-month.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a {@code YearMonth}.
@@ -982,9 +982,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endYearMonth the end year-month, which must be a {@code YearMonth}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this year-month and the end year-month
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this year-month and the end year-month
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -992,7 +992,7 @@
public long periodUntil(Temporal endYearMonth, TemporalUnit unit) {
if (endYearMonth instanceof YearMonth == false) {
Objects.requireNonNull(endYearMonth, "endYearMonth");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
YearMonth end = (YearMonth) endYearMonth;
if (unit instanceof ChronoUnit) {
--- a/jdk/src/share/classes/java/time/ZoneId.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/ZoneId.java Wed May 15 07:48:57 2013 -0700
@@ -157,7 +157,7 @@
* This approach is designed to allow a {@link ZonedDateTime} to be loaded and
* queried, but not modified, on a Java Runtime with incomplete time-zone information.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This abstract class has two implementations, both of which are immutable and thread-safe.
* One implementation models region-based IDs, the other is {@code ZoneOffset} modelling
* offset-based IDs. This difference is visible in serialization.
--- a/jdk/src/share/classes/java/time/ZoneOffset.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/ZoneOffset.java Wed May 15 07:48:57 2013 -0700
@@ -114,7 +114,7 @@
* Implementations may choose to cache certain common offsets, however
* applications must not rely on such caching.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/ZoneRegion.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/ZoneRegion.java Wed May 15 07:48:57 2013 -0700
@@ -83,7 +83,7 @@
* By contrast, the region identifier is well-defined and long-lived.
* This separation also allows rules to be shared between regions if appropriate.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/ZonedDateTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/ZonedDateTime.java Wed May 15 07:48:57 2013 -0700
@@ -142,7 +142,7 @@
* a vital, but secondary, piece of information, used to ensure that the class
* represents an instant, especially during a daylight savings overlap.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* A {@code ZonedDateTime} holds state equivalent to three separate objects,
* a {@code LocalDateTime}, a {@code ZoneId} and the resolved {@code ZoneOffset}.
* The offset and local date-time are used to define an instant when necessary.
@@ -1983,10 +1983,10 @@
}
/**
- * Calculates the period between this date-time and another date-time in
- * terms of the specified unit.
+ * Calculates the amount of time until another date-time in terms of the specified unit.
* <p>
- * This calculates the period between two date-times in terms of a single unit.
+ * This calculates the amount of time between two {@code ZonedDateTime}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified date-time.
* The result will be negative if the end is before the start.
* For example, the period in days between two date-times can be calculated
@@ -2040,9 +2040,9 @@
* This instance is immutable and unaffected by this method call.
*
* @param endDateTime the end date-time, which must be a {@code ZonedDateTime}, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date-time and the end date-time
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this date-time and the end date-time
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@@ -2050,7 +2050,7 @@
public long periodUntil(Temporal endDateTime, TemporalUnit unit) {
if (endDateTime instanceof ZonedDateTime == false) {
Objects.requireNonNull(endDateTime, "endDateTime");
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
if (unit instanceof ChronoUnit) {
ZonedDateTime end = (ZonedDateTime) endDateTime;
--- a/jdk/src/share/classes/java/time/chrono/ChronoDateImpl.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoDateImpl.java Wed May 15 07:48:57 2013 -0700
@@ -130,7 +130,7 @@
* The subclass must function according to the {@code Chronology} class description and must provide its
* {@link java.time.chrono.Chronology#getId() chronlogy ID} and {@link Chronology#getCalendarType() calendar type}. </p>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This abstract class must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Subclasses should be Serializable wherever possible.
@@ -325,11 +325,11 @@
Objects.requireNonNull(endDateTime, "endDateTime");
Objects.requireNonNull(unit, "unit");
if (endDateTime instanceof ChronoLocalDate == false) {
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
ChronoLocalDate<?> end = (ChronoLocalDate<?>) endDateTime;
if (getChronology().equals(end.getChronology()) == false) {
- throw new DateTimeException("Unable to calculate period between two different chronologies");
+ throw new DateTimeException("Unable to calculate amount as objects have different chronologies");
}
if (unit instanceof ChronoUnit) {
switch ((ChronoUnit) unit) {
--- a/jdk/src/share/classes/java/time/chrono/ChronoLocalDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoLocalDate.java Wed May 15 07:48:57 2013 -0700
@@ -234,7 +234,7 @@
* Use {@link TemporalAccessor} if read-only access is required, or use {@link Temporal}
* if read-write access is required.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Subclasses should be Serializable wherever possible.
@@ -257,6 +257,7 @@
* This allows dates in different calendar systems to be compared based
* on the position of the date on the local time-line.
* The underlying comparison is equivalent to comparing the epoch-day.
+ * @return a comparator that compares in time-line order ignoring the chronology
*
* @see #isAfter
* @see #isBefore
@@ -510,17 +511,17 @@
}
/**
- * Calculates the period between this date and another date in
- * terms of the specified unit.
+ * Calculates the amount of time until another date in terms of the specified unit.
* <p>
- * This calculates the period between two dates in terms of a single unit.
+ * This calculates the amount of time between two {@code ChronoLocalDate}
+ * objects in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified date.
* The result will be negative if the end is before the start.
* The {@code Temporal} passed to this method must be a
* {@code ChronoLocalDate} in the same chronology.
* The calculation returns a whole number, representing the number of
* complete units between the two dates.
- * For example, the period in days between two dates can be calculated
+ * For example, the amount in days between two dates can be calculated
* using {@code startDate.periodUntil(endDate, DAYS)}.
* <p>
* There are two equivalent ways of using this method.
@@ -548,9 +549,9 @@
*
* @param endDate the end date, which must be a {@code ChronoLocalDate}
* in the same chronology, not null
- * @param unit the unit to measure the period in, not null
- * @return the amount of the period between this date and the end date
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this date and the end date
+ * @throws DateTimeException if the amount cannot be calculated
* @throws ArithmeticException if numeric overflow occurs
*/
@Override // override for Javadoc
--- a/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTime.java Wed May 15 07:48:57 2013 -0700
@@ -106,7 +106,7 @@
* Ensure that the discussion in {@code ChronoLocalDate} has been read and understood
* before using this interface.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Subclasses should be Serializable wherever possible.
@@ -127,6 +127,8 @@
* on the position of the date-time on the local time-line.
* The underlying comparison is equivalent to comparing the epoch-day and nano-of-day.
*
+ * @return a comparator that compares in time-line order ignoring the chronology
+ *
* @see #isAfter
* @see #isBefore
* @see #isEqual
--- a/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTimeImpl.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoLocalDateTimeImpl.java Wed May 15 07:48:57 2013 -0700
@@ -92,7 +92,7 @@
* It does not store or represent a time-zone. For example, the value
* "2nd October 2007 at 13:45.30.123456789" can be stored in an {@code ChronoLocalDateTime}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @param <D> the concrete type for the date of this date-time
@@ -353,12 +353,12 @@
@Override
public long periodUntil(Temporal endDateTime, TemporalUnit unit) {
if (endDateTime instanceof ChronoLocalDateTime == false) {
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
@SuppressWarnings("unchecked")
ChronoLocalDateTime<D> end = (ChronoLocalDateTime<D>) endDateTime;
if (toLocalDate().getChronology().equals(end.toLocalDate().getChronology()) == false) {
- throw new DateTimeException("Unable to calculate period between two different chronologies");
+ throw new DateTimeException("Unable to calculate amount as objects have different chronologies");
}
if (unit instanceof ChronoUnit) {
ChronoUnit f = (ChronoUnit) unit;
--- a/jdk/src/share/classes/java/time/chrono/ChronoZonedDateTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoZonedDateTime.java Wed May 15 07:48:57 2013 -0700
@@ -107,7 +107,7 @@
* Ensure that the discussion in {@code ChronoLocalDate} has been read and understood
* before using this interface.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Subclasses should be Serializable wherever possible.
@@ -128,6 +128,8 @@
* on the position of the date-time on the instant time-line.
* The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
*
+ * @return a comparator that compares in time-line order ignoring the chronology
+ *
* @see #isAfter
* @see #isBefore
* @see #isEqual
--- a/jdk/src/share/classes/java/time/chrono/ChronoZonedDateTimeImpl.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ChronoZonedDateTimeImpl.java Wed May 15 07:48:57 2013 -0700
@@ -95,7 +95,7 @@
* the local time-line overlaps, typically as a result of the end of daylight time.
* Information about the local-time can be obtained using methods on the time-zone.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @param <D> the concrete type for the date of this date-time
@@ -287,12 +287,12 @@
@Override
public long periodUntil(Temporal endDateTime, TemporalUnit unit) {
if (endDateTime instanceof ChronoZonedDateTime == false) {
- throw new DateTimeException("Unable to calculate period between objects of two different types");
+ throw new DateTimeException("Unable to calculate amount as objects are of two different types");
}
@SuppressWarnings("unchecked")
ChronoZonedDateTime<D> end = (ChronoZonedDateTime<D>) endDateTime;
if (toLocalDate().getChronology().equals(end.toLocalDate().getChronology()) == false) {
- throw new DateTimeException("Unable to calculate period between two different chronologies");
+ throw new DateTimeException("Unable to calculate amount as objects have different chronologies");
}
if (unit instanceof ChronoUnit) {
end = end.withZoneSameInstant(offset);
--- a/jdk/src/share/classes/java/time/chrono/Chronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/Chronology.java Wed May 15 07:48:57 2013 -0700
@@ -176,7 +176,7 @@
* CLDR specification then the calendar type is the concatenation of the
* CLDR type and, if applicable, the CLDR variant,
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Subclasses should be Serializable wherever possible.
@@ -338,16 +338,13 @@
* <p>
* The {@code Locale} class also supports an extension mechanism that
* can be used to identify a calendar system. The mechanism is a form
- * of key-value pairs, where the calendar system has the key "ca"
- * and an optional variant key "cv".
+ * of key-value pairs, where the calendar system has the key "ca".
* For example, the locale "en-JP-u-ca-japanese" represents the English
* language as used in Japan with the Japanese calendar system.
* <p>
* This method finds the desired calendar system by in a manner equivalent
* to passing "ca" to {@link Locale#getUnicodeLocaleType(String)}.
* If the "ca" key is not present, then {@code IsoChronology} is returned.
- * The variant, if present, is appended to the "ca" value separated by "-"
- * and the concatenated value is used to find the calendar system by type.
* <p>
* Note that the behavior of this method differs from the older
* {@link java.util.Calendar#getInstance(Locale)} method.
@@ -374,10 +371,6 @@
if (type == null || "iso".equals(type) || "iso8601".equals(type)) {
return IsoChronology.INSTANCE;
}
- String variant = locale.getUnicodeLocaleType("cv");
- if (variant != null && !variant.isEmpty()) {
- type = type + '-' + variant;
- }
// Not pre-defined; lookup by the type
do {
Chronology chrono = CHRONOS_BY_TYPE.get(type);
@@ -563,7 +556,7 @@
* and the variant, if applicable, is appended separated by "-".
* The calendar type is used to lookup the {@code Chronology} using {@link #of(String)}.
*
- * @return the calendar system type, null if the calendar is not defined
+ * @return the calendar system type, null if the calendar is not defined by CLDR/LDML
* @see #getId()
*/
public abstract String getCalendarType();
--- a/jdk/src/share/classes/java/time/chrono/Era.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/Era.java Wed May 15 07:48:57 2013 -0700
@@ -93,7 +93,7 @@
* <p>
* Instances of {@code Era} may be compared using the {@code ==} operator.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations must be singletons - final, immutable and thread-safe.
* It is recommended to use an enum whenever possible.
--- a/jdk/src/share/classes/java/time/chrono/HijrahChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/HijrahChronology.java Wed May 15 07:48:57 2013 -0700
@@ -133,9 +133,10 @@
* Chronology chrono = Chronology.ofLocale(locale);
* </pre>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
- * <h3>Implementation Note for Hijrah Calendar Variant Configuration</h3>
+ *
+ * @implNote
* Each Hijrah variant is configured individually. Each variant is defined by a
* property resource that defines the {@code ID}, the {@code calendar type},
* the start of the calendar, the alignment with the
@@ -230,6 +231,11 @@
*/
public static final HijrahChronology INSTANCE;
/**
+ * Flag to indicate the initialization of configuration data is complete.
+ * @see #checkCalendarInit()
+ */
+ private volatile boolean initComplete;
+ /**
* Array of epoch days indexed by Hijrah Epoch month.
* Computed by {@link #loadCalendarData}.
*/
@@ -285,7 +291,8 @@
private static final String PROP_TYPE_SUFFIX = ".type";
/**
- * Name data.
+ * Static initialization of the predefined calendars found in the
+ * lib/calendars.properties file.
*/
static {
try {
@@ -299,8 +306,7 @@
// Register it by its aliases
Chronology.registerChrono(INSTANCE, "Hijrah");
Chronology.registerChrono(INSTANCE, "islamic");
-
- } catch (Exception ex) {
+ } catch (DateTimeException ex) {
// Absence of Hijrah calendar is fatal to initializing this class.
PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
logger.severe("Unable to initialize Hijrah calendar: Hijrah-umalqura", ex);
@@ -327,7 +333,7 @@
// Create and register the variant
HijrahChronology chrono = new HijrahChronology(id);
Chronology.registerChrono(chrono);
- } catch (Exception ex) {
+ } catch (DateTimeException ex) {
// Log error and continue
PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
logger.severe("Unable to initialize Hijrah calendar: " + id, ex);
@@ -343,22 +349,39 @@
* The property names are {@code "calendar.hijrah." + id}
* and {@code "calendar.hijrah." + id + ".type"}
* @param id the id of the calendar
- * @throws Exception if the resource can not be accessed or
- * the format is invalid
+ * @throws DateTimeException if the calendar type is missing from the properties file.
+ * @throws IllegalArgumentException if the id is empty
*/
- private HijrahChronology(String id) throws Exception {
+ private HijrahChronology(String id) throws DateTimeException {
if (id.isEmpty()) {
throw new IllegalArgumentException("calendar id is empty");
}
+ String propName = PROP_PREFIX + id + PROP_TYPE_SUFFIX;
+ String calType = calendarProperties.getProperty(propName);
+ if (calType == null || calType.isEmpty()) {
+ throw new DateTimeException("calendarType is missing or empty for: " + propName);
+ }
this.typeId = id;
- this.calendarType = calendarProperties.getProperty(PROP_PREFIX + id + PROP_TYPE_SUFFIX);
+ this.calendarType = calType;
+ }
- try {
- String resource = calendarProperties.getProperty(PROP_PREFIX + id);
- Objects.requireNonNull(resource, "Resource missing for calendar");
- loadCalendarData(resource);
- } catch (Exception ex) {
- throw new Exception("Unable to initialize HijrahCalendar: " + id, ex);
+ /**
+ * Check and ensure that the calendar data has been initialized.
+ * The initialization check is performed at the boundary between
+ * public and package methods. If a public calls another public method
+ * a check is not necessary in the caller.
+ * The constructors of HijrahDate call {@link #getEpochDay} or
+ * {@link #getHijrahDateInfo} so every call from HijrahDate to a
+ * HijrahChronology via package private methods has been checked.
+ *
+ * @throws DateTimeException if the calendar data configuration is
+ * malformed or IOExceptions occur loading the data
+ */
+ private void checkCalendarInit() {
+ // Keep this short so it can be inlined for performance
+ if (initComplete == false) {
+ loadCalendarData();
+ initComplete = true;
}
}
@@ -509,6 +532,7 @@
//-----------------------------------------------------------------------
@Override
public boolean isLeapYear(long prolepticYear) {
+ checkCalendarInit();
int epochMonth = yearToEpochMonth((int) prolepticYear);
if (epochMonth < 0 || epochMonth > maxEpochDay) {
throw new DateTimeException("Hijrah date out of range");
@@ -543,6 +567,7 @@
//-----------------------------------------------------------------------
@Override
public ValueRange range(ChronoField field) {
+ checkCalendarInit();
if (field instanceof ChronoField) {
ChronoField f = field;
switch (f) {
@@ -595,6 +620,7 @@
* @return int[0] = YEAR, int[1] = MONTH, int[2] = DATE
*/
int[] getHijrahDateInfo(int epochDay) {
+ checkCalendarInit(); // ensure that the chronology is initialized
if (epochDay < minEpochDay || epochDay >= maxEpochDay) {
throw new DateTimeException("Hijrah date out of range");
}
@@ -621,6 +647,7 @@
* @return the epoch day
*/
long getEpochDay(int prolepticYear, int monthOfYear, int dayOfMonth) {
+ checkCalendarInit(); // ensure that the chronology is initialized
checkValidMonth(monthOfYear);
int epochMonth = yearToEpochMonth(prolepticYear) + (monthOfYear - 1);
if (epochMonth < 0 || epochMonth >= hijrahEpochMonthStartDays.length) {
@@ -846,84 +873,90 @@
}
/**
- * Loads and processes the Hijrah calendar properties file.
+ * Loads and processes the Hijrah calendar properties file for this calendarType.
* The starting Hijrah date and the corresponding ISO date are
* extracted and used to calculate the epochDate offset.
* The version number is identified and ignored.
* Everything else is the data for a year with containing the length of each
* of 12 months.
*
- * @param resourceName containing the properties defining the calendar, not null
- * @throws IllegalArgumentException if any of the values are malformed
- * @throws NumberFormatException if numbers, including properties that should
- * be years are invalid
- * @throws IOException if access to the property resource fails.
+ * @throws DateTimeException if initialization of the calendar data from the
+ * resource fails
*/
- private void loadCalendarData(String resourceName) throws Exception {
- Properties props = readConfigProperties(resourceName);
+ private void loadCalendarData() {
+ try {
+ String resourceName = calendarProperties.getProperty(PROP_PREFIX + typeId);
+ Objects.requireNonNull(resourceName, "Resource missing for calendar: " + PROP_PREFIX + typeId);
+ Properties props = readConfigProperties(resourceName);
- Map<Integer, int[]> years = new HashMap<>();
- int minYear = Integer.MAX_VALUE;
- int maxYear = Integer.MIN_VALUE;
- String id = null;
- String type = null;
- String version = null;
- int isoStart = 0;
- for (Map.Entry<Object, Object> entry : props.entrySet()) {
- String key = (String) entry.getKey();
- switch (key) {
- case KEY_ID:
- id = (String)entry.getValue();
- break;
- case KEY_TYPE:
- type = (String)entry.getValue();
- break;
- case KEY_VERSION:
- version = (String)entry.getValue();
- break;
- case KEY_ISO_START: {
- int[] ymd = parseYMD((String) entry.getValue());
- isoStart = (int) LocalDate.of(ymd[0], ymd[1], ymd[2]).toEpochDay();
- break;
+ Map<Integer, int[]> years = new HashMap<>();
+ int minYear = Integer.MAX_VALUE;
+ int maxYear = Integer.MIN_VALUE;
+ String id = null;
+ String type = null;
+ String version = null;
+ int isoStart = 0;
+ for (Map.Entry<Object, Object> entry : props.entrySet()) {
+ String key = (String) entry.getKey();
+ switch (key) {
+ case KEY_ID:
+ id = (String)entry.getValue();
+ break;
+ case KEY_TYPE:
+ type = (String)entry.getValue();
+ break;
+ case KEY_VERSION:
+ version = (String)entry.getValue();
+ break;
+ case KEY_ISO_START: {
+ int[] ymd = parseYMD((String) entry.getValue());
+ isoStart = (int) LocalDate.of(ymd[0], ymd[1], ymd[2]).toEpochDay();
+ break;
+ }
+ default:
+ try {
+ // Everything else is either a year or invalid
+ int year = Integer.valueOf(key);
+ int[] months = parseMonths((String) entry.getValue());
+ years.put(year, months);
+ maxYear = Math.max(maxYear, year);
+ minYear = Math.min(minYear, year);
+ } catch (NumberFormatException nfe) {
+ throw new IllegalArgumentException("bad key: " + key);
+ }
}
- default:
- try {
- // Everything else is either a year or invalid
- int year = Integer.valueOf(key);
- int[] months = parseMonths((String) entry.getValue());
- years.put(year, months);
- maxYear = Math.max(maxYear, year);
- minYear = Math.min(minYear, year);
- } catch (NumberFormatException nfe) {
- throw new IllegalArgumentException("bad key: " + key);
- }
+ }
+
+ if (!getId().equals(id)) {
+ throw new IllegalArgumentException("Configuration is for a different calendar: " + id);
}
- }
+ if (!getCalendarType().equals(type)) {
+ throw new IllegalArgumentException("Configuration is for a different calendar type: " + type);
+ }
+ if (version == null || version.isEmpty()) {
+ throw new IllegalArgumentException("Configuration does not contain a version");
+ }
+ if (isoStart == 0) {
+ throw new IllegalArgumentException("Configuration does not contain a ISO start date");
+ }
- if (!getId().equals(id)) {
- throw new IllegalArgumentException("Configuration is for a different calendar: " + id);
- }
- if (!getCalendarType().equals(type)) {
- throw new IllegalArgumentException("Configuration is for a different calendar type: " + type);
- }
- if (version == null || version.isEmpty()) {
- throw new IllegalArgumentException("Configuration does not contain a version");
- }
- if (isoStart == 0) {
- throw new IllegalArgumentException("Configuration does not contain a ISO start date");
- }
+ // Now create and validate the array of epochDays indexed by epochMonth
+ hijrahStartEpochMonth = minYear * 12;
+ minEpochDay = isoStart;
+ hijrahEpochMonthStartDays = createEpochMonths(minEpochDay, minYear, maxYear, years);
+ maxEpochDay = hijrahEpochMonthStartDays[hijrahEpochMonthStartDays.length - 1];
- // Now create and validate the array of epochDays indexed by epochMonth
- hijrahStartEpochMonth = minYear * 12;
- minEpochDay = isoStart;
- hijrahEpochMonthStartDays = createEpochMonths(minEpochDay, minYear, maxYear, years);
- maxEpochDay = hijrahEpochMonthStartDays[hijrahEpochMonthStartDays.length - 1];
-
- // Compute the min and max year length in days.
- for (int year = minYear; year < maxYear; year++) {
- int length = getYearLength(year);
- minYearLength = Math.min(minYearLength, length);
- maxYearLength = Math.max(maxYearLength, length);
+ // Compute the min and max year length in days.
+ for (int year = minYear; year < maxYear; year++) {
+ int length = getYearLength(year);
+ minYearLength = Math.min(minYearLength, length);
+ maxYearLength = Math.max(maxYearLength, length);
+ }
+ } catch (Exception ex) {
+ // Log error and throw a DateTimeException
+ PlatformLogger logger = PlatformLogger.getLogger("java.time.chrono");
+ logger.severe("Unable to initialize Hijrah calendar proxy: " + typeId, ex);
+ throw new DateTimeException("Unable to initialize HijrahCalendar: " + typeId, ex);
}
}
--- a/jdk/src/share/classes/java/time/chrono/HijrahDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/HijrahDate.java Wed May 15 07:48:57 2013 -0700
@@ -102,7 +102,7 @@
* to create new HijrahDate instances.
* Alternatively, the {@link #withVariant} method can be used to convert
* to a new HijrahChronology.
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/HijrahEra.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/HijrahEra.java Wed May 15 07:48:57 2013 -0700
@@ -81,7 +81,7 @@
* <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra}.
* Use {@code getValue()} instead.</b>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/IsoChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/IsoChronology.java Wed May 15 07:48:57 2013 -0700
@@ -121,7 +121,7 @@
* <li>leap-year - Leap years occur every 4 years, except where the year is divisble by 100 and not divisble by 400.
* </ul><p>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -588,7 +588,12 @@
int moy = MONTH_OF_YEAR.checkValidIntValue(fieldValues.remove(MONTH_OF_YEAR));
int dom = DAY_OF_MONTH.checkValidIntValue(fieldValues.remove(DAY_OF_MONTH));
if (resolverStyle == ResolverStyle.SMART) { // previous valid
- dom = Math.min(dom, Month.of(moy).length(Year.isLeap(y)));
+ if (moy == 4 || moy == 6 || moy == 9 || moy == 11) {
+ dom = Math.min(dom, 30);
+ } else if (moy == 2) {
+ dom = Math.min(dom, Month.FEBRUARY.length(Year.isLeap(y)));
+
+ }
}
return LocalDate.of(y, moy, dom);
}
--- a/jdk/src/share/classes/java/time/chrono/IsoEra.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/IsoEra.java Wed May 15 07:48:57 2013 -0700
@@ -97,7 +97,7 @@
* <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}.
* Use {@code getValue()} instead.</b>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/JapaneseChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/JapaneseChronology.java Wed May 15 07:48:57 2013 -0700
@@ -85,7 +85,7 @@
* Only Meiji (1865-04-07 - 1868-09-07) and later eras are supported.
* Older eras are handled as an unknown era where the year-of-era is the ISO year.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -197,7 +197,7 @@
*/
@Override
public JapaneseDate dateYearDay(Era era, int yearOfEra, int dayOfYear) {
- return dateYearDay(prolepticYear(era, yearOfEra), dayOfYear);
+ return JapaneseDate.ofYearDay((JapaneseEra) era, yearOfEra, dayOfYear);
}
/**
@@ -251,16 +251,19 @@
}
@Override
+ @SuppressWarnings("unchecked")
public ChronoLocalDateTime<JapaneseDate> localDateTime(TemporalAccessor temporal) {
return (ChronoLocalDateTime<JapaneseDate>)super.localDateTime(temporal);
}
@Override
+ @SuppressWarnings("unchecked")
public ChronoZonedDateTime<JapaneseDate> zonedDateTime(TemporalAccessor temporal) {
return (ChronoZonedDateTime<JapaneseDate>)super.zonedDateTime(temporal);
}
@Override
+ @SuppressWarnings("unchecked")
public ChronoZonedDateTime<JapaneseDate> zonedDateTime(Instant instant, ZoneId zone) {
return (ChronoZonedDateTime<JapaneseDate>)super.zonedDateTime(instant, zone);
}
@@ -286,19 +289,27 @@
if (era instanceof JapaneseEra == false) {
throw new ClassCastException("Era must be JapaneseEra");
}
+
+ if (era == JapaneseEra.SEIREKI) {
+ JapaneseEra nextEra = JapaneseEra.values()[1];
+ int nextEraYear = nextEra.getPrivateEra().getSinceDate().getYear();
+ if (yearOfEra >= nextEraYear || yearOfEra < Year.MIN_VALUE) {
+ throw new DateTimeException("Invalid yearOfEra value");
+ }
+ return yearOfEra;
+ }
+
JapaneseEra jera = (JapaneseEra) era;
int gregorianYear = jera.getPrivateEra().getSinceDate().getYear() + yearOfEra - 1;
if (yearOfEra == 1) {
return gregorianYear;
}
- LocalGregorianCalendar.Date jdate = JCAL.newCalendarDate(null);
- jdate.setEra(jera.getPrivateEra()).setDate(yearOfEra, 1, 1);
- if (!JapaneseChronology.JCAL.validate(jdate)) {
- throw new DateTimeException("Invalid yearOfEra value");
- }
- JCAL.normalize(jdate);
- if (jdate.getNormalizedYear() == gregorianYear) {
- return gregorianYear;
+ if (gregorianYear >= Year.MIN_VALUE && gregorianYear <= Year.MAX_VALUE) {
+ LocalGregorianCalendar.Date jdate = JCAL.newCalendarDate(null);
+ jdate.setEra(jera.getPrivateEra()).setDate(yearOfEra, 1, 1);
+ if (JapaneseChronology.JCAL.validate(jdate)) {
+ return gregorianYear;
+ }
}
throw new DateTimeException("Invalid yearOfEra value");
}
@@ -322,13 +333,20 @@
@Override
public List<Era> eras() {
- return Arrays.asList(JapaneseEra.values());
+ return Arrays.<Era>asList(JapaneseEra.values());
+ }
+
+ JapaneseEra getCurrentEra() {
+ // Assume that the last JapaneseEra is the current one.
+ JapaneseEra[] eras = JapaneseEra.values();
+ return eras[eras.length - 1];
}
//-----------------------------------------------------------------------
@Override
public ValueRange range(ChronoField field) {
switch (field) {
+ case YEAR:
case DAY_OF_MONTH:
case DAY_OF_WEEK:
case MICRO_OF_DAY:
@@ -345,27 +363,23 @@
case NANO_OF_SECOND:
case CLOCK_HOUR_OF_DAY:
case CLOCK_HOUR_OF_AMPM:
- case EPOCH_DAY: // TODO: if year is restricted, then so is epoch-day
+ case EPOCH_DAY:
+ case PROLEPTIC_MONTH:
+ case MONTH_OF_YEAR:
return field.range();
+ case ERA:
+ return ValueRange.of(JapaneseEra.SEIREKI.getValue(),
+ getCurrentEra().getValue());
}
Calendar jcal = Calendar.getInstance(LOCALE);
int fieldIndex;
switch (field) {
- case ERA:
- return ValueRange.of(JapaneseEra.SEIREKI.getValue(),
- jcal.getMaximum(Calendar.ERA) - JapaneseEra.ERA_OFFSET);
- case YEAR:
- case YEAR_OF_ERA:
- // TODO: this is not right
+ case YEAR_OF_ERA: {
+ int startYear = getCurrentEra().getPrivateEra().getSinceDate().getYear();
return ValueRange.of(Year.MIN_VALUE, jcal.getGreatestMinimum(Calendar.YEAR),
- jcal.getLeastMaximum(Calendar.YEAR), Year.MAX_VALUE);
- case PROLEPTIC_MONTH:
- // TODO: should be the range of months bound by the valid range of years
- return ValueRange.of((jcal.getGreatestMinimum(Calendar.YEAR) - 1) * 12,
- (jcal.getLeastMaximum(Calendar.YEAR)) * 12);
- case MONTH_OF_YEAR:
- return ValueRange.of(jcal.getMinimum(Calendar.MONTH) + 1, jcal.getGreatestMinimum(Calendar.MONTH) + 1,
- jcal.getLeastMaximum(Calendar.MONTH) + 1, jcal.getMaximum(Calendar.MONTH) + 1);
+ jcal.getLeastMaximum(Calendar.YEAR) + 1, // +1 due to the different definitions
+ Year.MAX_VALUE - startYear);
+ }
case DAY_OF_YEAR:
fieldIndex = Calendar.DAY_OF_YEAR;
break;
--- a/jdk/src/share/classes/java/time/chrono/JapaneseDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/JapaneseDate.java Wed May 15 07:48:57 2013 -0700
@@ -83,6 +83,7 @@
import java.util.Calendar;
import java.util.Objects;
+import sun.util.calendar.CalendarDate;
import sun.util.calendar.LocalGregorianCalendar;
/**
@@ -101,7 +102,7 @@
* Calling {@code japaneseDate.get(ERA)} will return 2, corresponding to
* {@code JapaneseChronology.ERA_HEISEI}.<br>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -234,6 +235,24 @@
return of(prolepticYear, date.getMonthValue(), date.getDayOfMonth());
}
+ static JapaneseDate ofYearDay(JapaneseEra era, int yearOfEra, int dayOfYear) {
+ CalendarDate firstDay = era.getPrivateEra().getSinceDate();
+ LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
+ jdate.setEra(era.getPrivateEra());
+ if (yearOfEra == 1) {
+ jdate.setDate(yearOfEra, firstDay.getMonth(), firstDay.getDayOfMonth() + dayOfYear - 1);
+ } else {
+ jdate.setDate(yearOfEra, 1, dayOfYear);
+ }
+ JapaneseChronology.JCAL.normalize(jdate);
+ if (era.getPrivateEra() != jdate.getEra() || yearOfEra != jdate.getYear()) {
+ throw new DateTimeException("Invalid parameters");
+ }
+ LocalDate localdate = LocalDate.of(jdate.getNormalizedYear(),
+ jdate.getMonth(), jdate.getDayOfMonth());
+ return new JapaneseDate(era, yearOfEra, localdate);
+ }
+
/**
* Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
* system from the era, year-of-era, month-of-year and day-of-month fields.
--- a/jdk/src/share/classes/java/time/chrono/JapaneseEra.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/JapaneseEra.java Wed May 15 07:48:57 2013 -0700
@@ -91,7 +91,7 @@
* and the year of era of Seireki is proleptic Gregorian year.
* (The Julian to Gregorian transition is not supported.)
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/MinguoChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/MinguoChronology.java Wed May 15 07:48:57 2013 -0700
@@ -95,7 +95,7 @@
* are never out of step.
* </ul><p>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/MinguoDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/MinguoDate.java Wed May 15 07:48:57 2013 -0700
@@ -89,7 +89,7 @@
* This calendar system is primarily used in the Republic of China, often known as Taiwan.
* Dates are aligned such that {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/MinguoEra.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/MinguoEra.java Wed May 15 07:48:57 2013 -0700
@@ -102,7 +102,7 @@
* <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra}.
* Use {@code getValue()} instead.</b>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/Ser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/Ser.java Wed May 15 07:48:57 2013 -0700
@@ -68,7 +68,7 @@
/**
* The shared serialization delegate for this package.
*
- * <h3>Implementation notes</h3>
+ * @implNote
* This class wraps the object being serialized, and takes a byte representing the type of the class to
* be serialized. This byte can also be used for versioning the serialization format. In this case another
* byte flag would be used in order to specify an alternative version of the type format.
--- a/jdk/src/share/classes/java/time/chrono/ThaiBuddhistChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ThaiBuddhistChronology.java Wed May 15 07:48:57 2013 -0700
@@ -96,7 +96,7 @@
* are never out of step.
* </ul><p>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/ThaiBuddhistDate.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ThaiBuddhistDate.java Wed May 15 07:48:57 2013 -0700
@@ -89,7 +89,7 @@
* This calendar system is primarily used in Thailand.
* Dates are aligned such that {@code 2484-01-01 (Buddhist)} is {@code 1941-01-01 (ISO)}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/chrono/ThaiBuddhistEra.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/chrono/ThaiBuddhistEra.java Wed May 15 07:48:57 2013 -0700
@@ -102,7 +102,7 @@
* <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code ThaiBuddhistEra}.
* Use {@code getValue()} instead.</b>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/format/DateTimeFormatSymbols.java Wed May 15 15:01:59 2013 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,375 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
- * This file is available under and governed by the GNU General Public
- * License version 2 only, as published by the Free Software Foundation.
- * However, the following notice accompanied the original version of this
- * file:
- *
- * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * * Neither the name of JSR-310 nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package java.time.format;
-
-import java.text.DecimalFormatSymbols;
-import java.util.Locale;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-/**
- * Localized symbols used in date and time formatting.
- * <p>
- * A significant part of dealing with dates and times is the localization.
- * This class acts as a central point for accessing the information.
- *
- * <h3>Specification for implementors</h3>
- * This class is immutable and thread-safe.
- *
- * @since 1.8
- */
-public final class DateTimeFormatSymbols {
-
- /**
- * The standard set of non-localized symbols.
- * <p>
- * This uses standard ASCII characters for zero, positive, negative and a dot for the decimal point.
- */
- public static final DateTimeFormatSymbols STANDARD = new DateTimeFormatSymbols('0', '+', '-', '.');
- /**
- * The cache of symbols instances.
- */
- private static final ConcurrentMap<Locale, DateTimeFormatSymbols> CACHE = new ConcurrentHashMap<>(16, 0.75f, 2);
-
- /**
- * The zero digit.
- */
- private final char zeroDigit;
- /**
- * The positive sign.
- */
- private final char positiveSign;
- /**
- * The negative sign.
- */
- private final char negativeSign;
- /**
- * The decimal separator.
- */
- private final char decimalSeparator;
-
- //-----------------------------------------------------------------------
- /**
- * Lists all the locales that are supported.
- * <p>
- * The locale 'en_US' will always be present.
- *
- * @return an array of locales for which localization is supported
- */
- public static Locale[] getAvailableLocales() {
- return DecimalFormatSymbols.getAvailableLocales();
- }
-
- /**
- * Obtains symbols for the default
- * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
- * <p>
- * This method provides access to locale sensitive symbols.
- * <p>
- * This is equivalent to calling
- * {@link #of(Locale)
- * of(Locale.getDefault(Locale.Category.FORMAT))}.
- *
- * @see java.util.Locale.Category#FORMAT
- * @return the info, not null
- */
- public static DateTimeFormatSymbols ofDefaultLocale() {
- return of(Locale.getDefault(Locale.Category.FORMAT));
- }
-
- /**
- * Obtains symbols for the specified locale.
- * <p>
- * This method provides access to locale sensitive symbols.
- *
- * @param locale the locale, not null
- * @return the info, not null
- */
- public static DateTimeFormatSymbols of(Locale locale) {
- Objects.requireNonNull(locale, "locale");
- DateTimeFormatSymbols info = CACHE.get(locale);
- if (info == null) {
- info = create(locale);
- CACHE.putIfAbsent(locale, info);
- info = CACHE.get(locale);
- }
- return info;
- }
-
- private static DateTimeFormatSymbols create(Locale locale) {
- DecimalFormatSymbols oldSymbols = DecimalFormatSymbols.getInstance(locale);
- char zeroDigit = oldSymbols.getZeroDigit();
- char positiveSign = '+';
- char negativeSign = oldSymbols.getMinusSign();
- char decimalSeparator = oldSymbols.getDecimalSeparator();
- if (zeroDigit == '0' && negativeSign == '-' && decimalSeparator == '.') {
- return STANDARD;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Restricted constructor.
- *
- * @param zeroChar the character to use for the digit of zero
- * @param positiveSignChar the character to use for the positive sign
- * @param negativeSignChar the character to use for the negative sign
- * @param decimalPointChar the character to use for the decimal point
- */
- private DateTimeFormatSymbols(char zeroChar, char positiveSignChar, char negativeSignChar, char decimalPointChar) {
- this.zeroDigit = zeroChar;
- this.positiveSign = positiveSignChar;
- this.negativeSign = negativeSignChar;
- this.decimalSeparator = decimalPointChar;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents zero.
- * <p>
- * The character used to represent digits may vary by culture.
- * This method specifies the zero character to use, which implies the characters for one to nine.
- *
- * @return the character for zero
- */
- public char getZeroDigit() {
- return zeroDigit;
- }
-
- /**
- * Returns a copy of the info with a new character that represents zero.
- * <p>
- * The character used to represent digits may vary by culture.
- * This method specifies the zero character to use, which implies the characters for one to nine.
- *
- * @param zeroDigit the character for zero
- * @return a copy with a new character that represents zero, not null
-
- */
- public DateTimeFormatSymbols withZeroDigit(char zeroDigit) {
- if (zeroDigit == this.zeroDigit) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the positive sign.
- * <p>
- * The character used to represent a positive number may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the positive sign
- */
- public char getPositiveSign() {
- return positiveSign;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the positive sign.
- * <p>
- * The character used to represent a positive number may vary by culture.
- * This method specifies the character to use.
- *
- * @param positiveSign the character for the positive sign
- * @return a copy with a new character that represents the positive sign, not null
- */
- public DateTimeFormatSymbols withPositiveSign(char positiveSign) {
- if (positiveSign == this.positiveSign) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the negative sign.
- * <p>
- * The character used to represent a negative number may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the negative sign
- */
- public char getNegativeSign() {
- return negativeSign;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the negative sign.
- * <p>
- * The character used to represent a negative number may vary by culture.
- * This method specifies the character to use.
- *
- * @param negativeSign the character for the negative sign
- * @return a copy with a new character that represents the negative sign, not null
- */
- public DateTimeFormatSymbols withNegativeSign(char negativeSign) {
- if (negativeSign == this.negativeSign) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Gets the character that represents the decimal point.
- * <p>
- * The character used to represent a decimal point may vary by culture.
- * This method specifies the character to use.
- *
- * @return the character for the decimal point
- */
- public char getDecimalSeparator() {
- return decimalSeparator;
- }
-
- /**
- * Returns a copy of the info with a new character that represents the decimal point.
- * <p>
- * The character used to represent a decimal point may vary by culture.
- * This method specifies the character to use.
- *
- * @param decimalSeparator the character for the decimal point
- * @return a copy with a new character that represents the decimal point, not null
- */
- public DateTimeFormatSymbols withDecimalSeparator(char decimalSeparator) {
- if (decimalSeparator == this.decimalSeparator) {
- return this;
- }
- return new DateTimeFormatSymbols(zeroDigit, positiveSign, negativeSign, decimalSeparator);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Checks whether the character is a digit, based on the currently set zero character.
- *
- * @param ch the character to check
- * @return the value, 0 to 9, of the character, or -1 if not a digit
- */
- int convertToDigit(char ch) {
- int val = ch - zeroDigit;
- return (val >= 0 && val <= 9) ? val : -1;
- }
-
- /**
- * Converts the input numeric text to the internationalized form using the zero character.
- *
- * @param numericText the text, consisting of digits 0 to 9, to convert, not null
- * @return the internationalized text, not null
- */
- String convertNumberToI18N(String numericText) {
- if (zeroDigit == '0') {
- return numericText;
- }
- int diff = zeroDigit - '0';
- char[] array = numericText.toCharArray();
- for (int i = 0; i < array.length; i++) {
- array[i] = (char) (array[i] + diff);
- }
- return new String(array);
- }
-
- //-----------------------------------------------------------------------
- /**
- * Checks if these symbols equal another set of symbols.
- *
- * @param obj the object to check, null returns false
- * @return true if this is equal to the other date
- */
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj instanceof DateTimeFormatSymbols) {
- DateTimeFormatSymbols other = (DateTimeFormatSymbols) obj;
- return (zeroDigit == other.zeroDigit && positiveSign == other.positiveSign &&
- negativeSign == other.negativeSign && decimalSeparator == other.decimalSeparator);
- }
- return false;
- }
-
- /**
- * A hash code for these symbols.
- *
- * @return a suitable hash code
- */
- @Override
- public int hashCode() {
- return zeroDigit + positiveSign + negativeSign + decimalSeparator;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Returns a string describing these symbols.
- *
- * @return a string description, not null
- */
- @Override
- public String toString() {
- return "Symbols[" + zeroDigit + positiveSign + negativeSign + decimalSeparator + "]";
- }
-
-}
--- a/jdk/src/share/classes/java/time/format/DateTimeFormatter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeFormatter.java Wed May 15 07:48:57 2013 -0700
@@ -77,6 +77,7 @@
import java.text.ParseException;
import java.text.ParsePosition;
import java.time.DateTimeException;
+import java.time.Period;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.chrono.Chronology;
@@ -121,7 +122,7 @@
* </pre></blockquote>
* <p>
* In addition to the format, formatters can be created with desired Locale,
- * Chronology, ZoneId, and formatting symbols.
+ * Chronology, ZoneId, and DecimalStyle.
* <p>
* The {@link #withLocale withLocale} method returns a new formatter that
* overrides the locale. The locale affects some aspects of formatting and
@@ -138,8 +139,8 @@
* with the requested ZoneId before formatting. During parsing the ZoneId is
* applied before the value is returned.
* <p>
- * The {@link #withSymbols withSymbols} method returns a new formatter that
- * overrides the {@link DateTimeFormatSymbols}. The symbols are used for
+ * The {@link #withDecimalStyle withDecimalStyle} method returns a new formatter that
+ * overrides the {@link DecimalStyle}. The DecimalStyle symbols are used for
* formatting and parsing.
* <p>
* Some applications may need to use the older {@link Format java.text.Format}
@@ -417,7 +418,65 @@
* that you want to output directly to ensure that future changes do not break
* your application.
*
- * <h3>Specification for implementors</h3>
+ * <h3 id="resolving">Resolving</h3>
+ * Parsing is implemented as a two-phase operation.
+ * First, the text is parsed using the layout defined by the formatter, producing
+ * a {@code Map} of field to value, a {@code ZoneId} and a {@code Chronology}.
+ * Second, the parsed data is <em>resolved</em>, by validating, combining and
+ * simplifying the various fields into more useful ones.
+ * <p>
+ * Five parsing methods are supplied by this class.
+ * Four of these perform both the parse and resolve phases.
+ * The fifth method, {@link #parseUnresolved(CharSequence, ParsePosition)},
+ * only performs the first phase, leaving the result unresolved.
+ * As such, it is essentially a low-level operation.
+ * <p>
+ * The resolve phase is controlled by two parameters, set on this class.
+ * <p>
+ * The {@link ResolverStyle} is an enum that offers three different approaches,
+ * strict, smart and lenient. The smart option is the default.
+ * It can be set using {@link #withResolverStyle(ResolverStyle)}.
+ * <p>
+ * The {@link #withResolverFields(TemporalField...)} parameter allows the
+ * set of fields that will be resolved to be filtered before resolving starts.
+ * For example, if the formatter has parsed a year, month, day-of-month
+ * and day-of-year, then there are two approaches to resolve a date:
+ * (year + month + day-of-month) and (year + day-of-year).
+ * The resolver fields allows one of the two approaches to be selected.
+ * If no resolver fields are set then both approaches must result in the same date.
+ * <p>
+ * Resolving separate fields to form a complete date and time is a complex
+ * process with behaviour distributed across a number of classes.
+ * It follows these steps:
+ * <ol>
+ * <li>The chronology is determined.
+ * The chronology of the result is either the chronology that was parsed,
+ * or if no chronology was parsed, it is the chronology set on this class,
+ * or if that is null, it is {@code IsoChronology}.
+ * <li>The {@code ChronoField} date fields are resolved.
+ * This is achieved using {@link Chronology#resolveDate(Map, ResolverStyle)}.
+ * Documentation about field resolution is located in the implementation
+ * of {@code Chronology}.
+ * <li>The {@code ChronoField} time fields are resolved.
+ * This is documented on {@link ChronoField} and is the same for all chronologies.
+ * <li>Any fields that are not {@code ChronoField} are processed.
+ * This is achieved using {@link TemporalField#resolve(TemporalAccessor, long, ResolverStyle)}.
+ * Documentation about field resolution is located in the implementation
+ * of {@code TemporalField}.
+ * <li>The {@code ChronoField} date and time fields are re-resolved.
+ * This allows fields in step four to produce {@code ChronoField} values
+ * and have them be processed into dates and times.
+ * <li>A {@code LocalTime} is formed if there is at least an hour-of-day available.
+ * This involves providing default values for minute, second and fraction of second.
+ * <li>Any remaining unresolved fields are cross-checked against any
+ * date and/or time that was resolved. Thus, an earlier stage would resolve
+ * (year + month + day-of-month) to a date, and this stage would check that
+ * day-of-week was valid for the date.
+ * <li>If an {@linkplain #parsedExcessDays() excess number of days}
+ * was parsed then it is added to the date if a date is available.
+ * </ol>
+ *
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -435,7 +494,7 @@
/**
* The symbols to use for formatting, not null.
*/
- private final DateTimeFormatSymbols symbols;
+ private final DecimalStyle decimalStyle;
/**
* The resolver style to use, not null.
*/
@@ -1040,6 +1099,11 @@
* <p>
* This returns an immutable formatter capable of formatting and parsing
* the ISO-8601 instant format.
+ * When formatting, the second-of-minute is always output.
+ * The nano-of-second outputs zero, three, six or nine digits digits as necessary.
+ * When parsing, time to at least the seconds field is required.
+ * Fractional seconds from zero to nine are parsed.
+ * The localized decimal style is not used.
* <p>
* This is a special case formatter intended to allow a human readable form
* of an {@link java.time.Instant}. The {@code Instant} class is designed to
@@ -1201,25 +1265,117 @@
.toFormatter(ResolverStyle.SMART, IsoChronology.INSTANCE);
}
+ //-----------------------------------------------------------------------
+ /**
+ * A query that provides access to the excess days that were parsed.
+ * <p>
+ * This returns a singleton {@linkplain TemporalQuery query} that provides
+ * access to additional information from the parse. The query always returns
+ * a non-null period, with a zero period returned instead of null.
+ * <p>
+ * There are two situations where this query may return a non-zero period.
+ * <p><ul>
+ * <li>If the {@code ResolverStyle} is {@code LENIENT} and a time is parsed
+ * without a date, then the complete result of the parse consists of a
+ * {@code LocalTime} and an excess {@code Period} in days.
+ * <p>
+ * <li>If the {@code ResolverStyle} is {@code SMART} and a time is parsed
+ * without a date where the time is 24:00:00, then the complete result of
+ * the parse consists of a {@code LocalTime} of 00:00:00 and an excess
+ * {@code Period} of one day.
+ * </ul>
+ * <p>
+ * In both cases, if a complete {@code ChronoLocalDateTime} or {@code Instant}
+ * is parsed, then the excess days are added to the date part.
+ * As a result, this query will return a zero period.
+ * <p>
+ * The {@code SMART} behaviour handles the common "end of day" 24:00 value.
+ * Processing in {@code LENIENT} mode also produces the same result:
+ * <pre>
+ * Text to parse Parsed object Excess days
+ * "2012-12-03T00:00" LocalDateTime.of(2012, 12, 3, 0, 0) ZERO
+ * "2012-12-03T24:00" LocalDateTime.of(2012, 12, 4, 0, 0) ZERO
+ * "00:00" LocalTime.of(0, 0) ZERO
+ * "24:00" LocalTime.of(0, 0) Period.ofDays(1)
+ * </pre>
+ * The query can be used as follows:
+ * <pre>
+ * TemporalAccessor parsed = formatter.parse(str);
+ * LocalTime time = parsed.query(LocalTime::from);
+ * Period extraDays = parsed.query(DateTimeFormatter.parsedExcessDays());
+ * </pre>
+ */
+ public static final TemporalQuery<Period> parsedExcessDays() {
+ return PARSED_EXCESS_DAYS;
+ }
+ private static final TemporalQuery<Period> PARSED_EXCESS_DAYS = t -> {
+ if (t instanceof Parsed) {
+ return ((Parsed) t).excessDays;
+ } else {
+ return Period.ZERO;
+ }
+ };
+
+ /**
+ * A query that provides access to whether a leap-second was parsed.
+ * <p>
+ * This returns a singleton {@linkplain TemporalQuery query} that provides
+ * access to additional information from the parse. The query always returns
+ * a non-null boolean, true if parsing saw a leap-second, false if not.
+ * <p>
+ * Instant parsing handles the special "leap second" time of '23:59:60'.
+ * Leap seconds occur at '23:59:60' in the UTC time-zone, but at other
+ * local times in different time-zones. To avoid this potential ambiguity,
+ * the handling of leap-seconds is limited to
+ * {@link DateTimeFormatterBuilder#appendInstant()}, as that method
+ * always parses the instant with the UTC zone offset.
+ * <p>
+ * If the time '23:59:60' is received, then a simple conversion is applied,
+ * replacing the second-of-minute of 60 with 59. This query can be used
+ * on the parse result to determine if the leap-second adjustment was made.
+ * The query will return one second of excess if it did adjust to remove
+ * the leap-second, and zero if not. Note that applying a leap-second
+ * smoothing mechanism, such as UTC-SLS, is the responsibility of the
+ * application, as follows:
+ * <pre>
+ * TemporalAccessor parsed = formatter.parse(str);
+ * Instant instant = parsed.query(Instant::from);
+ * if (parsed.query(DateTimeFormatter.parsedLeapSecond())) {
+ * // validate leap-second is correct and apply correct smoothing
+ * }
+ * </pre>
+ */
+ public static final TemporalQuery<Boolean> parsedLeapSecond() {
+ return PARSED_LEAP_SECOND;
+ }
+ private static final TemporalQuery<Boolean> PARSED_LEAP_SECOND = t -> {
+ if (t instanceof Parsed) {
+ return ((Parsed) t).leapSecond;
+ } else {
+ return Boolean.FALSE;
+ }
+ };
+
+ //-----------------------------------------------------------------------
/**
* Constructor.
*
* @param printerParser the printer/parser to use, not null
* @param locale the locale to use, not null
- * @param symbols the symbols to use, not null
+ * @param decimalStyle the DecimalStyle to use, not null
* @param resolverStyle the resolver style to use, not null
* @param resolverFields the fields to use during resolving, null for all fields
* @param chrono the chronology to use, null for no override
* @param zone the zone to use, null for no override
*/
DateTimeFormatter(CompositePrinterParser printerParser,
- Locale locale, DateTimeFormatSymbols symbols,
+ Locale locale, DecimalStyle decimalStyle,
ResolverStyle resolverStyle, Set<TemporalField> resolverFields,
Chronology chrono, ZoneId zone) {
this.printerParser = Objects.requireNonNull(printerParser, "printerParser");
this.resolverFields = resolverFields;
this.locale = Objects.requireNonNull(locale, "locale");
- this.symbols = Objects.requireNonNull(symbols, "symbols");
+ this.decimalStyle = Objects.requireNonNull(decimalStyle, "decimalStyle");
this.resolverStyle = Objects.requireNonNull(resolverStyle, "resolverStyle");
this.chrono = chrono;
this.zone = zone;
@@ -1253,32 +1409,32 @@
if (this.locale.equals(locale)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
/**
- * Gets the set of symbols to be used during formatting.
+ * Gets the DecimalStyle to be used during formatting.
*
* @return the locale of this formatter, not null
*/
- public DateTimeFormatSymbols getSymbols() {
- return symbols;
+ public DecimalStyle getDecimalStyle() {
+ return decimalStyle;
}
/**
- * Returns a copy of this formatter with a new set of symbols.
+ * Returns a copy of this formatter with a new DecimalStyle.
* <p>
* This instance is immutable and unaffected by this method call.
*
- * @param symbols the new symbols, not null
- * @return a formatter based on this formatter with the requested symbols, not null
+ * @param decimalStyle the new DecimalStyle, not null
+ * @return a formatter based on this formatter with the requested DecimalStyle, not null
*/
- public DateTimeFormatter withSymbols(DateTimeFormatSymbols symbols) {
- if (this.symbols.equals(symbols)) {
+ public DateTimeFormatter withDecimalStyle(DecimalStyle decimalStyle) {
+ if (this.decimalStyle.equals(decimalStyle)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1332,7 +1488,7 @@
if (Objects.equals(this.chrono, chrono)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1389,7 +1545,7 @@
if (Objects.equals(this.zone, zone)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1431,7 +1587,7 @@
if (Objects.equals(this.resolverStyle, resolverStyle)) {
return this;
}
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
@@ -1495,7 +1651,7 @@
return this;
}
fields = Collections.unmodifiableSet(fields);
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, fields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, fields, chrono, zone);
}
/**
@@ -1543,7 +1699,7 @@
return this;
}
resolverFields = Collections.unmodifiableSet(new HashSet<>(resolverFields));
- return new DateTimeFormatter(printerParser, locale, symbols, resolverStyle, resolverFields, chrono, zone);
+ return new DateTimeFormatter(printerParser, locale, decimalStyle, resolverStyle, resolverFields, chrono, zone);
}
//-----------------------------------------------------------------------
--- a/jdk/src/share/classes/java/time/format/DateTimeFormatterBuilder.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeFormatterBuilder.java Wed May 15 07:48:57 2013 -0700
@@ -77,6 +77,7 @@
import java.math.RoundingMode;
import java.text.ParsePosition;
import java.time.DateTimeException;
+import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
@@ -142,7 +143,7 @@
* can be used, see {@link #appendPattern(String)}.
* In practice, this simply parses the pattern and calls other methods on the builder.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is a mutable builder intended for use from a single thread.
*
* @since 1.8
@@ -187,6 +188,44 @@
private int valueParserIndex = -1;
/**
+ * Gets the formatting pattern for date and time styles for a locale and chronology.
+ * The locale and chronology are used to lookup the locale specific format
+ * for the requested dateStyle and/or timeStyle.
+ *
+ * @param dateStyle the FormatStyle for the date
+ * @param timeStyle the FormatStyle for the time
+ * @param chrono the Chronology, non-null
+ * @param locale the locale, non-null
+ * @return the locale and Chronology specific formatting pattern
+ * @throws IllegalArgumentException if both dateStyle and timeStyle are null
+ */
+ public static String getLocalizedDateTimePattern(FormatStyle dateStyle, FormatStyle timeStyle,
+ Chronology chrono, Locale locale) {
+ Objects.requireNonNull(locale, "locale");
+ Objects.requireNonNull(chrono, "chrono");
+ if (dateStyle == null && timeStyle == null) {
+ throw new IllegalArgumentException("Either dateStyle or timeStyle must be non-null");
+ }
+ LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased().getLocaleResources(locale);
+ String pattern = lr.getJavaTimeDateTimePattern(
+ convertStyle(timeStyle), convertStyle(dateStyle), chrono.getCalendarType());
+ return pattern;
+ }
+
+ /**
+ * Converts the given FormatStyle to the java.text.DateFormat style.
+ *
+ * @param style the FormatStyle style
+ * @return the int style, or -1 if style is null, indicating un-required
+ */
+ private static int convertStyle(FormatStyle style) {
+ if (style == null) {
+ return -1;
+ }
+ return style.ordinal(); // indices happen to align
+ }
+
+ /**
* Constructs a new instance of the builder.
*/
public DateTimeFormatterBuilder() {
@@ -344,7 +383,7 @@
*/
public DateTimeFormatterBuilder appendValue(TemporalField field) {
Objects.requireNonNull(field, "field");
- active.valueParserIndex = appendInternal(new NumberPrinterParser(field, 1, 19, SignStyle.NORMAL));
+ appendValue(new NumberPrinterParser(field, 1, 19, SignStyle.NORMAL));
return this;
}
@@ -360,15 +399,15 @@
* If the value of the field is negative then an exception is thrown during formatting.
* <p>
* This method supports a special technique of parsing known as 'adjacent value parsing'.
- * This technique solves the problem where a variable length value is followed by one or more
+ * This technique solves the problem where a value, variable or fixed width, is followed by one or more
* fixed length values. The standard parser is greedy, and thus it would normally
* steal the digits that are needed by the fixed width value parsers that follow the
* variable width one.
* <p>
* No action is required to initiate 'adjacent value parsing'.
- * When a call to {@code appendValue} with a variable width is made, the builder
+ * When a call to {@code appendValue} is made, the builder
* enters adjacent value parsing setup mode. If the immediately subsequent method
- * call or calls on the same builder are to this method, then the parser will reserve
+ * call or calls on the same builder are for a fixed width value, then the parser will reserve
* space so that the fixed width values can be parsed.
* <p>
* For example, consider {@code builder.appendValue(YEAR).appendValue(MONTH_OF_YEAR, 2);}
@@ -381,7 +420,7 @@
* nothing for the month.
* <p>
* Adjacent value parsing applies to each set of fixed width not-negative values in the parser
- * that immediately follow any kind of variable width value.
+ * that immediately follow any kind of value, variable or fixed width.
* Calling any other append method will end the setup of adjacent value parsing.
* Thus, in the unlikely event that you need to avoid adjacent value parsing behavior,
* simply add the {@code appendValue} to another {@code DateTimeFormatterBuilder}
@@ -402,7 +441,8 @@
throw new IllegalArgumentException("The width must be from 1 to 19 inclusive but was " + width);
}
NumberPrinterParser pp = new NumberPrinterParser(field, width, width, SignStyle.NOT_NEGATIVE);
- return appendFixedWidth(width, pp);
+ appendValue(pp);
+ return this;
}
/**
@@ -420,8 +460,10 @@
* This behavior can be affected by 'adjacent value parsing'.
* See {@link #appendValue(java.time.temporal.TemporalField, int)} for full details.
* <p>
- * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}.
- * In lenient parsing mode, the minimum number of parsed digits is one.
+ * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}
+ * and the maximum is {@code maxWidth}.
+ * In lenient parsing mode, the minimum number of parsed digits is one
+ * and the maximum is 19 (except as limited by adjacent value parsing).
* <p>
* If this method is invoked with equal minimum and maximum widths and a sign style of
* {@code NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)}.
@@ -452,17 +494,13 @@
maxWidth + " < " + minWidth);
}
NumberPrinterParser pp = new NumberPrinterParser(field, minWidth, maxWidth, signStyle);
- if (minWidth == maxWidth) {
- appendInternal(pp);
- } else {
- active.valueParserIndex = appendInternal(pp);
- }
+ appendValue(pp);
return this;
}
//-----------------------------------------------------------------------
/**
- * Appends the reduced value of a date-time field to the formatter.
+ * Appends the reduced value of a date-time field with fixed width to the formatter.
* <p>
* This is typically used for formatting and parsing a two digit year.
* The {@code width} is the printed and parsed width.
@@ -471,51 +509,116 @@
* For formatting, the width is used to determine the number of characters to format.
* The rightmost characters are output to match the width, left padding with zero.
* <p>
- * For parsing, exactly the number of characters specified by the width are parsed.
- * This is incomplete information however, so the base value is used to complete the parse.
- * The base value is the first valid value in a range of ten to the power of width.
+ * For strict parsing, the number of characters allowed by the width are parsed.
+ * For lenient parsing, the number of characters must be at least 1 and less than 10.
+ * If the number of digits parsed is equal to {@code width} and the value is positive,
+ * the value of the field is computed to be the first number greater than
+ * or equal to the {@code baseValue} with the same least significant characters,
+ * otherwise the value parsed is the field value.
+ * This allows a reduced value to be entered for values in range of the baseValue
+ * and width and absolute values can be entered for values outside the range.
* <p>
* For example, a base value of {@code 1980} and a width of {@code 2} will have
* valid values from {@code 1980} to {@code 2079}.
* During parsing, the text {@code "12"} will result in the value {@code 2012} as that
- * is the value within the range where the last two digits are "12".
- * <p>
- * This is a fixed width parser operating using 'adjacent value parsing'.
- * See {@link #appendValue(java.time.temporal.TemporalField, int)} for full details.
+ * is the value within the range where the last two characters are "12".
+ * Compare with lenient parsing the text {@code "1915"} that will result in the
+ * value {@code 1915}.
*
* @param field the field to append, not null
- * @param width the width of the printed and parsed field, from 1 to 18
+ * @param width the field width of the printed and parsed field, from 1 to 10
+ * @param baseValue the base value of the range of valid values
+ * @return this, for chaining, not null
+ * @throws IllegalArgumentException if the width or base value is invalid
+ * @see #appendValueReduced(java.time.temporal.TemporalField, int, int, int)
+ */
+ public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
+ int width, int baseValue) {
+ return appendValueReduced(field, width, width, baseValue);
+ }
+
+ /**
+ * Appends the reduced value of a date-time field with a flexible width to the formatter.
+ * <p>
+ * This is typically used for formatting and parsing a two digit year
+ * but allowing for the year value to be up to maxWidth.
+ * <p>
+ * For formatting, the {@code width} and {@code maxWidth} are used to
+ * determine the number of characters to format.
+ * If the value of the field is within the range of the {@code baseValue} using
+ * {@code width} characters then the reduced value is formatted otherwise the value is
+ * truncated to fit {@code maxWidth}.
+ * The rightmost characters are output to match the width, left padding with zero.
+ * <p>
+ * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are parsed.
+ * For lenient parsing, the number of characters must be at least 1 and less than 10.
+ * If the number of digits parsed is equal to {@code width} and the value is positive,
+ * the value of the field is computed to be the first number greater than
+ * or equal to the {@code baseValue} with the same least significant characters,
+ * otherwise the value parsed is the field value.
+ * This allows a reduced value to be entered for values in range of the baseValue
+ * and width and absolute values can be entered for values outside the range.
+ * <p>
+ * For example, a base value of {@code 1980} and a width of {@code 2} will have
+ * valid values from {@code 1980} to {@code 2079}.
+ * During parsing, the text {@code "12"} will result in the value {@code 2012} as that
+ * is the value within the range where the last two characters are "12".
+ * Compare with parsing the text {@code "1915"} that will result in the
+ * value {@code 1915}.
+ *
+ * @param field the field to append, not null
+ * @param width the field width of the printed and parsed field, from 1 to 10
+ * @param maxWidth the maximum field width of the printed field, from 1 to 10
* @param baseValue the base value of the range of valid values
* @return this, for chaining, not null
* @throws IllegalArgumentException if the width or base value is invalid
*/
- public DateTimeFormatterBuilder appendValueReduced(
- TemporalField field, int width, int baseValue) {
+ public DateTimeFormatterBuilder appendValueReduced(TemporalField field,
+ int width, int maxWidth, int baseValue) {
Objects.requireNonNull(field, "field");
- ReducedPrinterParser pp = new ReducedPrinterParser(field, width, baseValue);
- appendFixedWidth(width, pp);
+ ReducedPrinterParser pp = new ReducedPrinterParser(field, width, maxWidth, baseValue);
+ appendValue(pp);
return this;
}
/**
- * Appends a fixed width printer-parser.
+ * Appends a fixed or variable width printer-parser handling adjacent value mode.
+ * If a PrinterParser is not active then the new PrinterParser becomes
+ * the active PrinterParser.
+ * Otherwise, the active PrinterParser is modified depending on the new PrinterParser.
+ * If the new PrinterParser is fixed width and has sign style {@code NOT_NEGATIVE}
+ * then its width is added to the active PP and
+ * the new PrinterParser is forced to be fixed width.
+ * If the new PrinterParser is variable width, the active PrinterParser is changed
+ * to be fixed width and the new PrinterParser becomes the active PP.
*
- * @param width the width
* @param pp the printer-parser, not null
* @return this, for chaining, not null
*/
- private DateTimeFormatterBuilder appendFixedWidth(int width, NumberPrinterParser pp) {
+ private DateTimeFormatterBuilder appendValue(NumberPrinterParser pp) {
if (active.valueParserIndex >= 0) {
+ final int activeValueParser = active.valueParserIndex;
+
// adjacent parsing mode, update setting in previous parsers
- NumberPrinterParser basePP = (NumberPrinterParser) active.printerParsers.get(active.valueParserIndex);
- basePP = basePP.withSubsequentWidth(width);
- int activeValueParser = active.valueParserIndex;
- active.printerParsers.set(active.valueParserIndex, basePP);
- appendInternal(pp.withFixedWidth());
- active.valueParserIndex = activeValueParser;
+ NumberPrinterParser basePP = (NumberPrinterParser) active.printerParsers.get(activeValueParser);
+ if (pp.minWidth == pp.maxWidth && pp.signStyle == SignStyle.NOT_NEGATIVE) {
+ // Append the width to the subsequentWidth of the active parser
+ basePP = basePP.withSubsequentWidth(pp.maxWidth);
+ // Append the new parser as a fixed width
+ appendInternal(pp.withFixedWidth());
+ // Retain the previous active parser
+ active.valueParserIndex = activeValueParser;
+ } else {
+ // Modify the active parser to be fixed width
+ basePP = basePP.withFixedWidth();
+ // The new parser becomes the mew active parser
+ active.valueParserIndex = appendInternal(pp);
+ }
+ // Replace the modified parser with the updated one
+ active.printerParsers.set(activeValueParser, basePP);
} else {
- // not adjacent parsing
- appendInternal(pp);
+ // The new Parser becomes the active parser
+ active.valueParserIndex = appendInternal(pp);
}
return this;
}
@@ -657,11 +760,24 @@
//-----------------------------------------------------------------------
/**
- * Appends an instant using ISO-8601 to the formatter.
+ * Appends an instant using ISO-8601 to the formatter, formatting fractional
+ * digits in groups of three.
* <p>
* Instants have a fixed output format.
- * They are converted to a date-time with a zone-offset of UTC and printed
+ * They are converted to a date-time with a zone-offset of UTC and formatted
* using the standard ISO-8601 format.
+ * With this method, formatting nano-of-second outputs zero, three, six
+ * or nine digits digits as necessary.
+ * The localized decimal style is not used.
+ * <p>
+ * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}
+ * and optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS}
+ * may be outside the maximum range of {@code LocalDateTime}.
+ * <p>
+ * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing.
+ * The end-of-day time of '24:00' is handled as midnight at the start of the following day.
+ * The leap-second time of '23:59:59' is handled to some degree, see
+ * {@link DateTimeFormatter#parsedLeapSecond()} for full details.
* <p>
* An alternative to this method is to format/parse the instant as a single
* epoch-seconds value. That is achieved using {@code appendValue(INSTANT_SECONDS)}.
@@ -669,11 +785,55 @@
* @return this, for chaining, not null
*/
public DateTimeFormatterBuilder appendInstant() {
- appendInternal(new InstantPrinterParser());
+ appendInternal(new InstantPrinterParser(-2));
return this;
}
/**
+ * Appends an instant using ISO-8601 to the formatter with control over
+ * the number of fractional digits.
+ * <p>
+ * Instants have a fixed output format, although this method provides some
+ * control over the fractional digits. They are converted to a date-time
+ * with a zone-offset of UTC and printed using the standard ISO-8601 format.
+ * The localized decimal style is not used.
+ * <p>
+ * The {@code fractionalDigits} parameter allows the output of the fractional
+ * second to be controlled. Specifying zero will cause no fractional digits
+ * to be output. From 1 to 9 will output an increasing number of digits, using
+ * zero right-padding if necessary. The special value -1 is used to output as
+ * many digits as necessary to avoid any trailing zeroes.
+ * <p>
+ * When parsing in strict mode, the number of parsed digits must match the
+ * fractional digits. When parsing in lenient mode, any number of fractional
+ * digits from zero to nine are accepted.
+ * <p>
+ * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}
+ * and optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS}
+ * may be outside the maximum range of {@code LocalDateTime}.
+ * <p>
+ * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing.
+ * The end-of-day time of '24:00' is handled as midnight at the start of the following day.
+ * The leap-second time of '23:59:59' is handled to some degree, see
+ * {@link DateTimeFormatter#parsedLeapSecond()} for full details.
+ * <p>
+ * An alternative to this method is to format/parse the instant as a single
+ * epoch-seconds value. That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+ *
+ * @param fractionalDigits the number of fractional second digits to format with,
+ * from 0 to 9, or -1 to use as many digits as necessary
+ * @return this, for chaining, not null
+ */
+ public DateTimeFormatterBuilder appendInstant(int fractionalDigits) {
+ if (fractionalDigits < -1 || fractionalDigits > 9) {
+ throw new IllegalArgumentException("The fractional digits must be from -1 to 9 inclusive but was " + fractionalDigits);
+ }
+ appendInternal(new InstantPrinterParser(fractionalDigits));
+ return this;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
* Appends the zone offset, such as '+01:00', to the formatter.
* <p>
* This appends an instruction to format/parse the offset ID to the builder.
@@ -1049,7 +1209,7 @@
* <p>
* The calendar system name will be output during a format.
* If the chronology cannot be obtained then an exception will be thrown.
- * The calendar system name is obtained from the formatting symbols.
+ * The calendar system name is obtained from the Chronology.
*
* @param textStyle the text style to use, not null
* @return this, for chaining, not null
@@ -1838,7 +1998,7 @@
* using the default locale.
* <p>
* This will create a formatter with the {@linkplain Locale#getDefault(Locale.Category) default FORMAT locale}.
- * Numbers will be printed and parsed using the standard non-localized set of symbols.
+ * Numbers will be printed and parsed using the standard DecimalStyle.
* The resolver style will be {@link ResolverStyle#SMART SMART}.
* <p>
* Calling this method will end any open optional sections by repeatedly
@@ -1858,7 +2018,7 @@
* using the specified locale.
* <p>
* This will create a formatter with the specified locale.
- * Numbers will be printed and parsed using the standard non-localized set of symbols.
+ * Numbers will be printed and parsed using the standard DecimalStyle.
* The resolver style will be {@link ResolverStyle#SMART SMART}.
* <p>
* Calling this method will end any open optional sections by repeatedly
@@ -1898,7 +2058,7 @@
optionalEnd();
}
CompositePrinterParser pp = new CompositePrinterParser(printerParsers, false);
- return new DateTimeFormatter(pp, locale, DateTimeFormatSymbols.STANDARD,
+ return new DateTimeFormatter(pp, locale, DecimalStyle.STANDARD,
resolverStyle, null, chrono, null);
}
@@ -1921,7 +2081,7 @@
* for the next parser. If an error occurs, the returned index will be negative
* and will have the error position encoded using the complement operator.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* <p>
@@ -2282,24 +2442,25 @@
/**
* Array of 10 to the power of n.
*/
- static final int[] EXCEED_POINTS = new int[] {
- 0,
- 10,
- 100,
- 1000,
- 10000,
- 100000,
- 1000000,
- 10000000,
- 100000000,
- 1000000000,
+ static final long[] EXCEED_POINTS = new long[] {
+ 0L,
+ 10L,
+ 100L,
+ 1000L,
+ 10000L,
+ 100000L,
+ 1000000L,
+ 10000000L,
+ 100000000L,
+ 1000000000L,
+ 10000000000L,
};
final TemporalField field;
final int minWidth;
- private final int maxWidth;
+ final int maxWidth;
private final SignStyle signStyle;
- private final int subsequentWidth;
+ final int subsequentWidth;
/**
* Constructor.
@@ -2328,7 +2489,7 @@
* @param subsequentWidth the width of subsequent non-negative numbers, 0 or greater,
* -1 if fixed width due to active adjacent parsing
*/
- private NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle, int subsequentWidth) {
+ protected NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle, int subsequentWidth) {
// validated by caller
this.field = field;
this.minWidth = minWidth;
@@ -2343,6 +2504,9 @@
* @return a new updated printer-parser, not null
*/
NumberPrinterParser withFixedWidth() {
+ if (subsequentWidth == -1) {
+ return this;
+ }
return new NumberPrinterParser(field, minWidth, maxWidth, signStyle, -1);
}
@@ -2363,24 +2527,24 @@
return false;
}
long value = getValue(valueLong);
- DateTimeFormatSymbols symbols = context.getSymbols();
+ DecimalStyle decimalStyle = context.getDecimalStyle();
String str = (value == Long.MIN_VALUE ? "9223372036854775808" : Long.toString(Math.abs(value)));
if (str.length() > maxWidth) {
throw new DateTimeException("Field " + field.getName() +
" cannot be printed as the value " + value +
" exceeds the maximum print width of " + maxWidth);
}
- str = symbols.convertNumberToI18N(str);
+ str = decimalStyle.convertNumberToI18N(str);
if (value >= 0) {
switch (signStyle) {
case EXCEEDS_PAD:
if (minWidth < 19 && value >= EXCEED_POINTS[minWidth]) {
- buf.append(symbols.getPositiveSign());
+ buf.append(decimalStyle.getPositiveSign());
}
break;
case ALWAYS:
- buf.append(symbols.getPositiveSign());
+ buf.append(decimalStyle.getPositiveSign());
break;
}
} else {
@@ -2388,7 +2552,7 @@
case NORMAL:
case EXCEEDS_PAD:
case ALWAYS:
- buf.append(symbols.getNegativeSign());
+ buf.append(decimalStyle.getNegativeSign());
break;
case NOT_NEGATIVE:
throw new DateTimeException("Field " + field.getName() +
@@ -2397,7 +2561,7 @@
}
}
for (int i = 0; i < minWidth - str.length(); i++) {
- buf.append(symbols.getZeroDigit());
+ buf.append(decimalStyle.getZeroDigit());
}
buf.append(str);
return true;
@@ -2426,13 +2590,13 @@
char sign = text.charAt(position); // IOOBE if invalid position
boolean negative = false;
boolean positive = false;
- if (sign == context.getSymbols().getPositiveSign()) {
+ if (sign == context.getDecimalStyle().getPositiveSign()) {
if (signStyle.parse(true, context.isStrict(), minWidth == maxWidth) == false) {
return ~position;
}
positive = true;
position++;
- } else if (sign == context.getSymbols().getNegativeSign()) {
+ } else if (sign == context.getDecimalStyle().getNegativeSign()) {
if (signStyle.parse(false, context.isStrict(), minWidth == maxWidth) == false) {
return ~position;
}
@@ -2448,7 +2612,7 @@
if (minEndPos > length) {
return ~position;
}
- int effMaxWidth = maxWidth + Math.max(subsequentWidth, 0);
+ int effMaxWidth = (context.isStrict() || isFixedWidth() ? maxWidth : 9) + Math.max(subsequentWidth, 0);
long total = 0;
BigInteger totalBig = null;
int pos = position;
@@ -2456,7 +2620,7 @@
int maxEndPos = Math.min(pos + effMaxWidth, length);
while (pos < maxEndPos) {
char ch = text.charAt(pos++);
- int digit = context.getSymbols().convertToDigit(ch);
+ int digit = context.getDecimalStyle().convertToDigit(ch);
if (digit < 0) {
pos--;
if (pos < minEndPos) {
@@ -2550,62 +2714,110 @@
*/
static final class ReducedPrinterParser extends NumberPrinterParser {
private final int baseValue;
- private final int range;
/**
* Constructor.
*
* @param field the field to format, validated not null
- * @param width the field width, from 1 to 18
+ * @param minWidth the minimum field width, from 1 to 10
+ * @param maxWidth the maximum field width, from 1 to 10
* @param baseValue the base value
*/
- ReducedPrinterParser(TemporalField field, int width, int baseValue) {
- super(field, width, width, SignStyle.NOT_NEGATIVE);
- if (width < 1 || width > 18) {
- throw new IllegalArgumentException("The width must be from 1 to 18 inclusive but was " + width);
+ ReducedPrinterParser(TemporalField field, int minWidth, int maxWidth,
+ int baseValue) {
+ this(field, minWidth, maxWidth, baseValue, 0);
+ if (minWidth < 1 || minWidth > 10) {
+ throw new IllegalArgumentException("The minWidth must be from 1 to 10 inclusive but was " + minWidth);
+ }
+ if (maxWidth < 1 || maxWidth > 10) {
+ throw new IllegalArgumentException("The maxWidth must be from 1 to 10 inclusive but was " + minWidth);
+ }
+ if (maxWidth < minWidth) {
+ throw new IllegalArgumentException("Maximum width must exceed or equal the minimum width but " +
+ maxWidth + " < " + minWidth);
}
if (field.range().isValidValue(baseValue) == false) {
throw new IllegalArgumentException("The base value must be within the range of the field");
}
- this.baseValue = baseValue;
- this.range = EXCEED_POINTS[width];
- if ((((long) baseValue) + range) > Integer.MAX_VALUE) {
+ if ((((long) baseValue) + EXCEED_POINTS[maxWidth]) > Integer.MAX_VALUE) {
throw new DateTimeException("Unable to add printer-parser as the range exceeds the capacity of an int");
}
}
+ /**
+ * Constructor.
+ * The arguments have already been checked.
+ *
+ * @param field the field to format, validated not null
+ * @param minWidth the minimum field width, from 1 to 10
+ * @param maxWidth the maximum field width, from 1 to 10
+ * @param baseValue the base value
+ * @param subsequentWidth the subsequentWidth for this instance
+ */
+ private ReducedPrinterParser(TemporalField field, int minWidth, int maxWidth,
+ int baseValue, int subsequentWidth) {
+ super(field, minWidth, maxWidth, SignStyle.NOT_NEGATIVE, subsequentWidth);
+ this.baseValue = baseValue;
+ }
+
@Override
long getValue(long value) {
- return Math.abs(value % range);
+ long absValue = Math.abs(value);
+ if (value >= baseValue && value < baseValue + EXCEED_POINTS[minWidth]) {
+ // Use the reduced value if it fits in minWidth
+ return absValue % EXCEED_POINTS[minWidth];
+ }
+ // Otherwise truncate to fit in maxWidth
+ return absValue % EXCEED_POINTS[maxWidth];
}
@Override
int setValue(DateTimeParseContext context, long value, int errorPos, int successPos) {
- int lastPart = baseValue % range;
- if (baseValue > 0) {
- value = baseValue - lastPart + value;
- } else {
- value = baseValue - lastPart - value;
- }
- if (value < baseValue) {
- value += range;
+ int parseLen = successPos - errorPos;
+ if (parseLen == minWidth && value >= 0) {
+ long range = EXCEED_POINTS[minWidth];
+ long lastPart = baseValue % range;
+ long basePart = baseValue - lastPart;
+ if (baseValue > 0) {
+ value = basePart + value;
+ } else {
+ value = basePart - value;
+ }
+ if (basePart != 0 && value < baseValue) {
+ value += range;
+ }
}
return context.setParsedField(field, value, errorPos, successPos);
}
+ /**
+ * Returns a new instance with fixed width flag set.
+ *
+ * @return a new updated printer-parser, not null
+ */
@Override
- NumberPrinterParser withFixedWidth() {
- return this;
+ ReducedPrinterParser withFixedWidth() {
+ if (subsequentWidth == -1) {
+ return this;
+ }
+ return new ReducedPrinterParser(field, minWidth, maxWidth, baseValue, -1);
}
+ /**
+ * Returns a new instance with an updated subsequent width.
+ *
+ * @param subsequentWidth the width of subsequent non-negative numbers, 0 or greater
+ * @return a new updated printer-parser, not null
+ */
@Override
- boolean isFixedWidth() {
- return true;
+ ReducedPrinterParser withSubsequentWidth(int subsequentWidth) {
+ return new ReducedPrinterParser(field, minWidth, maxWidth, baseValue,
+ this.subsequentWidth + subsequentWidth);
}
@Override
public String toString() {
- return "ReducedValue(" + field.getName() + "," + minWidth + "," + baseValue + ")";
+ return "ReducedValue(" + field.getName() + "," + minWidth + "," + maxWidth + "," + baseValue + ")";
}
}
@@ -2654,24 +2866,24 @@
if (value == null) {
return false;
}
- DateTimeFormatSymbols symbols = context.getSymbols();
+ DecimalStyle decimalStyle = context.getDecimalStyle();
BigDecimal fraction = convertToFraction(value);
if (fraction.scale() == 0) { // scale is zero if value is zero
if (minWidth > 0) {
if (decimalPoint) {
- buf.append(symbols.getDecimalSeparator());
+ buf.append(decimalStyle.getDecimalSeparator());
}
for (int i = 0; i < minWidth; i++) {
- buf.append(symbols.getZeroDigit());
+ buf.append(decimalStyle.getZeroDigit());
}
}
} else {
int outputScale = Math.min(Math.max(fraction.scale(), minWidth), maxWidth);
fraction = fraction.setScale(outputScale, RoundingMode.FLOOR);
String str = fraction.toPlainString().substring(2);
- str = symbols.convertNumberToI18N(str);
+ str = decimalStyle.convertNumberToI18N(str);
if (decimalPoint) {
- buf.append(symbols.getDecimalSeparator());
+ buf.append(decimalStyle.getDecimalSeparator());
}
buf.append(str);
}
@@ -2688,7 +2900,7 @@
return (effectiveMin > 0 ? ~position : position);
}
if (decimalPoint) {
- if (text.charAt(position) != context.getSymbols().getDecimalSeparator()) {
+ if (text.charAt(position) != context.getDecimalStyle().getDecimalSeparator()) {
// valid if whole field is optional, invalid if minimum width
return (effectiveMin > 0 ? ~position : position);
}
@@ -2703,7 +2915,7 @@
int pos = position;
while (pos < maxEndPos) {
char ch = text.charAt(pos++);
- int digit = context.getSymbols().convertToDigit(ch);
+ int digit = context.getDecimalStyle().convertToDigit(ch);
if (digit < 0) {
if (pos < minEndPos) {
return ~position; // need at least min width digits
@@ -2883,43 +3095,50 @@
// seconds per day = 86400
private static final long SECONDS_PER_10000_YEARS = 146097L * 25L * 86400L;
private static final long SECONDS_0000_TO_1970 = ((146097L * 5L) - (30L * 365L + 7L)) * 86400L;
- private static final CompositePrinterParser PARSER = new DateTimeFormatterBuilder()
- .parseCaseInsensitive()
- .append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T')
- .append(DateTimeFormatter.ISO_LOCAL_TIME).appendLiteral('Z')
- .toFormatter().toPrinterParser(false);
+ private final int fractionalDigits;
- InstantPrinterParser() {
+ InstantPrinterParser(int fractionalDigits) {
+ this.fractionalDigits = fractionalDigits;
}
@Override
public boolean format(DateTimePrintContext context, StringBuilder buf) {
// use INSTANT_SECONDS, thus this code is not bound by Instant.MAX
Long inSecs = context.getValue(INSTANT_SECONDS);
- Long inNanos = context.getValue(NANO_OF_SECOND);
- if (inSecs == null || inNanos == null) {
+ Long inNanos = null;
+ if (context.getTemporal().isSupported(NANO_OF_SECOND)) {
+ inNanos = context.getTemporal().getLong(NANO_OF_SECOND);
+ }
+ if (inSecs == null) {
return false;
}
long inSec = inSecs;
- int inNano = NANO_OF_SECOND.checkValidIntValue(inNanos);
+ int inNano = NANO_OF_SECOND.checkValidIntValue(inNanos != null ? inNanos : 0);
+ // format mostly using LocalDateTime.toString
if (inSec >= -SECONDS_0000_TO_1970) {
// current era
long zeroSecs = inSec - SECONDS_PER_10000_YEARS + SECONDS_0000_TO_1970;
long hi = Math.floorDiv(zeroSecs, SECONDS_PER_10000_YEARS) + 1;
long lo = Math.floorMod(zeroSecs, SECONDS_PER_10000_YEARS);
- LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, inNano, ZoneOffset.UTC);
+ LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, 0, ZoneOffset.UTC);
if (hi > 0) {
buf.append('+').append(hi);
}
- buf.append(ldt).append('Z');
+ buf.append(ldt);
+ if (ldt.getSecond() == 0) {
+ buf.append(":00");
+ }
} else {
// before current era
long zeroSecs = inSec + SECONDS_0000_TO_1970;
long hi = zeroSecs / SECONDS_PER_10000_YEARS;
long lo = zeroSecs % SECONDS_PER_10000_YEARS;
- LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, inNano, ZoneOffset.UTC);
+ LocalDateTime ldt = LocalDateTime.ofEpochSecond(lo - SECONDS_0000_TO_1970, 0, ZoneOffset.UTC);
int pos = buf.length();
- buf.append(ldt).append('Z');
+ buf.append(ldt);
+ if (ldt.getSecond() == 0) {
+ buf.append(":00");
+ }
if (hi < 0) {
if (ldt.getYear() == -10_000) {
buf.replace(pos, pos + 2, Long.toString(hi - 1));
@@ -2930,14 +3149,38 @@
}
}
}
+ // add fraction
+ if ((fractionalDigits < 0 && inNano > 0) || fractionalDigits > 0) {
+ buf.append('.');
+ int div = 100_000_000;
+ for (int i = 0; ((fractionalDigits == -1 && inNano > 0) ||
+ (fractionalDigits == -2 && (inNano > 0 || (i % 3) != 0)) ||
+ i < fractionalDigits); i++) {
+ int digit = inNano / div;
+ buf.append((char) (digit + '0'));
+ inNano = inNano - (digit * div);
+ div = div / 10;
+ }
+ }
+ buf.append('Z');
return true;
}
@Override
public int parse(DateTimeParseContext context, CharSequence text, int position) {
// new context to avoid overwriting fields like year/month/day
+ int minDigits = (fractionalDigits < 0 ? 0 : fractionalDigits);
+ int maxDigits = (fractionalDigits < 0 ? 9 : fractionalDigits);
+ CompositePrinterParser parser = new DateTimeFormatterBuilder()
+ .append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T')
+ .appendValue(HOUR_OF_DAY, 2).appendLiteral(':')
+ .appendValue(MINUTE_OF_HOUR, 2).appendLiteral(':')
+ .appendValue(SECOND_OF_MINUTE, 2)
+ .appendFraction(NANO_OF_SECOND, minDigits, maxDigits, true)
+ .appendLiteral('Z')
+ .toFormatter().toPrinterParser(false);
DateTimeParseContext newContext = context.copy();
- int pos = PARSER.parse(newContext, text, position);
+ int pos = parser.parse(newContext, text, position);
if (pos < 0) {
return pos;
}
@@ -2952,10 +3195,18 @@
Long nanoVal = newContext.getParsed(NANO_OF_SECOND);
int sec = (secVal != null ? secVal.intValue() : 0);
int nano = (nanoVal != null ? nanoVal.intValue() : 0);
+ int days = 0;
+ if (hour == 24 && min == 0 && sec == 0 && nano == 0) {
+ hour = 0;
+ days = 1;
+ } else if (hour == 23 && min == 59 && sec == 60) {
+ context.setParsedLeapSecond();
+ sec = 59;
+ }
int year = (int) yearParsed % 10_000;
long instantSecs;
try {
- LocalDateTime ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0);
+ LocalDateTime ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0).plusDays(days);
instantSecs = ldt.toEpochSecond(ZoneOffset.UTC);
instantSecs += Math.multiplyExact(yearParsed / 10_000L, SECONDS_PER_10000_YEARS);
} catch (RuntimeException ex) {
@@ -4017,9 +4268,7 @@
String key = chrono.getId() + '|' + locale.toString() + '|' + dateStyle + timeStyle;
DateTimeFormatter formatter = FORMATTER_CACHE.get(key);
if (formatter == null) {
- LocaleResources lr = LocaleProviderAdapter.getResourceBundleBased().getLocaleResources(locale);
- String pattern = lr.getJavaTimeDateTimePattern(
- convertStyle(timeStyle), convertStyle(dateStyle), chrono.getCalendarType());
+ String pattern = getLocalizedDateTimePattern(dateStyle, timeStyle, chrono, locale);
formatter = new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter(locale);
DateTimeFormatter old = FORMATTER_CACHE.putIfAbsent(key, formatter);
if (old != null) {
@@ -4029,19 +4278,6 @@
return formatter;
}
- /**
- * Converts the given FormatStyle to the java.text.DateFormat style.
- *
- * @param style the FormatStyle style
- * @return the int style, or -1 if style is null, indicating unrequired
- */
- private int convertStyle(FormatStyle style) {
- if (style == null) {
- return -1;
- }
- return style.ordinal(); // indices happen to align
- }
-
@Override
public String toString() {
return "Localized(" + (dateStyle != null ? dateStyle : "") + "," +
@@ -4096,7 +4332,7 @@
case 'Y':
field = weekDef.weekBasedYear();
if (count == 2) {
- return new ReducedPrinterParser(field, 2, 2000);
+ return new ReducedPrinterParser(field, 2, 2, 2000, 0);
} else {
return new NumberPrinterParser(field, count, 19,
(count < 4) ? SignStyle.NORMAL : SignStyle.EXCEEDS_PAD, -1);
--- a/jdk/src/share/classes/java/time/format/DateTimeParseContext.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeParseContext.java Wed May 15 07:48:57 2013 -0700
@@ -61,6 +61,7 @@
*/
package java.time.format;
+import java.time.Duration;
import java.time.ZoneId;
import java.time.chrono.Chronology;
import java.time.chrono.IsoChronology;
@@ -79,7 +80,7 @@
* Once parsing is complete, the {@link #toParsed()} is used to obtain the data.
* It contains a method to resolve the separate parsed fields into meaningful values.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard parsing as a new instance of this class
* is automatically created for each parse and parsing is single-threaded
@@ -118,9 +119,13 @@
/**
* Creates a copy of this context.
+ * This retains the case sensitive and strict flags.
*/
DateTimeParseContext copy() {
- return new DateTimeParseContext(formatter);
+ DateTimeParseContext newContext = new DateTimeParseContext(formatter);
+ newContext.caseSensitive = caseSensitive;
+ newContext.strict = strict;
+ return newContext;
}
//-----------------------------------------------------------------------
@@ -128,7 +133,7 @@
* Gets the locale.
* <p>
* This locale is used to control localization in the parse except
- * where localization is controlled by the symbols.
+ * where localization is controlled by the DecimalStyle.
*
* @return the locale, not null
*/
@@ -137,14 +142,14 @@
}
/**
- * Gets the formatting symbols.
+ * Gets the DecimalStyle.
* <p>
- * The symbols control the localization of numeric parsing.
+ * The DecimalStyle controls the numeric parsing.
*
- * @return the formatting symbols, not null
+ * @return the DecimalStyle, not null
*/
- DateTimeFormatSymbols getSymbols() {
- return formatter.getSymbols();
+ DecimalStyle getDecimalStyle() {
+ return formatter.getDecimalStyle();
}
/**
@@ -370,6 +375,13 @@
currentParsed().zone = zone;
}
+ /**
+ * Stores the parsed leap second.
+ */
+ void setParsedLeapSecond() {
+ currentParsed().leapSecond = true;
+ }
+
//-----------------------------------------------------------------------
/**
* Returns a string version of the context for debugging.
--- a/jdk/src/share/classes/java/time/format/DateTimeParseException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeParseException.java Wed May 15 07:48:57 2013 -0700
@@ -68,7 +68,7 @@
* <p>
* This exception includes the text being parsed and the error index.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/format/DateTimePrintContext.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimePrintContext.java Wed May 15 07:48:57 2013 -0700
@@ -85,7 +85,7 @@
* <p>
* This class provides a single wrapper to items used in the format.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard printing as the framework creates
* a new instance of the class for each format and printing is single-threaded.
@@ -234,7 +234,7 @@
* Gets the locale.
* <p>
* This locale is used to control localization in the format output except
- * where localization is controlled by the symbols.
+ * where localization is controlled by the DecimalStyle.
*
* @return the locale, not null
*/
@@ -243,14 +243,14 @@
}
/**
- * Gets the formatting symbols.
+ * Gets the DecimalStyle.
* <p>
- * The symbols control the localization of numeric output.
+ * The DecimalStyle controls the localization of numeric output.
*
- * @return the formatting symbols, not null
+ * @return the DecimalStyle, not null
*/
- DateTimeFormatSymbols getSymbols() {
- return formatter.getSymbols();
+ DecimalStyle getDecimalStyle() {
+ return formatter.getDecimalStyle();
}
//-----------------------------------------------------------------------
--- a/jdk/src/share/classes/java/time/format/DateTimeTextProvider.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/DateTimeTextProvider.java Wed May 15 07:48:57 2013 -0700
@@ -94,7 +94,7 @@
/**
* A provider to obtain the textual form of a date-time field.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must be thread-safe.
* Implementations should cache the textual information.
*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/time/format/DecimalStyle.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package java.time.format;
+
+import java.text.DecimalFormatSymbols;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * Localized decimal style used in date and time formatting.
+ * <p>
+ * A significant part of dealing with dates and times is the localization.
+ * This class acts as a central point for accessing the information.
+ *
+ * @implSpec
+ * This class is immutable and thread-safe.
+ *
+ * @since 1.8
+ */
+public final class DecimalStyle {
+
+ /**
+ * The standard set of non-localized decimal style symbols.
+ * <p>
+ * This uses standard ASCII characters for zero, positive, negative and a dot for the decimal point.
+ */
+ public static final DecimalStyle STANDARD = new DecimalStyle('0', '+', '-', '.');
+ /**
+ * The cache of DecimalStyle instances.
+ */
+ private static final ConcurrentMap<Locale, DecimalStyle> CACHE = new ConcurrentHashMap<>(16, 0.75f, 2);
+
+ /**
+ * The zero digit.
+ */
+ private final char zeroDigit;
+ /**
+ * The positive sign.
+ */
+ private final char positiveSign;
+ /**
+ * The negative sign.
+ */
+ private final char negativeSign;
+ /**
+ * The decimal separator.
+ */
+ private final char decimalSeparator;
+
+ //-----------------------------------------------------------------------
+ /**
+ * Lists all the locales that are supported.
+ * <p>
+ * The locale 'en_US' will always be present.
+ *
+ * @return a Set of Locales for which localization is supported
+ */
+ public static Set<Locale> getAvailableLocales() {
+ Locale[] l = DecimalFormatSymbols.getAvailableLocales();
+ Set<Locale> locales = new HashSet<>(l.length);
+ Collections.addAll(locales, l);
+ return locales;
+ }
+
+ /**
+ * Obtains the DecimalStyle for the default
+ * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
+ * <p>
+ * This method provides access to locale sensitive decimal style symbols.
+ * <p>
+ * This is equivalent to calling
+ * {@link #of(Locale)
+ * of(Locale.getDefault(Locale.Category.FORMAT))}.
+ *
+ * @see java.util.Locale.Category#FORMAT
+ * @return the info, not null
+ */
+ public static DecimalStyle ofDefaultLocale() {
+ return of(Locale.getDefault(Locale.Category.FORMAT));
+ }
+
+ /**
+ * Obtains the DecimalStyle for the specified locale.
+ * <p>
+ * This method provides access to locale sensitive decimal style symbols.
+ *
+ * @param locale the locale, not null
+ * @return the info, not null
+ */
+ public static DecimalStyle of(Locale locale) {
+ Objects.requireNonNull(locale, "locale");
+ DecimalStyle info = CACHE.get(locale);
+ if (info == null) {
+ info = create(locale);
+ CACHE.putIfAbsent(locale, info);
+ info = CACHE.get(locale);
+ }
+ return info;
+ }
+
+ private static DecimalStyle create(Locale locale) {
+ DecimalFormatSymbols oldSymbols = DecimalFormatSymbols.getInstance(locale);
+ char zeroDigit = oldSymbols.getZeroDigit();
+ char positiveSign = '+';
+ char negativeSign = oldSymbols.getMinusSign();
+ char decimalSeparator = oldSymbols.getDecimalSeparator();
+ if (zeroDigit == '0' && negativeSign == '-' && decimalSeparator == '.') {
+ return STANDARD;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Restricted constructor.
+ *
+ * @param zeroChar the character to use for the digit of zero
+ * @param positiveSignChar the character to use for the positive sign
+ * @param negativeSignChar the character to use for the negative sign
+ * @param decimalPointChar the character to use for the decimal point
+ */
+ private DecimalStyle(char zeroChar, char positiveSignChar, char negativeSignChar, char decimalPointChar) {
+ this.zeroDigit = zeroChar;
+ this.positiveSign = positiveSignChar;
+ this.negativeSign = negativeSignChar;
+ this.decimalSeparator = decimalPointChar;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents zero.
+ * <p>
+ * The character used to represent digits may vary by culture.
+ * This method specifies the zero character to use, which implies the characters for one to nine.
+ *
+ * @return the character for zero
+ */
+ public char getZeroDigit() {
+ return zeroDigit;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents zero.
+ * <p>
+ * The character used to represent digits may vary by culture.
+ * This method specifies the zero character to use, which implies the characters for one to nine.
+ *
+ * @param zeroDigit the character for zero
+ * @return a copy with a new character that represents zero, not null
+
+ */
+ public DecimalStyle withZeroDigit(char zeroDigit) {
+ if (zeroDigit == this.zeroDigit) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the positive sign.
+ * <p>
+ * The character used to represent a positive number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the positive sign
+ */
+ public char getPositiveSign() {
+ return positiveSign;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the positive sign.
+ * <p>
+ * The character used to represent a positive number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param positiveSign the character for the positive sign
+ * @return a copy with a new character that represents the positive sign, not null
+ */
+ public DecimalStyle withPositiveSign(char positiveSign) {
+ if (positiveSign == this.positiveSign) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the negative sign.
+ * <p>
+ * The character used to represent a negative number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the negative sign
+ */
+ public char getNegativeSign() {
+ return negativeSign;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the negative sign.
+ * <p>
+ * The character used to represent a negative number may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param negativeSign the character for the negative sign
+ * @return a copy with a new character that represents the negative sign, not null
+ */
+ public DecimalStyle withNegativeSign(char negativeSign) {
+ if (negativeSign == this.negativeSign) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Gets the character that represents the decimal point.
+ * <p>
+ * The character used to represent a decimal point may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @return the character for the decimal point
+ */
+ public char getDecimalSeparator() {
+ return decimalSeparator;
+ }
+
+ /**
+ * Returns a copy of the info with a new character that represents the decimal point.
+ * <p>
+ * The character used to represent a decimal point may vary by culture.
+ * This method specifies the character to use.
+ *
+ * @param decimalSeparator the character for the decimal point
+ * @return a copy with a new character that represents the decimal point, not null
+ */
+ public DecimalStyle withDecimalSeparator(char decimalSeparator) {
+ if (decimalSeparator == this.decimalSeparator) {
+ return this;
+ }
+ return new DecimalStyle(zeroDigit, positiveSign, negativeSign, decimalSeparator);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks whether the character is a digit, based on the currently set zero character.
+ *
+ * @param ch the character to check
+ * @return the value, 0 to 9, of the character, or -1 if not a digit
+ */
+ int convertToDigit(char ch) {
+ int val = ch - zeroDigit;
+ return (val >= 0 && val <= 9) ? val : -1;
+ }
+
+ /**
+ * Converts the input numeric text to the internationalized form using the zero character.
+ *
+ * @param numericText the text, consisting of digits 0 to 9, to convert, not null
+ * @return the internationalized text, not null
+ */
+ String convertNumberToI18N(String numericText) {
+ if (zeroDigit == '0') {
+ return numericText;
+ }
+ int diff = zeroDigit - '0';
+ char[] array = numericText.toCharArray();
+ for (int i = 0; i < array.length; i++) {
+ array[i] = (char) (array[i] + diff);
+ }
+ return new String(array);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks if this DecimalStyle is equal another DecimalStyle.
+ *
+ * @param obj the object to check, null returns false
+ * @return true if this is equal to the other date
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof DecimalStyle) {
+ DecimalStyle other = (DecimalStyle) obj;
+ return (zeroDigit == other.zeroDigit && positiveSign == other.positiveSign &&
+ negativeSign == other.negativeSign && decimalSeparator == other.decimalSeparator);
+ }
+ return false;
+ }
+
+ /**
+ * A hash code for this DecimalStyle.
+ *
+ * @return a suitable hash code
+ */
+ @Override
+ public int hashCode() {
+ return zeroDigit + positiveSign + negativeSign + decimalSeparator;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Returns a string describing this DecimalStyle.
+ *
+ * @return a string description, not null
+ */
+ @Override
+ public String toString() {
+ return "DecimalStyle[" + zeroDigit + positiveSign + negativeSign + decimalSeparator + "]";
+ }
+
+}
--- a/jdk/src/share/classes/java/time/format/FormatStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/FormatStyle.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
* These styles are used when obtaining a date-time style from configuration.
* See {@link DateTimeFormatter} and {@link DateTimeFormatterBuilder} for usage.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/format/Parsed.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/Parsed.java Wed May 15 07:48:57 2013 -0700
@@ -80,6 +80,7 @@
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalTime;
+import java.time.Period;
import java.time.ZoneId;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.Chronology;
@@ -105,7 +106,7 @@
* Once parsing is completed, this class can be used as the resultant {@code TemporalAccessor}.
* In most cases, it is only exposed once the fields have been resolved.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard parsing as a new instance of this class
* is automatically created for each parse and parsing is single-threaded
@@ -128,6 +129,10 @@
*/
Chronology chrono;
/**
+ * Whether a leap-second is parsed.
+ */
+ boolean leapSecond;
+ /**
* The effective chronology.
*/
Chronology effectiveChrono;
@@ -143,6 +148,10 @@
* The resolved time.
*/
private LocalTime time;
+ /**
+ * The excess period from time-only parsing.
+ */
+ Period excessDays = Period.ZERO;
/**
* Creates an instance.
@@ -159,6 +168,7 @@
cloned.fieldValues.putAll(this.fieldValues);
cloned.zone = this.zone;
cloned.chrono = this.chrono;
+ cloned.leapSecond = this.leapSecond;
return cloned;
}
@@ -232,6 +242,7 @@
resolveFields();
resolveTimeLenient();
crossCheck();
+ resolvePeriod();
return this;
}
@@ -308,36 +319,72 @@
private void resolveTimeFields() {
// simplify fields
if (fieldValues.containsKey(CLOCK_HOUR_OF_DAY)) {
+ // lenient allows anything, smart allows 0-24, strict allows 1-24
long ch = fieldValues.remove(CLOCK_HOUR_OF_DAY);
+ if (resolverStyle == ResolverStyle.STRICT || (resolverStyle == ResolverStyle.SMART && ch != 0)) {
+ CLOCK_HOUR_OF_DAY.checkValidValue(ch);
+ }
updateCheckConflict(CLOCK_HOUR_OF_DAY, HOUR_OF_DAY, ch == 24 ? 0 : ch);
}
if (fieldValues.containsKey(CLOCK_HOUR_OF_AMPM)) {
+ // lenient allows anything, smart allows 0-12, strict allows 1-12
long ch = fieldValues.remove(CLOCK_HOUR_OF_AMPM);
+ if (resolverStyle == ResolverStyle.STRICT || (resolverStyle == ResolverStyle.SMART && ch != 0)) {
+ CLOCK_HOUR_OF_AMPM.checkValidValue(ch);
+ }
updateCheckConflict(CLOCK_HOUR_OF_AMPM, HOUR_OF_AMPM, ch == 12 ? 0 : ch);
}
if (fieldValues.containsKey(AMPM_OF_DAY) && fieldValues.containsKey(HOUR_OF_AMPM)) {
long ap = fieldValues.remove(AMPM_OF_DAY);
long hap = fieldValues.remove(HOUR_OF_AMPM);
- updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, ap * 12 + hap);
+ if (resolverStyle == ResolverStyle.LENIENT) {
+ updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, Math.addExact(Math.multiplyExact(ap, 12), hap));
+ } else { // STRICT or SMART
+ AMPM_OF_DAY.checkValidValue(ap);
+ HOUR_OF_AMPM.checkValidValue(ap);
+ updateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, ap * 12 + hap);
+ }
+ }
+ if (fieldValues.containsKey(NANO_OF_DAY)) {
+ long nod = fieldValues.remove(NANO_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ NANO_OF_DAY.checkValidValue(nod);
+ }
+ updateCheckConflict(NANO_OF_DAY, HOUR_OF_DAY, nod / 3600_000_000_000L);
+ updateCheckConflict(NANO_OF_DAY, MINUTE_OF_HOUR, (nod / 60_000_000_000L) % 60);
+ updateCheckConflict(NANO_OF_DAY, SECOND_OF_MINUTE, (nod / 1_000_000_000L) % 60);
+ updateCheckConflict(NANO_OF_DAY, NANO_OF_SECOND, nod % 1_000_000_000L);
}
if (fieldValues.containsKey(MICRO_OF_DAY)) {
long cod = fieldValues.remove(MICRO_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MICRO_OF_DAY.checkValidValue(cod);
+ }
updateCheckConflict(MICRO_OF_DAY, SECOND_OF_DAY, cod / 1_000_000L);
updateCheckConflict(MICRO_OF_DAY, MICRO_OF_SECOND, cod % 1_000_000L);
}
if (fieldValues.containsKey(MILLI_OF_DAY)) {
long lod = fieldValues.remove(MILLI_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MILLI_OF_DAY.checkValidValue(lod);
+ }
updateCheckConflict(MILLI_OF_DAY, SECOND_OF_DAY, lod / 1_000);
updateCheckConflict(MILLI_OF_DAY, MILLI_OF_SECOND, lod % 1_000);
}
if (fieldValues.containsKey(SECOND_OF_DAY)) {
long sod = fieldValues.remove(SECOND_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ SECOND_OF_DAY.checkValidValue(sod);
+ }
updateCheckConflict(SECOND_OF_DAY, HOUR_OF_DAY, sod / 3600);
updateCheckConflict(SECOND_OF_DAY, MINUTE_OF_HOUR, (sod / 60) % 60);
updateCheckConflict(SECOND_OF_DAY, SECOND_OF_MINUTE, sod % 60);
}
if (fieldValues.containsKey(MINUTE_OF_DAY)) {
long mod = fieldValues.remove(MINUTE_OF_DAY);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MINUTE_OF_DAY.checkValidValue(mod);
+ }
updateCheckConflict(MINUTE_OF_DAY, HOUR_OF_DAY, mod / 60);
updateCheckConflict(MINUTE_OF_DAY, MINUTE_OF_HOUR, mod % 60);
}
@@ -345,29 +392,34 @@
// combine partial second fields strictly, leaving lenient expansion to later
if (fieldValues.containsKey(NANO_OF_SECOND)) {
long nos = fieldValues.get(NANO_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ NANO_OF_SECOND.checkValidValue(nos);
+ }
if (fieldValues.containsKey(MICRO_OF_SECOND)) {
long cos = fieldValues.remove(MICRO_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MICRO_OF_SECOND.checkValidValue(cos);
+ }
nos = cos * 1000 + (nos % 1000);
updateCheckConflict(MICRO_OF_SECOND, NANO_OF_SECOND, nos);
}
if (fieldValues.containsKey(MILLI_OF_SECOND)) {
long los = fieldValues.remove(MILLI_OF_SECOND);
+ if (resolverStyle != ResolverStyle.LENIENT) {
+ MILLI_OF_SECOND.checkValidValue(los);
+ }
updateCheckConflict(MILLI_OF_SECOND, NANO_OF_SECOND, los * 1_000_000L + (nos % 1_000_000L));
}
}
- // convert to time if possible
- if (fieldValues.containsKey(NANO_OF_DAY)) {
- long nod = fieldValues.remove(NANO_OF_DAY);
- updateCheckConflict(LocalTime.ofNanoOfDay(nod));
- }
+ // convert to time if all four fields available (optimization)
if (fieldValues.containsKey(HOUR_OF_DAY) && fieldValues.containsKey(MINUTE_OF_HOUR) &&
fieldValues.containsKey(SECOND_OF_MINUTE) && fieldValues.containsKey(NANO_OF_SECOND)) {
- int hodVal = HOUR_OF_DAY.checkValidIntValue(fieldValues.remove(HOUR_OF_DAY));
- int mohVal = MINUTE_OF_HOUR.checkValidIntValue(fieldValues.remove(MINUTE_OF_HOUR));
- int somVal = SECOND_OF_MINUTE.checkValidIntValue(fieldValues.remove(SECOND_OF_MINUTE));
- int nosVal = NANO_OF_SECOND.checkValidIntValue(fieldValues.remove(NANO_OF_SECOND));
- updateCheckConflict(LocalTime.of(hodVal, mohVal, somVal, nosVal));
+ long hod = fieldValues.remove(HOUR_OF_DAY);
+ long moh = fieldValues.remove(MINUTE_OF_HOUR);
+ long som = fieldValues.remove(SECOND_OF_MINUTE);
+ long nos = fieldValues.remove(NANO_OF_SECOND);
+ resolveTime(hod, moh, som, nos);
}
}
@@ -377,7 +429,7 @@
// which would break updateCheckConflict(field)
if (time == null) {
- // can only get here if NANO_OF_SECOND not present
+ // NANO_OF_SECOND merged with MILLI/MICRO above
if (fieldValues.containsKey(MILLI_OF_SECOND)) {
long los = fieldValues.remove(MILLI_OF_SECOND);
if (fieldValues.containsKey(MICRO_OF_SECOND)) {
@@ -395,43 +447,87 @@
long cos = fieldValues.remove(MICRO_OF_SECOND);
fieldValues.put(NANO_OF_SECOND, cos * 1_000L);
}
- }
- // merge hour/minute/second/nano leniently
- Long hod = fieldValues.get(HOUR_OF_DAY);
- if (hod != null) {
- int hodVal = HOUR_OF_DAY.checkValidIntValue(hod);
- Long moh = fieldValues.get(MINUTE_OF_HOUR);
- Long som = fieldValues.get(SECOND_OF_MINUTE);
- Long nos = fieldValues.get(NANO_OF_SECOND);
+ // merge hour/minute/second/nano leniently
+ Long hod = fieldValues.get(HOUR_OF_DAY);
+ if (hod != null) {
+ Long moh = fieldValues.get(MINUTE_OF_HOUR);
+ Long som = fieldValues.get(SECOND_OF_MINUTE);
+ Long nos = fieldValues.get(NANO_OF_SECOND);
- // check for invalid combinations that cannot be defaulted
- if (time == null) {
+ // check for invalid combinations that cannot be defaulted
if ((moh == null && (som != null || nos != null)) ||
(moh != null && som == null && nos != null)) {
return;
}
- }
- // default as necessary and build time
- int mohVal = (moh != null ? MINUTE_OF_HOUR.checkValidIntValue(moh) : (time != null ? time.getMinute() : 0));
- int somVal = (som != null ? SECOND_OF_MINUTE.checkValidIntValue(som) : (time != null ? time.getSecond() : 0));
- int nosVal = (nos != null ? NANO_OF_SECOND.checkValidIntValue(nos) : (time != null ? time.getNano() : 0));
- updateCheckConflict(LocalTime.of(hodVal, mohVal, somVal, nosVal));
- fieldValues.remove(HOUR_OF_DAY);
- fieldValues.remove(MINUTE_OF_HOUR);
- fieldValues.remove(SECOND_OF_MINUTE);
- fieldValues.remove(NANO_OF_SECOND);
+ // default as necessary and build time
+ long mohVal = (moh != null ? moh : 0);
+ long somVal = (som != null ? som : 0);
+ long nosVal = (nos != null ? nos : 0);
+ resolveTime(hod, mohVal, somVal, nosVal);
+ fieldValues.remove(HOUR_OF_DAY);
+ fieldValues.remove(MINUTE_OF_HOUR);
+ fieldValues.remove(SECOND_OF_MINUTE);
+ fieldValues.remove(NANO_OF_SECOND);
+ }
+ }
+
+ // validate remaining
+ if (resolverStyle != ResolverStyle.LENIENT && fieldValues.size() > 0) {
+ for (Entry<TemporalField, Long> entry : fieldValues.entrySet()) {
+ TemporalField field = entry.getKey();
+ if (field instanceof ChronoField && field.isTimeBased()) {
+ ((ChronoField) field).checkValidValue(entry.getValue());
+ }
+ }
}
}
- private void updateCheckConflict(LocalTime lt) {
+ private void resolveTime(long hod, long moh, long som, long nos) {
+ if (resolverStyle == ResolverStyle.LENIENT) {
+ long totalNanos = Math.multiplyExact(hod, 3600_000_000_000L);
+ totalNanos = Math.addExact(totalNanos, Math.multiplyExact(moh, 60_000_000_000L));
+ totalNanos = Math.addExact(totalNanos, Math.multiplyExact(som, 1_000_000_000L));
+ totalNanos = Math.addExact(totalNanos, nos);
+ int excessDays = (int) Math.floorDiv(totalNanos, 86400_000_000_000L); // safe int cast
+ long nod = Math.floorMod(totalNanos, 86400_000_000_000L);
+ updateCheckConflict(LocalTime.ofNanoOfDay(nod), Period.ofDays(excessDays));
+ } else { // STRICT or SMART
+ int mohVal = MINUTE_OF_HOUR.checkValidIntValue(moh);
+ int nosVal = NANO_OF_SECOND.checkValidIntValue(nos);
+ // handle 24:00 end of day
+ if (resolverStyle == ResolverStyle.SMART && hod == 24 && mohVal == 0 && som == 0 && nosVal == 0) {
+ updateCheckConflict(LocalTime.MIDNIGHT, Period.ofDays(1));
+ } else {
+ int hodVal = HOUR_OF_DAY.checkValidIntValue(hod);
+ int somVal = SECOND_OF_MINUTE.checkValidIntValue(som);
+ updateCheckConflict(LocalTime.of(hodVal, mohVal, somVal, nosVal), Period.ZERO);
+ }
+ }
+ }
+
+ private void resolvePeriod() {
+ // add whole days if we have both date and time
+ if (date != null && time != null && excessDays.isZero() == false) {
+ date = date.plus(excessDays);
+ excessDays = Period.ZERO;
+ }
+ }
+
+ private void updateCheckConflict(LocalTime timeToSet, Period periodToSet) {
if (time != null) {
- if (lt != null && time.equals(lt) == false) {
- throw new DateTimeException("Conflict found: Fields resolved to two different times: " + time + " " + lt);
+ if (time.equals(timeToSet) == false) {
+ throw new DateTimeException("Conflict found: Fields resolved to different times: " + time + " " + timeToSet);
+ }
+ if (excessDays.isZero() == false && periodToSet.isZero() == false && excessDays.equals(periodToSet) == false) {
+ throw new DateTimeException("Conflict found: Fields resolved to different excess periods: " + excessDays + " " + periodToSet);
+ } else {
+ excessDays = periodToSet;
}
} else {
- time = lt;
+ time = timeToSet;
+ excessDays = periodToSet;
}
}
--- a/jdk/src/share/classes/java/time/format/ResolverStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/ResolverStyle.java Wed May 15 07:48:57 2013 -0700
@@ -69,7 +69,7 @@
* Phase 2 resolves the parsed field-value pairs into date and/or time objects.
* This style is used to control how phase 2, resolving, happens.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
@@ -96,10 +96,9 @@
* behavior. Individual fields will interpret this differently.
* <p>
* For example, resolving year-month and day-of-month in the ISO calendar
- * system using smart mode will ensure that the day-of-month is valid
- * for the year-month, rejecting invalid values, with the exception that
- * February 29th in a year other than a leap year will be converted to
- * February 28th.
+ * system using smart mode will ensure that the day-of-month is from
+ * 1 to 31, converting any value beyond the last valid day-of-month to be
+ * the last valid day-of-month.
*/
SMART,
/**
@@ -110,6 +109,7 @@
* <p>
* For example, lenient mode allows the month in the ISO calendar system
* to be outside the range 1 to 12.
+ * For example, month 15 is treated as being 3 months after month 12.
*/
LENIENT;
--- a/jdk/src/share/classes/java/time/format/SignStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/SignStyle.java Wed May 15 07:48:57 2013 -0700
@@ -68,7 +68,7 @@
* to be controlled using this enum.
* See {@link DateTimeFormatterBuilder} for usage.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/format/TextStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/TextStyle.java Wed May 15 07:48:57 2013 -0700
@@ -80,7 +80,7 @@
* For example, the word used for a month when used alone in a date picker is different
* to the word used for month in association with a day and year in a date.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is immutable and thread-safe enum.
*/
public enum TextStyle {
--- a/jdk/src/share/classes/java/time/format/package-info.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/format/package-info.java Wed May 15 07:48:57 2013 -0700
@@ -76,7 +76,7 @@
* Localization occurs by calling
* {@link java.time.format.DateTimeFormatter#withLocale(java.util.Locale) withLocale(Locale)}
* on the formatter. Further customization is possible using
- * {@link java.time.format.DateTimeFormatSymbols DateTimeFormatSymbols}.
+ * {@link java.time.format.DecimalStyle DecimalStyle}.
* </p>
*
* <h3>Package specification</h3>
--- a/jdk/src/share/classes/java/time/temporal/ChronoField.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ChronoField.java Wed May 15 07:48:57 2013 -0700
@@ -93,7 +93,7 @@
* just with slightly different rules.
* The documentation of each field explains how it operates.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is a final, immutable and thread-safe enum.
*
* @since 1.8
@@ -115,6 +115,10 @@
* object stores, using integer division to remove excess precision.
* For example, if the {@code TemporalAccessor} stores time to millisecond precision,
* then the nano-of-second must be divided by 1,000,000 before replacing the milli-of-second.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MILLI_OF_SECOND} and {@code MICRO_OF_SECOND}.
*/
NANO_OF_SECOND("NanoOfSecond", NANOS, SECONDS, ValueRange.of(0, 999_999_999)),
/**
@@ -126,6 +130,11 @@
* This field is used to represent the nano-of-day handling any fraction of the second.
* Implementations of {@code TemporalAccessor} should provide a value for this field if
* they can return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code NANO_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
NANO_OF_DAY("NanoOfDay", NANOS, DAYS, ValueRange.of(0, 86400L * 1000_000_000L - 1)),
/**
@@ -141,6 +150,11 @@
* <p>
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_SECOND} with the value multiplied by 1,000.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MILLI_OF_SECOND} to produce
+ * {@code NANO_OF_SECOND}.
*/
MICRO_OF_SECOND("MicroOfSecond", MICROS, SECONDS, ValueRange.of(0, 999_999)),
/**
@@ -155,6 +169,11 @@
* <p>
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_DAY} with the value multiplied by 1,000.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MICRO_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MICRO_OF_DAY("MicroOfDay", MICROS, DAYS, ValueRange.of(0, 86400L * 1000_000L - 1)),
/**
@@ -170,6 +189,11 @@
* <p>
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_SECOND} with the value multiplied by 1,000,000.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is resolved in combination with {@code MICRO_OF_SECOND} to produce
+ * {@code NANO_OF_SECOND}.
*/
MILLI_OF_SECOND("MilliOfSecond", MILLIS, SECONDS, ValueRange.of(0, 999)),
/**
@@ -184,6 +208,11 @@
* <p>
* When this field is used for setting a value, it should behave in the same way as
* setting {@link #NANO_OF_DAY} with the value multiplied by 1,000,000.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MILLI_OF_SECOND}, {@code SECOND_OF_MINUTE},
+ * {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MILLI_OF_DAY("MilliOfDay", MILLIS, DAYS, ValueRange.of(0, 86400L * 1000L - 1)),
/**
@@ -191,6 +220,9 @@
* <p>
* This counts the second within the minute, from 0 to 59.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
*/
SECOND_OF_MINUTE("SecondOfMinute", SECONDS, MINUTES, ValueRange.of(0, 59), "second"),
/**
@@ -198,6 +230,11 @@
* <p>
* This counts the second within the day, from 0 to (24 * 60 * 60) - 1.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code SECOND_OF_MINUTE}, {@code MINUTE_OF_HOUR}
+ * and {@code HOUR_OF_DAY} fields.
*/
SECOND_OF_DAY("SecondOfDay", SECONDS, DAYS, ValueRange.of(0, 86400L - 1)),
/**
@@ -205,6 +242,9 @@
* <p>
* This counts the minute within the hour, from 0 to 59.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
*/
MINUTE_OF_HOUR("MinuteOfHour", MINUTES, HOURS, ValueRange.of(0, 59), "minute"),
/**
@@ -212,6 +252,10 @@
* <p>
* This counts the minute within the day, from 0 to (24 * 60) - 1.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The value is split to form {@code MINUTE_OF_HOUR} and {@code HOUR_OF_DAY} fields.
*/
MINUTE_OF_DAY("MinuteOfDay", MINUTES, DAYS, ValueRange.of(0, (24 * 60) - 1)),
/**
@@ -220,6 +264,12 @@
* This counts the hour within the AM/PM, from 0 to 11.
* This is the hour that would be observed on a standard 12-hour digital clock.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 0 to 11 in strict and smart mode.
+ * In lenient mode the value is not validated. It is combined with
+ * {@code AMPM_OF_DAY} to form {@code HOUR_OF_DAY} by multiplying
+ * the {AMPM_OF_DAY} value by 12.
*/
HOUR_OF_AMPM("HourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(0, 11)),
/**
@@ -228,6 +278,12 @@
* This counts the hour within the AM/PM, from 1 to 12.
* This is the hour that would be observed on a standard 12-hour analog wall clock.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 1 to 12 in strict mode and from
+ * 0 to 12 in smart mode. In lenient mode the value is not validated.
+ * The field is converted to an {@code HOUR_OF_AMPM} with the same value,
+ * unless the value is 12, in which case it is converted to 0.
*/
CLOCK_HOUR_OF_AMPM("ClockHourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(1, 12)),
/**
@@ -236,6 +292,13 @@
* This counts the hour within the day, from 0 to 23.
* This is the hour that would be observed on a standard 24-hour digital clock.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated in strict and smart mode but not in lenient mode.
+ * The field is combined with {@code MINUTE_OF_HOUR}, {@code SECOND_OF_MINUTE} and
+ * {@code NANO_OF_SECOND} to produce a {@code LocalTime}.
+ * In lenient mode, any excess days are added to the parsed date, or
+ * made available via {@link java.time.format.DateTimeFormatter#parsedExcessDays()}.
*/
HOUR_OF_DAY("HourOfDay", HOURS, DAYS, ValueRange.of(0, 23), "hour"),
/**
@@ -244,6 +307,12 @@
* This counts the hour within the AM/PM, from 1 to 24.
* This is the hour that would be observed on a 24-hour analog wall clock.
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 1 to 24 in strict mode and from
+ * 0 to 24 in smart mode. In lenient mode the value is not validated.
+ * The field is converted to an {@code HOUR_OF_DAY} with the same value,
+ * unless the value is 24, in which case it is converted to 0.
*/
CLOCK_HOUR_OF_DAY("ClockHourOfDay", HOURS, DAYS, ValueRange.of(1, 24)),
/**
@@ -251,6 +320,12 @@
* <p>
* This counts the AM/PM within the day, from 0 (AM) to 1 (PM).
* This field has the same meaning for all calendar systems.
+ * <p>
+ * When parsing this field it behaves equivalent to the following:
+ * The value is validated from 0 to 1 in strict and smart mode.
+ * In lenient mode the value is not validated. It is combined with
+ * {@code HOUR_OF_AMPM} to form {@code HOUR_OF_DAY} by multiplying
+ * the {AMPM_OF_DAY} value by 12.
*/
AMPM_OF_DAY("AmPmOfDay", HALF_DAYS, DAYS, ValueRange.of(0, 1), "dayperiod"),
/**
--- a/jdk/src/share/classes/java/time/temporal/ChronoUnit.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ChronoUnit.java Wed May 15 07:48:57 2013 -0700
@@ -72,7 +72,7 @@
* just with slightly different rules.
* The documentation of each unit explains how it operates.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is a final, immutable and thread-safe enum.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/temporal/IsoFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/IsoFields.java Wed May 15 07:48:57 2013 -0700
@@ -146,7 +146,7 @@
* <tr><th>2009-01-05</th><td>Monday</td><td>Week 2 of week-based-year 2009</td></tr>
* </table>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* <p>
* This class is immutable and thread-safe.
*
--- a/jdk/src/share/classes/java/time/temporal/JulianFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/JulianFields.java Wed May 15 07:48:57 2013 -0700
@@ -81,7 +81,7 @@
* The fields are supported, and can be queried and set if {@code EPOCH_DAY} is available.
* The fields work with all chronologies.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This is an immutable and thread-safe class.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/temporal/Temporal.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/Temporal.java Wed May 15 07:48:57 2013 -0700
@@ -119,7 +119,7 @@
* days to months.
* </ul><p>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
* All implementations must be {@link Comparable}.
@@ -146,7 +146,7 @@
* date = date.with(next(WEDNESDAY)); // static import from Adjusters and DayOfWeek
* </pre>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -177,7 +177,7 @@
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the adjustment must be performed.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -217,7 +217,7 @@
* Note that calling {@code plus} followed by {@code minus} is not guaranteed to
* return the same date-time.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -247,12 +247,8 @@
* a date representing the 31st January, then adding one month would be unclear.
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
- * <p>
- * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
- * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
- * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code MONTHS}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all units defined in {@link ChronoUnit}.
* If the unit is supported, then the addition must be performed.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -292,7 +288,7 @@
* Note that calling {@code plus} followed by {@code minus} is not guaranteed to
* return the same date-time.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must not alter either this object.
* Instead, an adjusted copy of the original must be returned.
* This provides equivalent, safe behavior for immutable and mutable implementations.
@@ -322,12 +318,8 @@
* a date representing the 31st March, then subtracting one month would be unclear.
* In cases like this, the field is responsible for resolving the result. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
- * <p>
- * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
- * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
- * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code MONTHS}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must behave in a manor equivalent to the default method behavior.
* <p>
* Implementations must not alter either this object or the specified temporal object.
@@ -353,10 +345,10 @@
//-----------------------------------------------------------------------
/**
- * Calculates the period between this temporal and another temporal in
- * terms of the specified unit.
+ * Calculates the amount of time until another temporal in terms of the specified unit.
* <p>
- * This calculates the period between two temporals in terms of a single unit.
+ * This calculates the amount of time between two temporal objects
+ * of the same type in terms of a single {@code TemporalUnit}.
* The start and end points are {@code this} and the specified temporal.
* The result will be negative if the end is before the start.
* For example, the period in hours between two temporal objects can be
@@ -385,7 +377,7 @@
* long daysBetween = DAYS.between(start, end);
* </pre>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must begin by checking to ensure that the input temporal
* object is of the same observable type as the implementation.
* They must then perform the calculation for all instances of {@link ChronoUnit}.
@@ -410,11 +402,11 @@
* Neither this object, nor the specified temporal, may be altered.
*
* @param endTemporal the end temporal, of the same type as this object, not null
- * @param unit the unit to measure the period in, not null
- * @return the period between this temporal object and the specified one in terms of
- * the unit; positive if the specified object is later than this one, negative if
- * it is earlier than this one
- * @throws DateTimeException if the period cannot be calculated
+ * @param unit the unit to measure the amount in, not null
+ * @return the amount of time between this temporal object and the specified one
+ * in terms of the unit; positive if the specified object is later than this one,
+ * negative if it is earlier than this one
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
--- a/jdk/src/share/classes/java/time/temporal/TemporalAccessor.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAccessor.java Wed May 15 07:48:57 2013 -0700
@@ -94,7 +94,7 @@
* of this interface may be in calendar systems other than ISO.
* See {@link java.time.chrono.ChronoLocalDate} for a fuller discussion of the issues.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -109,7 +109,7 @@
* If false, then calling the {@link #range(TemporalField) range} and {@link #get(TemporalField) get}
* methods will throw an exception.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then true is returned, otherwise false
* <p>
@@ -137,7 +137,7 @@
* and it is important not to read too much into them. For example, there
* could be values within the range that are invalid for the field.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the range of the field must be returned.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -183,7 +183,7 @@
* If the date-time cannot return the value, because the field is unsupported or for
* some other reason, an exception will be thrown.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported and has an {@code int} range, then the value of
* the field must be returned.
@@ -231,7 +231,7 @@
* If the date-time cannot return the value, because the field is unsupported or for
* some other reason, an exception will be thrown.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations must check and handle all fields defined in {@link ChronoField}.
* If the field is supported, then the value of the field must be returned.
* If unsupported, then an {@code UnsupportedTemporalTypeException} must be thrown.
@@ -265,7 +265,7 @@
* {@code LocalDate::from} and {@code ZoneId::from}.
* Additional implementations are provided as static methods on {@link TemporalQuery}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The default implementation must behave equivalent to this code:
* <pre>
* if (query == TemporalQuery.zoneId() ||
--- a/jdk/src/share/classes/java/time/temporal/TemporalAdjuster.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAdjuster.java Wed May 15 07:48:57 2013 -0700
@@ -97,7 +97,7 @@
* <li>finding the next or previous day-of-week, such as "next Thursday"
* </ul>
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
* <p>
@@ -127,7 +127,7 @@
* It is recommended to use the second approach, {@code with(TemporalAdjuster)},
* as it is a lot clearer to read in code.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The implementation must take the input object and adjust it.
* The implementation defines the logic of the adjustment and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
@@ -162,10 +162,10 @@
* This is provided for convenience to make user-written adjusters simpler.
* <p>
* In general, user-written adjusters should be static constants:
- * <pre>
+ * <pre>{@code
* static TemporalAdjuster TWO_DAYS_LATER = TemporalAdjuster.ofDateAdjuster(
* date -> date.plusDays(2));
- * </pre>
+ * }</pre>
*
* @param dateBasedAdjuster the date-based adjuster, not null
* @return the temporal adjuster wrapping on the date adjuster, not null
--- a/jdk/src/share/classes/java/time/temporal/TemporalAmount.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalAmount.java Wed May 15 07:48:57 2013 -0700
@@ -90,7 +90,7 @@
* used in application code. Instead, applications should create and pass
* around instances of concrete types, such as {@code Period} and {@code Duration}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -104,7 +104,7 @@
* value of the {@code TemporalAmount}. A value must be returned
* for each unit listed in {@code getUnits}.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* Implementations may declare support for units not listed by {@link #getUnits()}.
* Typically, the implementation would define additional units
* as conversions for the convenience of developers.
@@ -124,7 +124,7 @@
* The units are ordered from longest duration to the shortest duration
* of the unit.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The list of units completely and uniquely represents the
* state of the object without omissions, overlaps or duplication.
* The units are in order from longest duration to shortest.
@@ -150,7 +150,7 @@
* It is recommended to use the second approach, {@code plus(TemporalAmount)},
* as it is a lot clearer to read in code.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The implementation must take the input object and add to it.
* The implementation defines the logic of the addition and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
@@ -192,7 +192,7 @@
* It is recommended to use the second approach, {@code minus(TemporalAmount)},
* as it is a lot clearer to read in code.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The implementation must take the input object and subtract from it.
* The implementation defines the logic of the subtraction and is responsible for
* documenting that logic. It may use any method on {@code Temporal} to
--- a/jdk/src/share/classes/java/time/temporal/TemporalField.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalField.java Wed May 15 07:48:57 2013 -0700
@@ -82,7 +82,7 @@
* If it is, then the date-time must handle it.
* Otherwise, the method call is re-dispatched to the matching method in this interface.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* Implementations should be {@code Serializable} where possible.
--- a/jdk/src/share/classes/java/time/temporal/TemporalQuery.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalQuery.java Wed May 15 07:48:57 2013 -0700
@@ -96,7 +96,7 @@
* {@code LocalDate::from} and {@code ZoneId::from}.
* Additional common implementations are provided on this interface as static methods.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface places no restrictions on the mutability of implementations,
* however immutability is strongly recommended.
*
@@ -124,7 +124,7 @@
* It is recommended to use the second approach, {@code query(TemporalQuery)},
* as it is a lot clearer to read in code.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* The implementation must take the input object and query it.
* The implementation defines the logic of the query and is responsible for
* documenting that logic.
--- a/jdk/src/share/classes/java/time/temporal/TemporalUnit.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/TemporalUnit.java Wed May 15 07:48:57 2013 -0700
@@ -83,7 +83,7 @@
* If it is, then the date-time must handle it.
* Otherwise, the method call is re-dispatched to the matching method in this interface.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface must be implemented with care to ensure other classes operate correctly.
* All implementations that can be instantiated must be final, immutable and thread-safe.
* It is recommended to use an enum where possible.
@@ -197,19 +197,17 @@
//-----------------------------------------------------------------------
/**
- * Calculates the period in terms of this unit between two temporal objects
- * of the same type.
+ * Calculates the amount of time between two temporal objects.
* <p>
- * This calculates the period between two temporals in terms of this unit.
- * The start and end points are supplied as temporal objects and must be
- * of the same type.
+ * This calculates the amount in terms of this unit. The start and end
+ * points are supplied as temporal objects and must be of the same type.
* The result will be negative if the end is before the start.
- * For example, the period in hours between two temporal objects can be
+ * For example, the amount in hours between two temporal objects can be
* calculated using {@code HOURS.between(startTime, endTime)}.
* <p>
* The calculation returns a whole number, representing the number of
* complete units between the two temporals.
- * For example, the period in hours between the times 11:30 and 13:29
+ * For example, the amount in hours between the times 11:30 and 13:29
* will only be one hour as it is one minute short of two hours.
* <p>
* There are two equivalent ways of using this method.
@@ -237,9 +235,9 @@
*
* @param temporal1 the base temporal object, not null
* @param temporal2 the other temporal object, not null
- * @return the period between temporal1 and temporal2 in terms of this unit;
+ * @return the amount of time between temporal1 and temporal2 in terms of this unit;
* positive if temporal2 is later than temporal1, negative if earlier
- * @throws DateTimeException if the period cannot be calculated
+ * @throws DateTimeException if the amount cannot be calculated
* @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
* @throws ArithmeticException if numeric overflow occurs
*/
--- a/jdk/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
* UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is
* not supported for a Temporal class.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/temporal/ValueRange.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/ValueRange.java Wed May 15 07:48:57 2013 -0700
@@ -79,7 +79,7 @@
* <p>
* Instances of this class are not tied to a specific field.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/temporal/WeekFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/temporal/WeekFields.java Wed May 15 07:48:57 2013 -0700
@@ -170,7 +170,8 @@
* <tr><th>2009-01-05</th><td>Monday</td>
* <td>Week 2 of 2009</td><td>Week 1 of 2009</td></tr>
* </table>
- * <h3>Specification for implementors</h3>
+ *
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
@@ -200,8 +201,6 @@
* Note that the first week may start in the previous calendar year.
* Note also that the first few days of a calendar year may be in the
* week-based-year corresponding to the previous calendar year.
- * <p>
- * This field is an immutable and thread-safe singleton.
*/
public static final WeekFields ISO = new WeekFields(DayOfWeek.MONDAY, 4);
@@ -211,8 +210,6 @@
* <p>
* Defined as starting on Sunday and with a minimum of 1 day in the month.
* This week definition is in use in the US and other European countries.
- * <p>
- * This field is an immutable and thread-safe singleton.
*/
public static final WeekFields SUNDAY_START = WeekFields.of(DayOfWeek.SUNDAY, 1);
@@ -230,7 +227,7 @@
* In that case, the week is set to the last week of the year
* with the same day-of-week.
* <p>
- * This field is an immutable and thread-safe singleton.
+ * This unit is an immutable and thread-safe singleton.
*/
public static final TemporalUnit WEEK_BASED_YEARS = IsoFields.WEEK_BASED_YEARS;
@@ -247,22 +244,18 @@
* The minimal number of days in the first week.
*/
private final int minimalDays;
-
/**
* The field used to access the computed DayOfWeek.
*/
private transient final TemporalField dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
-
/**
* The field used to access the computed WeekOfMonth.
*/
private transient final TemporalField weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
-
/**
* The field used to access the computed WeekOfYear.
*/
private transient final TemporalField weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
-
/**
* The field that represents the week-of-week-based-year.
* <p>
@@ -271,7 +264,6 @@
* This unit is an immutable and thread-safe singleton.
*/
private transient final TemporalField weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
-
/**
* The field that represents the week-based-year.
* <p>
@@ -281,6 +273,7 @@
*/
private transient final TemporalField weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
+ //-----------------------------------------------------------------------
/**
* Obtains an instance of {@code WeekFields} appropriate for a locale.
* <p>
@@ -359,8 +352,7 @@
try {
return WeekFields.of(firstDayOfWeek, minimalDays);
} catch (IllegalArgumentException iae) {
- throw new InvalidObjectException("Invalid serialized WeekFields: "
- + iae.getMessage());
+ throw new InvalidObjectException("Invalid serialized WeekFields: " + iae.getMessage());
}
}
@@ -394,21 +386,24 @@
//-----------------------------------------------------------------------
/**
- * Returns a field to access the day of week,
- * computed based on this WeekFields.
+ * Returns a field to access the day of week based on this {@code WeekFields}.
* <p>
- * The days of week are numbered from 1 to 7.
- * Day number 1 is the {@link #getFirstDayOfWeek() first day-of-week}.
+ * This is similar to {@link ChronoField#DAY_OF_WEEK} but uses values for
+ * the day-of-week based on this {@code WeekFields}.
+ * The days are numbered from 1 to 7 where the
+ * {@link #getFirstDayOfWeek() first day-of-week} is assigned the value 1.
+ * <p>
+ * For example, if the first day-of-week is Sunday, then that will have the
+ * value 1, with other days ranging from Monday as 2 to Saturday as 7.
*
- * @return the field for day-of-week using this week definition, not null
+ * @return a field providing access to the day-of-week with localized numbering, not null
*/
public TemporalField dayOfWeek() {
return dayOfWeek;
}
/**
- * Returns a field to access the week of month,
- * computed based on this WeekFields.
+ * Returns a field to access the week of month based on this {@code WeekFields}.
* <p>
* This represents the concept of the count of weeks within the month where weeks
* start on a fixed day-of-week, such as Monday.
@@ -426,15 +421,15 @@
* - if the 5th day of the month is a Monday, week two starts on the 5th and the 1st to 4th is in week one<br>
* <p>
* This field can be used with any calendar system.
- * @return a TemporalField to access the WeekOfMonth, not null
+ *
+ * @return a field providing access to the week-of-month, not null
*/
public TemporalField weekOfMonth() {
return weekOfMonth;
}
/**
- * Returns a field to access the week of year,
- * computed based on this WeekFields.
+ * Returns a field to access the week of year based on this {@code WeekFields}.
* <p>
* This represents the concept of the count of weeks within the year where weeks
* start on a fixed day-of-week, such as Monday.
@@ -452,15 +447,15 @@
* - if the 5th day of the year is a Monday, week two starts on the 5th and the 1st to 4th is in week one<br>
* <p>
* This field can be used with any calendar system.
- * @return a TemporalField to access the WeekOfYear, not null
+ *
+ * @return a field providing access to the week-of-year, not null
*/
public TemporalField weekOfYear() {
return weekOfYear;
}
/**
- * Returns a field to access the week of a week-based-year,
- * computed based on this WeekFields.
+ * Returns a field to access the week of a week-based-year based on this {@code WeekFields}.
* <p>
* This represents the concept of the count of weeks within the year where weeks
* start on a fixed day-of-week, such as Monday and each week belongs to exactly one year.
@@ -482,15 +477,15 @@
* the 1st to 4th is in week one<br>
* <p>
* This field can be used with any calendar system.
- * @return a TemporalField to access the week of week-based-year, not null
+ *
+ * @return a field providing access to the week-of-week-based-year, not null
*/
public TemporalField weekOfWeekBasedYear() {
return weekOfWeekBasedYear;
}
/**
- * Returns a field to access the year of a week-based-year,
- * computed based on this WeekFields.
+ * Returns a field to access the year of a week-based-year based on this {@code WeekFields}.
* <p>
* This represents the concept of the year where weeks start on a fixed day-of-week,
* such as Monday and each week belongs to exactly one year.
@@ -504,14 +499,16 @@
* is in the last week of the previous year.
* <p>
* This field can be used with any calendar system.
- * @return a TemporalField to access the year of week-based-year, not null
+ *
+ * @return a field providing access to the week-based-year, not null
*/
public TemporalField weekBasedYear() {
return weekBasedYear;
}
+ //-----------------------------------------------------------------------
/**
- * Checks if this WeekFields is equal to the specified object.
+ * Checks if this {@code WeekFields} is equal to the specified object.
* <p>
* The comparison is based on the entire state of the rules, which is
* the first day-of-week and minimal days.
@@ -531,7 +528,7 @@
}
/**
- * A hash code for these rules.
+ * A hash code for this {@code WeekFields}.
*
* @return a suitable hash code
*/
@@ -542,7 +539,7 @@
//-----------------------------------------------------------------------
/**
- * A string representation of this definition.
+ * A string representation of this {@code WeekFields} instance.
*
* @return the string representation, not null
*/
@@ -957,7 +954,6 @@
/**
* Map the field range to a week range of a week year.
* @param temporal the temporal
- * @param field the field to get the range of
* @return the ValueRange with the range adjusted to weeks.
*/
private ValueRange rangeWeekOfWeekBasedYear(TemporalAccessor temporal) {
--- a/jdk/src/share/classes/java/time/zone/Ser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/Ser.java Wed May 15 07:48:57 2013 -0700
@@ -74,7 +74,7 @@
/**
* The shared serialization delegate for this package.
*
- * <h3>Implementation notes</h3>
+ * @implNote
* This class is mutable and should be created once per serialization.
*
* @serial include
--- a/jdk/src/share/classes/java/time/zone/ZoneOffsetTransition.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneOffsetTransition.java Wed May 15 07:48:57 2013 -0700
@@ -89,7 +89,7 @@
* An example would be when the offset changes from {@code +04:00} to {@code +03:00}.
* This might be described as 'the clocks will move back one hour tonight at 2am'.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java Wed May 15 07:48:57 2013 -0700
@@ -90,7 +90,7 @@
* </ul><p>
* These different rule types can be expressed and queried.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/zone/ZoneRules.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRules.java Wed May 15 07:48:57 2013 -0700
@@ -100,7 +100,7 @@
* Applications should treat the data provided as representing the best information
* available to the implementation of this rule.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/zone/ZoneRulesException.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRulesException.java Wed May 15 07:48:57 2013 -0700
@@ -64,7 +64,7 @@
* This exception is used to indicate a problems with the configured
* time-zone rules.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This class is intended for use in a single thread.
*
* @since 1.8
--- a/jdk/src/share/classes/java/time/zone/ZoneRulesProvider.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/time/zone/ZoneRulesProvider.java Wed May 15 07:48:57 2013 -0700
@@ -111,7 +111,7 @@
* Each provider will provide the latest rules for each zone ID, but they
* may also provide the history of how the rules changed.
*
- * <h3>Specification for implementors</h3>
+ * @implSpec
* This interface is a service provider that can be called by multiple threads.
* Implementations must be immutable and thread-safe.
* <p>
--- a/jdk/src/share/classes/java/util/JapaneseImperialCalendar.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/java/util/JapaneseImperialCalendar.java Wed May 15 07:48:57 2013 -0700
@@ -249,11 +249,14 @@
CalendarDate transitionDate = eras[i].getSinceDate();
date.setDate(transitionDate.getYear(), BaseCalendar.JANUARY, 1);
long fdd = gcal.getFixedDate(date);
- dayOfYear = Math.min((int)(fdd - fd), dayOfYear);
+ if (fd != fdd) {
+ dayOfYear = Math.min((int)(fd - fdd) + 1, dayOfYear);
+ }
date.setDate(transitionDate.getYear(), BaseCalendar.DECEMBER, 31);
- fdd = gcal.getFixedDate(date) + 1;
- dayOfYear = Math.min((int)(fd - fdd), dayOfYear);
-
+ fdd = gcal.getFixedDate(date);
+ if (fd != fdd) {
+ dayOfYear = Math.min((int)(fdd - fd) + 1, dayOfYear);
+ }
LocalGregorianCalendar.Date lgd = getCalendarDate(fd - 1);
int y = lgd.getYear();
// Unless the first year starts from January 1, the actual
--- a/jdk/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java Wed May 15 07:48:57 2013 -0700
@@ -246,16 +246,16 @@
return false;
}
ldate.setNormalizedYear(era.getSinceDate().getYear() + ldate.getYear() - 1);
- // If it's not the last Era, validate the date.
- if (era != eras[eras.length - 1]) {
- Date tmp = newCalendarDate(date.getZone());
- tmp.setEra(era).setDate(date.getYear(), date.getMonth(), date.getDayOfMonth());
- normalize(tmp);
- if (tmp.getEra() != era) {
- return false;
- }
+ Date tmp = newCalendarDate(date.getZone());
+ tmp.setEra(era).setDate(date.getYear(), date.getMonth(), date.getDayOfMonth());
+ normalize(tmp);
+ if (tmp.getEra() != era) {
+ return false;
}
} else {
+ if (date.getYear() >= eras[0].getSinceDate().getYear()) {
+ return false;
+ }
ldate.setNormalizedYear(ldate.getYear());
}
return super.validate(ldate);
--- a/jdk/test/java/time/tck/java/time/TCKInstant.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKInstant.java Wed May 15 07:48:57 2013 -0700
@@ -370,6 +370,8 @@
{"Z"},
{"1970-01-01T00:00:00"},
{"1970-01-01T00:00:0Z"},
+ {"1970-01-01T00:0:00Z"},
+ {"1970-01-01T0:00:00Z"},
{"1970-01-01T00:00:00.0000000000Z"},
};
}
@@ -2045,60 +2047,64 @@
Object[][] data_toString() {
return new Object[][] {
{Instant.ofEpochSecond(65L, 567), "1970-01-01T00:01:05.000000567Z"},
+ {Instant.ofEpochSecond(65L, 560), "1970-01-01T00:01:05.000000560Z"},
+ {Instant.ofEpochSecond(65L, 560000), "1970-01-01T00:01:05.000560Z"},
+ {Instant.ofEpochSecond(65L, 560000000), "1970-01-01T00:01:05.560Z"},
+
{Instant.ofEpochSecond(1, 0), "1970-01-01T00:00:01Z"},
- {Instant.ofEpochSecond(60, 0), "1970-01-01T00:01Z"},
- {Instant.ofEpochSecond(3600, 0), "1970-01-01T01:00Z"},
+ {Instant.ofEpochSecond(60, 0), "1970-01-01T00:01:00Z"},
+ {Instant.ofEpochSecond(3600, 0), "1970-01-01T01:00:00Z"},
{Instant.ofEpochSecond(-1, 0), "1969-12-31T23:59:59Z"},
- {LocalDateTime.of(0, 1, 2, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-02T00:00Z"},
- {LocalDateTime.of(0, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "0000-01-01T12:30Z"},
+ {LocalDateTime.of(0, 1, 2, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-02T00:00:00Z"},
+ {LocalDateTime.of(0, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "0000-01-01T12:30:00Z"},
{LocalDateTime.of(0, 1, 1, 0, 0, 0, 1).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00.000000001Z"},
- {LocalDateTime.of(0, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-01T00:00Z"},
+ {LocalDateTime.of(0, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00Z"},
{LocalDateTime.of(-1, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-0001-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-1, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-31T12:30Z"},
- {LocalDateTime.of(-1, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-30T12:30Z"},
+ {LocalDateTime.of(-1, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-31T12:30:00Z"},
+ {LocalDateTime.of(-1, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-30T12:30:00Z"},
- {LocalDateTime.of(-9999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-02T12:30Z"},
- {LocalDateTime.of(-9999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-01T12:30Z"},
- {LocalDateTime.of(-9999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-9999-01-01T00:00Z"},
+ {LocalDateTime.of(-9999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-02T12:30:00Z"},
+ {LocalDateTime.of(-9999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-01T12:30:00Z"},
+ {LocalDateTime.of(-9999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-9999-01-01T00:00:00Z"},
{LocalDateTime.of(-10000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-10000-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-10000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-31T12:30Z"},
- {LocalDateTime.of(-10000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-30T12:30Z"},
- {LocalDateTime.of(-15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-15000-12-31T12:30Z"},
+ {LocalDateTime.of(-10000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-31T12:30:00Z"},
+ {LocalDateTime.of(-10000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-30T12:30:00Z"},
+ {LocalDateTime.of(-15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-15000-12-31T12:30:00Z"},
- {LocalDateTime.of(-19999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-02T12:30Z"},
- {LocalDateTime.of(-19999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-01T12:30Z"},
- {LocalDateTime.of(-19999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-19999-01-01T00:00Z"},
+ {LocalDateTime.of(-19999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-02T12:30:00Z"},
+ {LocalDateTime.of(-19999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-01T12:30:00Z"},
+ {LocalDateTime.of(-19999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-19999-01-01T00:00:00Z"},
{LocalDateTime.of(-20000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-20000-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(-20000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-31T12:30Z"},
- {LocalDateTime.of(-20000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-30T12:30Z"},
- {LocalDateTime.of(-25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-25000-12-31T12:30Z"},
+ {LocalDateTime.of(-20000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-31T12:30:00Z"},
+ {LocalDateTime.of(-20000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-30T12:30:00Z"},
+ {LocalDateTime.of(-25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-25000-12-31T12:30:00Z"},
- {LocalDateTime.of(9999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-30T12:30Z"},
- {LocalDateTime.of(9999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-31T12:30Z"},
+ {LocalDateTime.of(9999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-30T12:30:00Z"},
+ {LocalDateTime.of(9999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-31T12:30:00Z"},
{LocalDateTime.of(9999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "9999-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(10000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+10000-01-01T00:00Z"},
- {LocalDateTime.of(10000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-01T12:30Z"},
- {LocalDateTime.of(10000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-02T12:30Z"},
- {LocalDateTime.of(15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+15000-12-31T12:30Z"},
+ {LocalDateTime.of(10000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+10000-01-01T00:00:00Z"},
+ {LocalDateTime.of(10000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-01T12:30:00Z"},
+ {LocalDateTime.of(10000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-02T12:30:00Z"},
+ {LocalDateTime.of(15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+15000-12-31T12:30:00Z"},
- {LocalDateTime.of(19999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-30T12:30Z"},
- {LocalDateTime.of(19999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-31T12:30Z"},
+ {LocalDateTime.of(19999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-30T12:30:00Z"},
+ {LocalDateTime.of(19999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-31T12:30:00Z"},
{LocalDateTime.of(19999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "+19999-12-31T23:59:59.999999999Z"},
- {LocalDateTime.of(20000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+20000-01-01T00:00Z"},
- {LocalDateTime.of(20000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-01T12:30Z"},
- {LocalDateTime.of(20000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-02T12:30Z"},
- {LocalDateTime.of(25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+25000-12-31T12:30Z"},
+ {LocalDateTime.of(20000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+20000-01-01T00:00:00Z"},
+ {LocalDateTime.of(20000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-01T12:30:00Z"},
+ {LocalDateTime.of(20000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-02T12:30:00Z"},
+ {LocalDateTime.of(25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+25000-12-31T12:30:00Z"},
- {LocalDateTime.of(-999_999_999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC).minus(1, DAYS), "-1000000000-12-31T12:30Z"},
- {LocalDateTime.of(999_999_999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC).plus(1, DAYS), "+1000000000-01-01T12:30Z"},
+ {LocalDateTime.of(-999_999_999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC).minus(1, DAYS), "-1000000000-12-31T12:30:00Z"},
+ {LocalDateTime.of(999_999_999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC).plus(1, DAYS), "+1000000000-01-01T12:30:00Z"},
- {Instant.MIN, "-1000000000-01-01T00:00Z"},
+ {Instant.MIN, "-1000000000-01-01T00:00:00Z"},
{Instant.MAX, "+1000000000-12-31T23:59:59.999999999Z"},
};
}
--- a/jdk/test/java/time/tck/java/time/TCKLocalTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKLocalTime.java Wed May 15 07:48:57 2013 -0700
@@ -142,7 +142,7 @@
private static final TemporalUnit[] INVALID_UNITS;
static {
- EnumSet<ChronoUnit> set = EnumSet.range(WEEKS, FOREVER);
+ EnumSet<ChronoUnit> set = EnumSet.range(DAYS, FOREVER);
INVALID_UNITS = (TemporalUnit[]) set.toArray(new TemporalUnit[set.size()]);
}
@@ -1122,14 +1122,6 @@
}
}
- @Test
- public void test_plus_longTemporalUnit_multiples() {
- assertEquals(TEST_12_30_40_987654321.plus(0, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.plus(1, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.plus(2, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.plus(-3, DAYS), TEST_12_30_40_987654321);
- }
-
@Test(expectedExceptions=NullPointerException.class)
public void test_plus_longTemporalUnit_null() {
TEST_12_30_40_987654321.plus(1, (TemporalUnit) null);
@@ -1556,14 +1548,6 @@
}
}
- @Test
- public void test_minus_longTemporalUnit_long_multiples() {
- assertEquals(TEST_12_30_40_987654321.minus(0, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.minus(1, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.minus(2, DAYS), TEST_12_30_40_987654321);
- assertEquals(TEST_12_30_40_987654321.minus(-3, DAYS), TEST_12_30_40_987654321);
- }
-
@Test(expectedExceptions=NullPointerException.class)
public void test_minus_longTemporalUnit_null() {
TEST_12_30_40_987654321.minus(1, (TemporalUnit) null);
--- a/jdk/test/java/time/tck/java/time/TCKOffsetTime.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKOffsetTime.java Wed May 15 07:48:57 2013 -0700
@@ -75,7 +75,13 @@
import static java.time.temporal.ChronoField.OFFSET_SECONDS;
import static java.time.temporal.ChronoField.SECOND_OF_DAY;
import static java.time.temporal.ChronoField.SECOND_OF_MINUTE;
+import static java.time.temporal.ChronoUnit.MONTHS;
import static java.time.temporal.ChronoUnit.DAYS;
+import static java.time.temporal.ChronoUnit.HOURS;
+import static java.time.temporal.ChronoUnit.MINUTES;
+import static java.time.temporal.ChronoUnit.MICROS;
+import static java.time.temporal.ChronoUnit.MILLIS;
+import static java.time.temporal.ChronoUnit.HALF_DAYS;
import static java.time.temporal.ChronoUnit.NANOS;
import static java.time.temporal.ChronoUnit.SECONDS;
import static org.testng.Assert.assertEquals;
@@ -110,6 +116,7 @@
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalQuery;
+import java.time.temporal.TemporalUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -1031,6 +1038,56 @@
}
//-----------------------------------------------------------------------
+ // periodUntil(Temporal, TemporalUnit)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="periodUntilUnit")
+ Object[][] data_periodUntilUnit() {
+ return new Object[][] {
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(13, 1, 1), ZoneOffset.ofHours(1)), HALF_DAYS, 1},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), HOURS, 1},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), MINUTES, 60},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), SECONDS, 3600},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), MILLIS, 3600*1000},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), MICROS, 3600*1000*1000L},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1)), NANOS, 3600*1000*1000L*1000},
+
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(14, 1, 1), ZoneOffset.ofHours(2)), HALF_DAYS, 1},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), HOURS, 1},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), MINUTES, 60},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), SECONDS, 3600},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), MILLIS, 3600*1000},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), MICROS, 3600*1000*1000L},
+ {OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1)), OffsetTime.of(LocalTime.of(3, 1, 1), ZoneOffset.ofHours(2)), NANOS, 3600*1000*1000L*1000},
+ };
+ }
+
+ @Test(dataProvider="periodUntilUnit")
+ public void test_periodUntil_TemporalUnit(OffsetTime offsetTime1, OffsetTime offsetTime2, TemporalUnit unit, long expected) {
+ long amount = offsetTime1.periodUntil(offsetTime2, unit);
+ assertEquals(amount, expected);
+ }
+
+ @Test(dataProvider="periodUntilUnit")
+ public void test_periodUntil_TemporalUnit_negated(OffsetTime offsetTime1, OffsetTime offsetTime2, TemporalUnit unit, long expected) {
+ long amount = offsetTime2.periodUntil(offsetTime1, unit);
+ assertEquals(amount, -expected);
+ }
+
+ @Test(expectedExceptions=DateTimeException.class)
+ public void test_periodUntil_InvalidType() {
+ OffsetTime offsetTime = OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1));
+ OffsetDateTime offsetDateTime = offsetTime.atDate(LocalDate.of(1980, 2, 10));
+ offsetTime.periodUntil(offsetDateTime, SECONDS);
+ }
+
+ @Test(expectedExceptions=DateTimeException.class)
+ public void test_periodUntil_InvalidTemporalUnit() {
+ OffsetTime offsetTime1 = OffsetTime.of(LocalTime.of(1, 1, 1), ZoneOffset.ofHours(1));
+ OffsetTime offsetTime2 = OffsetTime.of(LocalTime.of(2, 1, 1), ZoneOffset.ofHours(1));
+ offsetTime1.periodUntil(offsetTime2, MONTHS);
+ }
+
+ //-----------------------------------------------------------------------
// format(DateTimeFormatter)
//-----------------------------------------------------------------------
@Test
--- a/jdk/test/java/time/tck/java/time/TCKYear.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKYear.java Wed May 15 07:48:57 2013 -0700
@@ -71,6 +71,7 @@
import static java.time.temporal.ChronoUnit.WEEKS;
import static java.time.temporal.ChronoUnit.YEARS;
import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
import java.io.ByteArrayOutputStream;
@@ -89,6 +90,7 @@
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZoneOffset;
+import java.time.chrono.IsoEra;
import java.time.chrono.IsoChronology;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
@@ -526,6 +528,47 @@
}
//-----------------------------------------------------------------------
+ // plus(long, TemporalUnit)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="plus_long_TemporalUnit")
+ Object[][] data_plus_long_TemporalUnit() {
+ return new Object[][] {
+ {Year.of(1), 1, ChronoUnit.YEARS, Year.of(2), null},
+ {Year.of(1), -12, ChronoUnit.YEARS, Year.of(-11), null},
+ {Year.of(1), 0, ChronoUnit.YEARS, Year.of(1), null},
+ {Year.of(999999999), 0, ChronoUnit.YEARS, Year.of(999999999), null},
+ {Year.of(-999999999), 0, ChronoUnit.YEARS, Year.of(-999999999), null},
+ {Year.of(0), -999999999, ChronoUnit.YEARS, Year.of(-999999999), null},
+ {Year.of(0), 999999999, ChronoUnit.YEARS, Year.of(999999999), null},
+
+ {Year.of(-1), 1, ChronoUnit.ERAS, Year.of(2), null},
+ {Year.of(5), 1, ChronoUnit.CENTURIES, Year.of(105), null},
+ {Year.of(5), 1, ChronoUnit.DECADES, Year.of(15), null},
+
+ {Year.of(999999999), 1, ChronoUnit.YEARS, null, DateTimeException.class},
+ {Year.of(-999999999), -1, ChronoUnit.YEARS, null, DateTimeException.class},
+
+ {Year.of(1), 0, ChronoUnit.DAYS, null, DateTimeException.class},
+ {Year.of(1), 0, ChronoUnit.WEEKS, null, DateTimeException.class},
+ {Year.of(1), 0, ChronoUnit.MONTHS, null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="plus_long_TemporalUnit")
+ public void test_plus_long_TemporalUnit(Year base, long amount, TemporalUnit unit, Year expectedYear, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.plus(amount, unit), expectedYear);
+ } else {
+ try {
+ Year result = base.plus(amount, unit);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
// minus(Period)
//-----------------------------------------------------------------------
@DataProvider(name="minusValid")
@@ -617,6 +660,47 @@
}
//-----------------------------------------------------------------------
+ // minus(long, TemporalUnit)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="minus_long_TemporalUnit")
+ Object[][] data_minus_long_TemporalUnit() {
+ return new Object[][] {
+ {Year.of(1), 1, ChronoUnit.YEARS, Year.of(0), null},
+ {Year.of(1), -12, ChronoUnit.YEARS, Year.of(13), null},
+ {Year.of(1), 0, ChronoUnit.YEARS, Year.of(1), null},
+ {Year.of(999999999), 0, ChronoUnit.YEARS, Year.of(999999999), null},
+ {Year.of(-999999999), 0, ChronoUnit.YEARS, Year.of(-999999999), null},
+ {Year.of(0), -999999999, ChronoUnit.YEARS, Year.of(999999999), null},
+ {Year.of(0), 999999999, ChronoUnit.YEARS, Year.of(-999999999), null},
+
+ {Year.of(999999999), 1, ChronoUnit.ERAS, Year.of(-999999999 + 1), null},
+ {Year.of(105), 1, ChronoUnit.CENTURIES, Year.of(5), null},
+ {Year.of(15), 1, ChronoUnit.DECADES, Year.of(5), null},
+
+ {Year.of(-999999999), 1, ChronoUnit.YEARS, null, DateTimeException.class},
+ {Year.of(1), -999999999, ChronoUnit.YEARS, null, DateTimeException.class},
+
+ {Year.of(1), 0, ChronoUnit.DAYS, null, DateTimeException.class},
+ {Year.of(1), 0, ChronoUnit.WEEKS, null, DateTimeException.class},
+ {Year.of(1), 0, ChronoUnit.MONTHS, null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="minus_long_TemporalUnit")
+ public void test_minus_long_TemporalUnit(Year base, long amount, TemporalUnit unit, Year expectedYear, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.minus(amount, unit), expectedYear);
+ } else {
+ try {
+ Year result = base.minus(amount, unit);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
// adjustInto()
//-----------------------------------------------------------------------
@Test
@@ -641,6 +725,49 @@
}
//-----------------------------------------------------------------------
+ // with(TemporalAdjuster)
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_with_TemporalAdjuster() {
+ Year base = Year.of(-10);
+ for (int i = -4; i <= 2104; i++) {
+ Temporal result = base.with(Year.of(i));
+ assertEquals(result, Year.of(i));
+ }
+ }
+
+ @Test(expectedExceptions=DateTimeException.class)
+ public void test_with_BadTemporalAdjuster() {
+ Year test = Year.of(1);
+ test.with(LocalTime.of(18, 1, 2));
+ }
+
+ //-----------------------------------------------------------------------
+ // with(TemporalField, long)
+ //-----------------------------------------------------------------------
+ @Test(groups={"tck"})
+ public void test_with() {
+ Year base = Year.of(5);
+ Year result = base.with(ChronoField.ERA, 0);
+ assertEquals(result, base.with(IsoEra.of(0)));
+
+ int prolepticYear = IsoChronology.INSTANCE.prolepticYear(IsoEra.of(0), 5);
+ assertEquals(result.get(ChronoField.ERA), 0);
+ assertEquals(result.get(ChronoField.YEAR), prolepticYear);
+ assertEquals(result.get(ChronoField.YEAR_OF_ERA), 5);
+
+ result = base.with(ChronoField.YEAR, 10);
+ assertEquals(result.get(ChronoField.ERA), base.get(ChronoField.ERA));
+ assertEquals(result.get(ChronoField.YEAR), 10);
+ assertEquals(result.get(ChronoField.YEAR_OF_ERA), 10);
+
+ result = base.with(ChronoField.YEAR_OF_ERA, 20);
+ assertEquals(result.get(ChronoField.ERA), base.get(ChronoField.ERA));
+ assertEquals(result.get(ChronoField.YEAR), 20);
+ assertEquals(result.get(ChronoField.YEAR_OF_ERA), 20);
+ }
+
+ //-----------------------------------------------------------------------
// length()
//-----------------------------------------------------------------------
@Test
--- a/jdk/test/java/time/tck/java/time/TCKYearMonth.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKYearMonth.java Wed May 15 07:48:57 2013 -0700
@@ -81,6 +81,7 @@
import java.io.IOException;
import java.time.Clock;
import java.time.DateTimeException;
+import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
@@ -98,6 +99,7 @@
import java.time.temporal.ChronoUnit;
import java.time.temporal.JulianFields;
import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalUnit;
@@ -689,6 +691,106 @@
}
//-----------------------------------------------------------------------
+ // plus(long, TemporalUnit)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="plus_long_TemporalUnit")
+ Object[][] data_plus_long_TemporalUnit() {
+ return new Object[][] {
+ {YearMonth.of(1, 10), 1, ChronoUnit.YEARS, YearMonth.of(2, 10), null},
+ {YearMonth.of(1, 10), -12, ChronoUnit.YEARS, YearMonth.of(-11, 10), null},
+ {YearMonth.of(1, 10), 0, ChronoUnit.YEARS, YearMonth.of(1, 10), null},
+ {YearMonth.of(999999999, 12), 0, ChronoUnit.YEARS, YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), 0, ChronoUnit.YEARS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 1), -999999999, ChronoUnit.YEARS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 12), 999999999, ChronoUnit.YEARS, YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 10), 1, ChronoUnit.MONTHS, YearMonth.of(1, 11), null},
+ {YearMonth.of(1, 10), -12, ChronoUnit.MONTHS, YearMonth.of(0, 10), null},
+ {YearMonth.of(1, 10), 0, ChronoUnit.MONTHS, YearMonth.of(1, 10), null},
+ {YearMonth.of(999999999, 12), 0, ChronoUnit.MONTHS, YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), 0, ChronoUnit.MONTHS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(-999999999, 2), -1, ChronoUnit.MONTHS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(999999999, 3), 9, ChronoUnit.MONTHS, YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(-1, 10), 1, ChronoUnit.ERAS, YearMonth.of(2, 10), null},
+ {YearMonth.of(5, 10), 1, ChronoUnit.CENTURIES, YearMonth.of(105, 10), null},
+ {YearMonth.of(5, 10), 1, ChronoUnit.DECADES, YearMonth.of(15, 10), null},
+
+ {YearMonth.of(999999999, 12), 1, ChronoUnit.MONTHS, null, DateTimeException.class},
+ {YearMonth.of(-999999999, 1), -1, ChronoUnit.MONTHS, null, DateTimeException.class},
+
+ {YearMonth.of(1, 1), 0, ChronoUnit.DAYS, null, DateTimeException.class},
+ {YearMonth.of(1, 1), 0, ChronoUnit.WEEKS, null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="plus_long_TemporalUnit")
+ public void test_plus_long_TemporalUnit(YearMonth base, long amount, TemporalUnit unit, YearMonth expectedYearMonth, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.plus(amount, unit), expectedYearMonth);
+ } else {
+ try {
+ YearMonth result = base.plus(amount, unit);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ // plus(TemporalAmount)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="plus_TemporalAmount")
+ Object[][] data_plus_TemporalAmount() {
+ return new Object[][] {
+ {YearMonth.of(1, 1), Period.ofYears(1), YearMonth.of(2, 1), null},
+ {YearMonth.of(1, 1), Period.ofYears(-12), YearMonth.of(-11, 1), null},
+ {YearMonth.of(1, 1), Period.ofYears(0), YearMonth.of(1, 1), null},
+ {YearMonth.of(999999999, 12), Period.ofYears(0), YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), Period.ofYears(0), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 1), Period.ofYears(-999999999), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 12), Period.ofYears(999999999), YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofMonths(1), YearMonth.of(1, 2), null},
+ {YearMonth.of(1, 1), Period.ofMonths(-12), YearMonth.of(0, 1), null},
+ {YearMonth.of(1, 1), Period.ofMonths(121), YearMonth.of(11, 2), null},
+ {YearMonth.of(1, 1), Period.ofMonths(0), YearMonth.of(1, 1), null},
+ {YearMonth.of(999999999, 12), Period.ofMonths(0), YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), Period.ofMonths(0), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(-999999999, 2), Period.ofMonths(-1), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(999999999, 11), Period.ofMonths(1), YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofYears(1).withMonths(2), YearMonth.of(2, 3), null},
+ {YearMonth.of(1, 1), Period.ofYears(-12).withMonths(-1), YearMonth.of(-12, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofMonths(2).withYears(1), YearMonth.of(2, 3), null},
+ {YearMonth.of(1, 1), Period.ofMonths(-1).withYears(-12), YearMonth.of(-12, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofDays(365), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofDays(365), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofHours(365*24), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofMinutes(365*24*60), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofSeconds(365*24*3600), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofNanos(365*24*3600*1000000000), null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="plus_TemporalAmount")
+ public void test_plus_TemporalAmount(YearMonth base, TemporalAmount temporalAmount, YearMonth expectedYearMonth, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.plus(temporalAmount), expectedYearMonth);
+ } else {
+ try {
+ YearMonth result = base.plus(temporalAmount);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
// minusYears()
//-----------------------------------------------------------------------
@Test
@@ -804,6 +906,106 @@
}
//-----------------------------------------------------------------------
+ // minus(long, TemporalUnit)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="minus_long_TemporalUnit")
+ Object[][] data_minus_long_TemporalUnit() {
+ return new Object[][] {
+ {YearMonth.of(1, 10), 1, ChronoUnit.YEARS, YearMonth.of(0, 10), null},
+ {YearMonth.of(1, 10), 12, ChronoUnit.YEARS, YearMonth.of(-11, 10), null},
+ {YearMonth.of(1, 10), 0, ChronoUnit.YEARS, YearMonth.of(1, 10), null},
+ {YearMonth.of(999999999, 12), 0, ChronoUnit.YEARS, YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), 0, ChronoUnit.YEARS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 1), 999999999, ChronoUnit.YEARS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 12), -999999999, ChronoUnit.YEARS, YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 10), 1, ChronoUnit.MONTHS, YearMonth.of(1, 9), null},
+ {YearMonth.of(1, 10), 12, ChronoUnit.MONTHS, YearMonth.of(0, 10), null},
+ {YearMonth.of(1, 10), 0, ChronoUnit.MONTHS, YearMonth.of(1, 10), null},
+ {YearMonth.of(999999999, 12), 0, ChronoUnit.MONTHS, YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), 0, ChronoUnit.MONTHS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(-999999999, 2), 1, ChronoUnit.MONTHS, YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(999999999, 11), -1, ChronoUnit.MONTHS, YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 10), 1, ChronoUnit.ERAS, YearMonth.of(0, 10), null},
+ {YearMonth.of(5, 10), 1, ChronoUnit.CENTURIES, YearMonth.of(-95, 10), null},
+ {YearMonth.of(5, 10), 1, ChronoUnit.DECADES, YearMonth.of(-5, 10), null},
+
+ {YearMonth.of(999999999, 12), -1, ChronoUnit.MONTHS, null, DateTimeException.class},
+ {YearMonth.of(-999999999, 1), 1, ChronoUnit.MONTHS, null, DateTimeException.class},
+
+ {YearMonth.of(1, 1), 0, ChronoUnit.DAYS, null, DateTimeException.class},
+ {YearMonth.of(1, 1), 0, ChronoUnit.WEEKS, null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="minus_long_TemporalUnit")
+ public void test_minus_long_TemporalUnit(YearMonth base, long amount, TemporalUnit unit, YearMonth expectedYearMonth, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.minus(amount, unit), expectedYearMonth);
+ } else {
+ try {
+ YearMonth result = base.minus(amount, unit);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ // minus(TemporalAmount)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="minus_TemporalAmount")
+ Object[][] data_minus_TemporalAmount() {
+ return new Object[][] {
+ {YearMonth.of(1, 1), Period.ofYears(1), YearMonth.of(0, 1), null},
+ {YearMonth.of(1, 1), Period.ofYears(-12), YearMonth.of(13, 1), null},
+ {YearMonth.of(1, 1), Period.ofYears(0), YearMonth.of(1, 1), null},
+ {YearMonth.of(999999999, 12), Period.ofYears(0), YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), Period.ofYears(0), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 1), Period.ofYears(999999999), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(0, 12), Period.ofYears(-999999999), YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofMonths(1), YearMonth.of(0, 12), null},
+ {YearMonth.of(1, 1), Period.ofMonths(-12), YearMonth.of(2, 1), null},
+ {YearMonth.of(1, 1), Period.ofMonths(121), YearMonth.of(-10, 12), null},
+ {YearMonth.of(1, 1), Period.ofMonths(0), YearMonth.of(1, 1), null},
+ {YearMonth.of(999999999, 12), Period.ofMonths(0), YearMonth.of(999999999, 12), null},
+ {YearMonth.of(-999999999, 1), Period.ofMonths(0), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(-999999999, 2), Period.ofMonths(1), YearMonth.of(-999999999, 1), null},
+ {YearMonth.of(999999999, 11), Period.ofMonths(-1), YearMonth.of(999999999, 12), null},
+
+ {YearMonth.of(1, 1), Period.ofYears(1).withMonths(2), YearMonth.of(-1, 11), null},
+ {YearMonth.of(1, 1), Period.ofYears(-12).withMonths(-1), YearMonth.of(13, 2), null},
+
+ {YearMonth.of(1, 1), Period.ofMonths(2).withYears(1), YearMonth.of(-1, 11), null},
+ {YearMonth.of(1, 1), Period.ofMonths(-1).withYears(-12), YearMonth.of(13, 2), null},
+
+ {YearMonth.of(1, 1), Period.ofDays(365), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofDays(365), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofHours(365*24), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofMinutes(365*24*60), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofSeconds(365*24*3600), null, DateTimeException.class},
+ {YearMonth.of(1, 1), Duration.ofNanos(365*24*3600*1000000000), null, DateTimeException.class},
+ };
+ }
+
+ @Test(groups={"tck"}, dataProvider="minus_TemporalAmount")
+ public void test_minus_TemporalAmount(YearMonth base, TemporalAmount temporalAmount, YearMonth expectedYearMonth, Class expectedEx) {
+ if (expectedEx == null) {
+ assertEquals(base.minus(temporalAmount), expectedYearMonth);
+ } else {
+ try {
+ YearMonth result = base.minus(temporalAmount);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
// adjustInto()
//-----------------------------------------------------------------------
@Test
--- a/jdk/test/java/time/tck/java/time/TCKZoneOffset.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/TCKZoneOffset.java Wed May 15 07:48:57 2013 -0700
@@ -73,8 +73,10 @@
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
+import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
+import java.time.OffsetDateTime;
import java.time.temporal.ChronoField;
import java.time.temporal.JulianFields;
import java.time.temporal.TemporalAccessor;
@@ -620,6 +622,45 @@
}
//-----------------------------------------------------------------------
+ // adjustInto()
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_adjustInto_ZonedDateTime() {
+ ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
+ for (String zoneId : ZoneId.getAvailableZoneIds()) {
+ //Do not change offset of ZonedDateTime after adjustInto()
+ ZonedDateTime zonedDateTime_target = ZonedDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneId.of(zoneId));
+ ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
+ assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());
+
+ OffsetDateTime offsetDateTime_target = zonedDateTime_target.toOffsetDateTime();
+ OffsetDateTime offsetDateTime_result = (OffsetDateTime)(base.adjustInto(offsetDateTime_target));
+ assertEquals(base, offsetDateTime_result.getOffset());
+ }
+ }
+
+ @Test
+ public void test_adjustInto_OffsetDateTime() {
+ ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
+ for (int i=-18; i<=18; i++) {
+ OffsetDateTime offsetDateTime_target = OffsetDateTime.of(LocalDate.of(1909, 2, 2), LocalTime.of(10, 10, 10), ZoneOffset.ofHours(i));
+ OffsetDateTime offsetDateTime_result = (OffsetDateTime)base.adjustInto(offsetDateTime_target);
+ assertEquals(base, offsetDateTime_result.getOffset());
+
+ //Do not change offset of ZonedDateTime after adjustInto()
+ ZonedDateTime zonedDateTime_target = offsetDateTime_target.toZonedDateTime();
+ ZonedDateTime zonedDateTime_result = (ZonedDateTime)(base.adjustInto(zonedDateTime_target));
+ assertEquals(zonedDateTime_target.getOffset(), zonedDateTime_result.getOffset());
+ }
+ }
+
+ @Test(expectedExceptions=DateTimeException.class)
+ public void test_adjustInto_dateOnly() {
+ ZoneOffset base = ZoneOffset.ofHoursMinutesSeconds(1, 1, 1);
+ base.adjustInto((LocalDate.of(1909, 2, 2)));
+ }
+
+ //-----------------------------------------------------------------------
// toString()
//-----------------------------------------------------------------------
@Test
--- a/jdk/test/java/time/tck/java/time/chrono/TCKChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/chrono/TCKChronology.java Wed May 15 07:48:57 2013 -0700
@@ -162,39 +162,30 @@
@DataProvider(name = "calendarsystemtype")
Object[][] data_CalendarType() {
return new Object[][] {
- {HijrahChronology.INSTANCE, "islamic", "umalqura"},
- {IsoChronology.INSTANCE, "iso8601", null},
- {JapaneseChronology.INSTANCE, "japanese", null},
- {MinguoChronology.INSTANCE, "roc", null},
- {ThaiBuddhistChronology.INSTANCE, "buddhist", null},
+ {HijrahChronology.INSTANCE, "islamic-umalqura"},
+ {IsoChronology.INSTANCE, "iso8601"},
+ {JapaneseChronology.INSTANCE, "japanese"},
+ {MinguoChronology.INSTANCE, "roc"},
+ {ThaiBuddhistChronology.INSTANCE, "buddhist"},
};
}
@Test(dataProvider = "calendarsystemtype")
- public void test_getCalendarType(Chronology chrono, String calendarType, String variant) {
+ public void test_getCalendarType(Chronology chrono, String calendarType) {
String type = calendarType;
- if (variant != null) {
- type += '-';
- type += variant;
- }
assertEquals(chrono.getCalendarType(), type);
}
@Test(dataProvider = "calendarsystemtype")
- public void test_lookupLocale(Chronology chrono, String calendarType, String variant) {
+ public void test_lookupLocale(Chronology chrono, String calendarType) {
Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
builder.setUnicodeLocaleKeyword("ca", calendarType);
- if (variant != null) {
- builder.setUnicodeLocaleKeyword("cv", variant);
- }
Locale locale = builder.build();
assertEquals(Chronology.ofLocale(locale), chrono);
}
-
/**
* Test lookup by calendarType of each chronology.
- * The calendarType is split on "-" to separate the calendar and variant.
* Verify that the calendar can be found by {@link java.time.chrono.Chronology#ofLocale}.
*/
@Test
@@ -202,15 +193,10 @@
// Test that all available chronologies can be successfully found using ofLocale
Set<Chronology> chronos = Chronology.getAvailableChronologies();
for (Chronology chrono : chronos) {
- String[] split = chrono.getCalendarType().split("-");
-
Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
- builder.setUnicodeLocaleKeyword("ca", split[0]);
- if (split.length > 1) {
- builder.setUnicodeLocaleKeyword("cv", split[1]);
- }
+ builder.setUnicodeLocaleKeyword("ca", chrono.getCalendarType());
Locale locale = builder.build();
- assertEquals(Chronology.ofLocale(locale), chrono, "Lookup by type and variant");
+ assertEquals(Chronology.ofLocale(locale), chrono, "Lookup by type");
}
}
@@ -218,7 +204,6 @@
public void test_lookupLocale() {
Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
builder.setUnicodeLocaleKeyword("ca", "xxx");
- builder.setUnicodeLocaleKeyword("cv", "yyy");
Locale locale = builder.build();
Chronology.ofLocale(locale);
--- a/jdk/test/java/time/tck/java/time/chrono/TCKChronologySerialization.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/chrono/TCKChronologySerialization.java Wed May 15 07:48:57 2013 -0700
@@ -93,7 +93,6 @@
//-----------------------------------------------------------------------
@Test(dataProvider="calendars")
public void test_ChronoSerialization(Chronology chrono) throws Exception {
- System.out.printf(" ChronoSerialization: %s%n", chrono);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(baos);
out.writeObject(chrono);
--- a/jdk/test/java/time/tck/java/time/chrono/TCKHijrahChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/chrono/TCKHijrahChronology.java Wed May 15 07:48:57 2013 -0700
@@ -62,16 +62,20 @@
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
+import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.Chronology;
import java.time.chrono.Era;
import java.time.chrono.HijrahChronology;
import java.time.chrono.HijrahDate;
+import java.time.chrono.HijrahEra;
import java.time.chrono.IsoChronology;
import java.time.chrono.MinguoChronology;
import java.time.chrono.MinguoDate;
@@ -119,8 +123,11 @@
//{HijrahChronology.INSTANCE.date(1324, 7, 3), LocalDate.of(1906, 8, 23)},
//{HijrahChronology.INSTANCE.date(1324, 7, 4), LocalDate.of(1906, 8, 24)},
//{HijrahChronology.INSTANCE.date(1325, 1, 1), LocalDate.of(1907, 2, 13)},
+
{HijrahChronology.INSTANCE.date(1434, 7, 1), LocalDate.of(2013, 5, 11)},
-
+ {HijrahChronology.INSTANCE.date(HijrahEra.AH, 1434, 7, 1), LocalDate.of(2013, 5, 11)},
+ {HijrahChronology.INSTANCE.dateYearDay(HijrahEra.AH, 1434, 178), LocalDate.of(2013, 5, 11)},
+ {HijrahChronology.INSTANCE.dateYearDay(1434, 178), LocalDate.of(2013, 5, 11)},
//{HijrahChronology.INSTANCE.date(1500, 3, 3), LocalDate.of(2079, 1, 5)},
//{HijrahChronology.INSTANCE.date(1500, 10, 28), LocalDate.of(2079, 8, 25)},
//{HijrahChronology.INSTANCE.date(1500, 10, 29), LocalDate.of(2079, 8, 26)},
@@ -142,6 +149,26 @@
assertEquals(hijrahDate.get(DAY_OF_WEEK), iso.get(DAY_OF_WEEK), "Hijrah day of week should be same as ISO day of week");
}
+ @Test
+ public void test_dateNow(){
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahDate.now()) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahDate.now(ZoneId.systemDefault())) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahDate.now(Clock.systemDefaultZone())) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahDate.now(Clock.systemDefaultZone().getZone())) ;
+
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(), HijrahChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ;
+
+ ZoneId zoneId = ZoneId.of("Europe/Paris");
+ assertEquals(HijrahChronology.INSTANCE.dateNow(zoneId), HijrahChronology.INSTANCE.dateNow(Clock.system(zoneId))) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(zoneId), HijrahChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(zoneId), HijrahDate.now(Clock.system(zoneId))) ;
+ assertEquals(HijrahChronology.INSTANCE.dateNow(zoneId), HijrahDate.now(Clock.system(zoneId).getZone())) ;
+
+ assertEquals(HijrahChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), HijrahChronology.INSTANCE.dateNow(Clock.systemUTC())) ;
+ }
+
@DataProvider(name="badDates")
Object[][] data_badDates() {
return new Object[][] {
--- a/jdk/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java Wed May 15 07:48:57 2013 -0700
@@ -66,12 +66,15 @@
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
+import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.Period;
import java.time.Year;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.Chronology;
import java.time.chrono.Era;
@@ -182,6 +185,16 @@
{JapaneseChronology.INSTANCE.dateYearDay(1868, 60), LocalDate.of(1868, 2, 29)},
{JapaneseChronology.INSTANCE.dateYearDay(1928, 60), LocalDate.of(1928, 2, 29)},
{JapaneseChronology.INSTANCE.dateYearDay(1912, 60), LocalDate.of(1912, 2, 29)},
+
+ {JapaneseDate.ofYearDay(1996, 60), LocalDate.of(1996, 2, 29)},
+ {JapaneseDate.ofYearDay(1868, 60), LocalDate.of(1868, 2, 29)},
+ {JapaneseDate.ofYearDay(1928, 60), LocalDate.of(1928, 2, 29)},
+ {JapaneseDate.ofYearDay(1912, 60), LocalDate.of(1912, 2, 29)},
+
+ {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.HEISEI, 1996 - YDIFF_HEISEI, 60), LocalDate.of(1996, 2, 29)},
+ {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.MEIJI, 1868 - YDIFF_MEIJI, 60), LocalDate.of(1868, 2, 29)},
+ {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.SHOWA, 1928 - YDIFF_SHOWA, 60), LocalDate.of(1928, 2, 29)},
+// {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.TAISHO, 1916 - YDIFF_TAISHO, 60), LocalDate.of(1912, 2, 29)},
};
}
@@ -195,6 +208,26 @@
assertEquals(JapaneseChronology.INSTANCE.date(iso), jdate);
}
+ @Test
+ public void test_dateNow(){
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now()) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(ZoneId.systemDefault())) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone())) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone().getZone())) ;
+
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ;
+
+ ZoneId zoneId = ZoneId.of("Europe/Paris");
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId))) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId))) ;
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId).getZone())) ;
+
+ assertEquals(JapaneseChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), JapaneseChronology.INSTANCE.dateNow(Clock.systemUTC())) ;
+ }
+
@DataProvider(name="badDates")
Object[][] data_badDates() {
return new Object[][] {
@@ -232,8 +265,6 @@
return new Object[][] {
{2, JapaneseEra.HEISEI, 1, 1 + YDIFF_HEISEI, false},
{2, JapaneseEra.HEISEI, 100, 100 + YDIFF_HEISEI, true},
- {2, JapaneseEra.HEISEI, 0, YDIFF_HEISEI, true},
- {2, JapaneseEra.HEISEI, -10, -10 + YDIFF_HEISEI, false},
{-1, JapaneseEra.MEIJI, 1, 1 + YDIFF_MEIJI, true},
{-1, JapaneseEra.MEIJI, 4, 4 + YDIFF_MEIJI, false},
--- a/jdk/test/java/time/tck/java/time/chrono/TCKThaiBuddhistChronology.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/chrono/TCKThaiBuddhistChronology.java Wed May 15 07:48:57 2013 -0700
@@ -66,12 +66,15 @@
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
+import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.Period;
import java.time.Year;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.Chronology;
import java.time.chrono.Era;
@@ -177,6 +180,15 @@
{ThaiBuddhistChronology.INSTANCE.dateYearDay(400 + YDIFF, 60), LocalDate.of(400, 2, 29)},
{ThaiBuddhistChronology.INSTANCE.dateYearDay(2000 + YDIFF, 60), LocalDate.of(2000, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BE, 1916 + YDIFF, 60), LocalDate.of(1916, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BEFORE_BE, -1907 - YDIFF, 60), LocalDate.of(1908, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BE, 2000 + YDIFF, 60), LocalDate.of(2000, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BE, 2400 + YDIFF, 60), LocalDate.of(2400, 2, 29)},
+
+ {ThaiBuddhistChronology.INSTANCE.date(ThaiBuddhistEra.BE, 1916 + YDIFF, 2, 29 ), LocalDate.of(1916, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.date(ThaiBuddhistEra.BEFORE_BE, -1907 - YDIFF, 2, 29), LocalDate.of(1908, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.date(ThaiBuddhistEra.BE, 2000 + YDIFF, 2, 29), LocalDate.of(2000, 2, 29)},
+ {ThaiBuddhistChronology.INSTANCE.date(ThaiBuddhistEra.BE, 2400 + YDIFF, 2, 29), LocalDate.of(2400, 2, 29)},
};
}
@@ -190,6 +202,26 @@
assertEquals(ThaiBuddhistChronology.INSTANCE.date(iso), jdate);
}
+ @Test
+ public void test_dateNow(){
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistDate.now()) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistDate.now(ZoneId.systemDefault())) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistDate.now(Clock.systemDefaultZone())) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistDate.now(Clock.systemDefaultZone().getZone())) ;
+
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(), ThaiBuddhistChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ;
+
+ ZoneId zoneId = ZoneId.of("Europe/Paris");
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(zoneId), ThaiBuddhistChronology.INSTANCE.dateNow(Clock.system(zoneId))) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(zoneId), ThaiBuddhistChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(zoneId), ThaiBuddhistDate.now(Clock.system(zoneId))) ;
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(zoneId), ThaiBuddhistDate.now(Clock.system(zoneId).getZone())) ;
+
+ assertEquals(ThaiBuddhistChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), ThaiBuddhistChronology.INSTANCE.dateNow(Clock.systemUTC())) ;
+ }
+
@DataProvider(name="badDates")
Object[][] data_badDates() {
return new Object[][] {
--- a/jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatSymbols.java Wed May 15 15:01:59 2013 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,210 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
- * This file is available under and governed by the GNU General Public
- * License version 2 only, as published by the Free Software Foundation.
- * However, the following notice accompanied the original version of this
- * file:
- *
- * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * * Neither the name of JSR-310 nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package tck.java.time.format;
-
-import static org.testng.Assert.assertEquals;
-
-import java.time.format.DateTimeFormatSymbols;
-import java.util.Arrays;
-import java.util.Locale;
-
-import org.testng.annotations.Test;
-
-/**
- * Test DateTimeFormatSymbols.
- */
-@Test
-public class TCKDateTimeFormatSymbols {
-
- @Test
- public void test_getAvailableLocales() {
- Locale[] locales = DateTimeFormatSymbols.getAvailableLocales();
- assertEquals(locales.length > 0, true);
- assertEquals(Arrays.asList(locales).contains(Locale.US), true);
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_of_Locale() {
- DateTimeFormatSymbols loc1 = DateTimeFormatSymbols.of(Locale.CANADA);
- assertEquals(loc1.getZeroDigit(), '0');
- assertEquals(loc1.getPositiveSign(), '+');
- assertEquals(loc1.getNegativeSign(), '-');
- assertEquals(loc1.getDecimalSeparator(), '.');
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_STANDARD() {
- DateTimeFormatSymbols loc1 = DateTimeFormatSymbols.STANDARD;
- assertEquals(loc1.getZeroDigit(), '0');
- assertEquals(loc1.getPositiveSign(), '+');
- assertEquals(loc1.getNegativeSign(), '-');
- assertEquals(loc1.getDecimalSeparator(), '.');
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_zeroDigit() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.withZeroDigit('A').getZeroDigit(), 'A');
- }
-
- @Test
- public void test_positiveSign() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.withPositiveSign('A').getPositiveSign(), 'A');
- }
-
- @Test
- public void test_negativeSign() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.withNegativeSign('A').getNegativeSign(), 'A');
- }
-
- @Test
- public void test_decimalSeparator() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.withDecimalSeparator('A').getDecimalSeparator(), 'A');
- }
-
- //-----------------------------------------------------------------------
- /* TBD: convertToDigit and convertNumberToI18N are package-private methods
- @Test
- public void test_convertToDigit_base() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.convertToDigit('0'), 0);
- assertEquals(base.convertToDigit('1'), 1);
- assertEquals(base.convertToDigit('9'), 9);
- assertEquals(base.convertToDigit(' '), -1);
- assertEquals(base.convertToDigit('A'), -1);
- }
-
- @Test
- public void test_convertToDigit_altered() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD.withZeroDigit('A');
- assertEquals(base.convertToDigit('A'), 0);
- assertEquals(base.convertToDigit('B'), 1);
- assertEquals(base.convertToDigit('J'), 9);
- assertEquals(base.convertToDigit(' '), -1);
- assertEquals(base.convertToDigit('0'), -1);
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_convertNumberToI18N_base() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.convertNumberToI18N("134"), "134");
- }
-
- @Test
- public void test_convertNumberToI18N_altered() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD.withZeroDigit('A');
- assertEquals(base.convertNumberToI18N("134"), "BDE");
- }
- */
- //-----------------------------------------------------------------------
- @Test
- public void test_equalsHashCode1() {
- DateTimeFormatSymbols a = DateTimeFormatSymbols.STANDARD;
- DateTimeFormatSymbols b = DateTimeFormatSymbols.STANDARD;
- assertEquals(a.equals(b), true);
- assertEquals(b.equals(a), true);
- assertEquals(a.hashCode(), b.hashCode());
- }
-
- @Test
- public void test_equalsHashCode2() {
- DateTimeFormatSymbols a = DateTimeFormatSymbols.STANDARD.withZeroDigit('A');
- DateTimeFormatSymbols b = DateTimeFormatSymbols.STANDARD.withZeroDigit('A');
- assertEquals(a.equals(b), true);
- assertEquals(b.equals(a), true);
- assertEquals(a.hashCode(), b.hashCode());
- }
-
- @Test
- public void test_equalsHashCode3() {
- DateTimeFormatSymbols a = DateTimeFormatSymbols.STANDARD.withZeroDigit('A');
- DateTimeFormatSymbols b = DateTimeFormatSymbols.STANDARD.withDecimalSeparator('A');
- assertEquals(a.equals(b), false);
- assertEquals(b.equals(a), false);
- }
-
- @Test
- public void test_equalsHashCode_bad() {
- DateTimeFormatSymbols a = DateTimeFormatSymbols.STANDARD;
- assertEquals(a.equals(""), false);
- assertEquals(a.equals(null), false);
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_toString_base() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.STANDARD;
- assertEquals(base.toString(), "Symbols[0+-.]");
- }
-
- @Test
- public void test_toString_altered() {
- DateTimeFormatSymbols base = DateTimeFormatSymbols.of(Locale.US).withZeroDigit('A').withDecimalSeparator('@');
- assertEquals(base.toString(), "Symbols[A+-@]");
- }
-
-}
--- a/jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatter.java Wed May 15 07:48:57 2013 -0700
@@ -90,7 +90,7 @@
import java.time.chrono.IsoChronology;
import java.time.chrono.ThaiBuddhistChronology;
import java.time.chrono.ThaiBuddhistDate;
-import java.time.format.DateTimeFormatSymbols;
+import java.time.format.DecimalStyle;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.DateTimeParseException;
@@ -134,14 +134,14 @@
//-----------------------------------------------------------------------
@Test
public void test_withLocale() {
- DateTimeFormatter base = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter base = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
DateTimeFormatter test = base.withLocale(Locale.GERMAN);
assertEquals(test.getLocale(), Locale.GERMAN);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_withLocale_null() {
- DateTimeFormatter base = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter base = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
base.withLocale((Locale) null);
}
@@ -192,7 +192,9 @@
.appendValue(YEAR).appendLiteral('-').appendValue(MONTH_OF_YEAR).appendLiteral('-')
.appendValue(DAY_OF_MONTH).appendLiteral('-').appendValue(DAY_OF_YEAR).toFormatter();
DateTimeFormatter f = base.withResolverFields(YEAR, DAY_OF_YEAR);
- assertEquals(f.getResolverFields(), new HashSet<>(Arrays.asList(YEAR, DAY_OF_YEAR)));
+ Set<TemporalField> expected = new HashSet<>(Arrays.asList(YEAR, DAY_OF_YEAR));
+ // Use set.equals(); testNG comparison of Collections is ordered
+ assertTrue(f.getResolverFields().equals(expected), "ResolveFields: " + f.getResolverFields());
try {
base.parse("2012-6-30-321", LocalDate::from); // wrong month/day-of-month
fail();
@@ -392,27 +394,27 @@
//-----------------------------------------------------------------------
@Test
public void test_format_TemporalAccessor_simple() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
String result = test.format(LocalDate.of(2008, 6, 30));
assertEquals(result, "ONE30");
}
@Test(expectedExceptions = DateTimeException.class)
public void test_format_TemporalAccessor_noSuchField() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.format(LocalTime.of(11, 30));
}
@Test(expectedExceptions = NullPointerException.class)
public void test_format_TemporalAccessor_null() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.format((TemporalAccessor) null);
}
//-----------------------------------------------------------------------
@Test
public void test_print_TemporalAppendable() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
StringBuilder buf = new StringBuilder();
test.formatTo(LocalDate.of(2008, 6, 30), buf);
assertEquals(buf.toString(), "ONE30");
@@ -420,21 +422,21 @@
@Test(expectedExceptions=DateTimeException.class)
public void test_print_TemporalAppendable_noSuchField() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
StringBuilder buf = new StringBuilder();
test.formatTo(LocalTime.of(11, 30), buf);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_print_TemporalAppendable_nullTemporal() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
StringBuilder buf = new StringBuilder();
test.formatTo((TemporalAccessor) null, buf);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_print_TemporalAppendable_nullAppendable() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.formatTo(LocalDate.of(2008, 6, 30), (Appendable) null);
}
@@ -443,7 +445,7 @@
//-----------------------------------------------------------------------
@Test
public void test_parse_CharSequence() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
TemporalAccessor result = test.parse("ONE30");
assertEquals(result.isSupported(DAY_OF_MONTH), true);
assertEquals(result.getLong(DAY_OF_MONTH), 30L);
@@ -466,7 +468,7 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_parse_CharSequence_null() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parse((String) null);
}
@@ -475,7 +477,7 @@
//-----------------------------------------------------------------------
@Test
public void test_parse_CharSequence_ParsePosition() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(3);
TemporalAccessor result = test.parse("XXXONE30XXX", pos);
assertEquals(pos.getIndex(), 8);
@@ -523,13 +525,13 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_parse_CharSequence_ParsePosition_nullText() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parse((CharSequence) null, new ParsePosition(0));
}
@Test(expectedExceptions=NullPointerException.class)
public void test_parse_CharSequence_ParsePosition_nullParsePosition() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parse("Text", (ParsePosition) null);
}
@@ -594,7 +596,7 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_parse_Query_String_nullRule() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parse("30", (TemporalQuery<?>) null);
}
@@ -630,7 +632,7 @@
@Test(expectedExceptions=DateTimeParseException.class)
public void test_parseBest_String_parseErrorLongText() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
try {
test.parseBest("ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789", ZonedDateTime::from, LocalDate::from);
} catch (DateTimeParseException ex) {
@@ -644,7 +646,7 @@
@Test(expectedExceptions=DateTimeParseException.class)
public void test_parseBest_String_parseIncomplete() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
try {
test.parseBest("ONE30SomethingElse", ZonedDateTime::from, LocalDate::from);
} catch (DateTimeParseException ex) {
@@ -658,32 +660,32 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_parseBest_String_nullText() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parseBest((String) null, ZonedDateTime::from, LocalDate::from);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_parseBest_String_nullRules() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parseBest("30", (TemporalQuery<?>[]) null);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_parseBest_String_zeroRules() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parseBest("30", new TemporalQuery<?>[0]);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_parseBest_String_oneRule() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parseBest("30", LocalDate::from);
}
//-----------------------------------------------------------------------
@Test
public void test_parseUnresolved_StringParsePosition() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(0);
TemporalAccessor result = test.parseUnresolved("ONE30XXX", pos);
assertEquals(pos.getIndex(), 5);
@@ -693,7 +695,7 @@
@Test
public void test_parseUnresolved_StringParsePosition_parseError() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(0);
TemporalAccessor result = test.parseUnresolved("ONEXXX", pos);
assertEquals(pos.getIndex(), 0);
@@ -725,20 +727,20 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_parseUnresolved_StringParsePosition_nullString() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(0);
test.parseUnresolved((String) null, pos);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_parseUnresolved_StringParsePosition_nullParsePosition() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
test.parseUnresolved("ONE30", (ParsePosition) null);
}
@Test(expectedExceptions=IndexOutOfBoundsException.class)
public void test_parseUnresolved_StringParsePosition_invalidPosition() {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(6);
test.parseUnresolved("ONE30", pos);
}
@@ -747,7 +749,7 @@
//-----------------------------------------------------------------------
@Test
public void test_toFormat_format() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
String result = format.format(LocalDate.of(2008, 6, 30));
assertEquals(result, "ONE30");
@@ -755,14 +757,14 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_toFormat_format_null() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
format.format(null);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_toFormat_format_notTemporal() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
format.format("Not a Temporal");
}
@@ -770,7 +772,7 @@
//-----------------------------------------------------------------------
@Test
public void test_toFormat_parseObject_String() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
TemporalAccessor result = (TemporalAccessor) format.parseObject("ONE30");
assertEquals(result.isSupported(DAY_OF_MONTH), true);
@@ -779,7 +781,7 @@
@Test(expectedExceptions=ParseException.class)
public void test_toFormat_parseObject_String_parseError() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
try {
format.parseObject("ONEXXX");
@@ -792,7 +794,7 @@
@Test(expectedExceptions=ParseException.class)
public void test_toFormat_parseObject_String_parseErrorLongText() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
try {
format.parseObject("ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789");
@@ -806,7 +808,7 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_toFormat_parseObject_String_null() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
format.parseObject((String) null);
}
@@ -814,7 +816,7 @@
//-----------------------------------------------------------------------
@Test
public void test_toFormat_parseObject_StringParsePosition() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
ParsePosition pos = new ParsePosition(0);
TemporalAccessor result = (TemporalAccessor) format.parseObject("ONE30XXX", pos);
@@ -826,7 +828,7 @@
@Test
public void test_toFormat_parseObject_StringParsePosition_parseError() throws Exception {
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
ParsePosition pos = new ParsePosition(0);
TemporalAccessor result = (TemporalAccessor) format.parseObject("ONEXXX", pos);
@@ -838,7 +840,7 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_toFormat_parseObject_StringParsePosition_nullString() throws Exception {
// SimpleDateFormat has this behavior
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
ParsePosition pos = new ParsePosition(0);
format.parseObject((String) null, pos);
@@ -847,7 +849,7 @@
@Test(expectedExceptions=NullPointerException.class)
public void test_toFormat_parseObject_StringParsePosition_nullParsePosition() throws Exception {
// SimpleDateFormat has this behavior
- DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
Format format = test.toFormat();
format.parseObject("ONE30", (ParsePosition) null);
}
@@ -855,7 +857,7 @@
@Test
public void test_toFormat_parseObject_StringParsePosition_invalidPosition_tooBig() throws Exception {
// SimpleDateFormat has this behavior
- DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(6);
Format test = dtf.toFormat();
assertNull(test.parseObject("ONE30", pos));
@@ -865,7 +867,7 @@
@Test
public void test_toFormat_parseObject_StringParsePosition_invalidPosition_tooSmall() throws Exception {
// SimpleDateFormat throws StringIndexOutOfBoundException
- DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withSymbols(DateTimeFormatSymbols.STANDARD);
+ DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
ParsePosition pos = new ParsePosition(-1);
Format test = dtf.toFormat();
assertNull(test.parseObject("ONE30", pos));
--- a/jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatters.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatters.java Wed May 15 07:48:57 2013 -0700
@@ -63,6 +63,7 @@
import static java.time.temporal.ChronoField.DAY_OF_WEEK;
import static java.time.temporal.ChronoField.DAY_OF_YEAR;
import static java.time.temporal.ChronoField.HOUR_OF_DAY;
+import static java.time.temporal.ChronoField.INSTANT_SECONDS;
import static java.time.temporal.ChronoField.MINUTE_OF_HOUR;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.NANO_OF_SECOND;
@@ -1180,6 +1181,52 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
+ @DataProvider(name="sample_isoInstant")
+ Object[][] provider_sample_isoInstant() {
+ return new Object[][]{
+ {0, 0, "1970-01-01T00:00:00Z", null},
+ {0, null, "1970-01-01T00:00:00Z", null},
+ {0, -1, null, DateTimeException.class},
+
+ {-1, 0, "1969-12-31T23:59:59Z", null},
+ {1, 0, "1970-01-01T00:00:01Z", null},
+ {60, 0, "1970-01-01T00:01:00Z", null},
+ {3600, 0, "1970-01-01T01:00:00Z", null},
+ {86400, 0, "1970-01-02T00:00:00Z", null},
+
+ {0, 1, "1970-01-01T00:00:00.000000001Z", null},
+ {0, 2, "1970-01-01T00:00:00.000000002Z", null},
+ {0, 10, "1970-01-01T00:00:00.000000010Z", null},
+ {0, 100, "1970-01-01T00:00:00.000000100Z", null},
+ };
+ }
+
+ @Test(dataProvider="sample_isoInstant")
+ public void test_print_isoInstant(
+ long instantSecs, Integer nano, String expected, Class<?> expectedEx) {
+ TemporalAccessor test = buildAccessorInstant(instantSecs, nano);
+ if (expectedEx == null) {
+ assertEquals(DateTimeFormatter.ISO_INSTANT.format(test), expected);
+ } else {
+ try {
+ DateTimeFormatter.ISO_INSTANT.format(test);
+ fail();
+ } catch (Exception ex) {
+ assertTrue(expectedEx.isInstance(ex));
+ }
+ }
+ }
+
+ @Test(dataProvider="sample_isoInstant")
+ public void test_parse_isoInstant(
+ long instantSecs, Integer nano, String input, Class<?> invalid) {
+ if (input != null) {
+ TemporalAccessor parsed = DateTimeFormatter.ISO_INSTANT.parseUnresolved(input, new ParsePosition(0));
+ assertEquals(parsed.getLong(INSTANT_SECONDS), instantSecs);
+ assertEquals(parsed.getLong(NANO_OF_SECOND), (nano == null ? 0 : nano));
+ }
+ }
+
@Test
public void test_isoInstant_basics() {
assertEquals(DateTimeFormatter.ISO_INSTANT.getChronology(), null);
@@ -1334,6 +1381,15 @@
return mock;
}
+ private TemporalAccessor buildAccessorInstant(long instantSecs, Integer nano) {
+ MockAccessor mock = new MockAccessor();
+ mock.fields.put(INSTANT_SECONDS, instantSecs);
+ if (nano != null) {
+ mock.fields.put(NANO_OF_SECOND, (long) nano);
+ }
+ return mock;
+ }
+
private void buildCalendrical(Expected expected, String offsetId, String zoneId) {
if (offsetId != null) {
expected.add(ZoneOffset.of(offsetId));
--- a/jdk/test/java/time/tck/java/time/format/TCKDateTimeParseResolver.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/format/TCKDateTimeParseResolver.java Wed May 15 07:48:57 2013 -0700
@@ -59,6 +59,9 @@
*/
package tck.java.time.format;
+import static java.time.format.ResolverStyle.LENIENT;
+import static java.time.format.ResolverStyle.SMART;
+import static java.time.format.ResolverStyle.STRICT;
import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH;
import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR;
import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_MONTH;
@@ -88,11 +91,15 @@
import static java.time.temporal.ChronoField.YEAR;
import static java.time.temporal.ChronoField.YEAR_OF_ERA;
import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
import java.time.LocalDate;
import java.time.LocalTime;
+import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.format.ResolverStyle;
import java.time.temporal.IsoFields;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
@@ -519,4 +526,350 @@
assertEquals(accessor.query(TemporalQuery.localTime()), null);
}
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveFourToTime")
+ Object[][] data_resolveFourToTime() {
+ return new Object[][]{
+ // merge
+ {null, 0, 0, 0, 0, LocalTime.of(0, 0, 0, 0), Period.ZERO},
+ {null, 1, 0, 0, 0, LocalTime.of(1, 0, 0, 0), Period.ZERO},
+ {null, 0, 2, 0, 0, LocalTime.of(0, 2, 0, 0), Period.ZERO},
+ {null, 0, 0, 3, 0, LocalTime.of(0, 0, 3, 0), Period.ZERO},
+ {null, 0, 0, 0, 4, LocalTime.of(0, 0, 0, 4), Period.ZERO},
+ {null, 1, 2, 3, 4, LocalTime.of(1, 2, 3, 4), Period.ZERO},
+ {null, 23, 59, 59, 123456789, LocalTime.of(23, 59, 59, 123456789), Period.ZERO},
+
+ {ResolverStyle.STRICT, 14, 59, 60, 123456789, null, null},
+ {ResolverStyle.SMART, 14, 59, 60, 123456789, null, null},
+ {ResolverStyle.LENIENT, 14, 59, 60, 123456789, LocalTime.of(15, 0, 0, 123456789), Period.ZERO},
+
+ {ResolverStyle.STRICT, 23, 59, 60, 123456789, null, null},
+ {ResolverStyle.SMART, 23, 59, 60, 123456789, null, null},
+ {ResolverStyle.LENIENT, 23, 59, 60, 123456789, LocalTime.of(0, 0, 0, 123456789), Period.ofDays(1)},
+
+ {ResolverStyle.STRICT, 24, 0, 0, 0, null, null},
+ {ResolverStyle.SMART, 24, 0, 0, 0, LocalTime.of(0, 0, 0, 0), Period.ofDays(1)},
+ {ResolverStyle.LENIENT, 24, 0, 0, 0, LocalTime.of(0, 0, 0, 0), Period.ofDays(1)},
+
+ {ResolverStyle.STRICT, 24, 1, 0, 0, null, null},
+ {ResolverStyle.SMART, 24, 1, 0, 0, null, null},
+ {ResolverStyle.LENIENT, 24, 1, 0, 0, LocalTime.of(0, 1, 0, 0), Period.ofDays(1)},
+
+ {ResolverStyle.STRICT, 25, 0, 0, 0, null, null},
+ {ResolverStyle.SMART, 25, 0, 0, 0, null, null},
+ {ResolverStyle.LENIENT, 25, 0, 0, 0, LocalTime.of(1, 0, 0, 0), Period.ofDays(1)},
+
+ {ResolverStyle.STRICT, 49, 2, 3, 4, null, null},
+ {ResolverStyle.SMART, 49, 2, 3, 4, null, null},
+ {ResolverStyle.LENIENT, 49, 2, 3, 4, LocalTime.of(1, 2, 3, 4), Period.ofDays(2)},
+
+ {ResolverStyle.STRICT, -1, 2, 3, 4, null, null},
+ {ResolverStyle.SMART, -1, 2, 3, 4, null, null},
+ {ResolverStyle.LENIENT, -1, 2, 3, 4, LocalTime.of(23, 2, 3, 4), Period.ofDays(-1)},
+
+ {ResolverStyle.STRICT, -6, 2, 3, 4, null, null},
+ {ResolverStyle.SMART, -6, 2, 3, 4, null, null},
+ {ResolverStyle.LENIENT, -6, 2, 3, 4, LocalTime.of(18, 2, 3, 4), Period.ofDays(-1)},
+
+ {ResolverStyle.STRICT, 25, 61, 61, 1_123456789, null, null},
+ {ResolverStyle.SMART, 25, 61, 61, 1_123456789, null, null},
+ {ResolverStyle.LENIENT, 25, 61, 61, 1_123456789, LocalTime.of(2, 2, 2, 123456789), Period.ofDays(1)},
+ };
+ }
+
+ @Test(dataProvider="resolveFourToTime")
+ public void test_resolveFourToTime(ResolverStyle style,
+ long hour, long min, long sec, long nano, LocalTime expectedTime, Period excessPeriod) {
+ DateTimeFormatter f = new DateTimeFormatterBuilder()
+ .parseDefaulting(HOUR_OF_DAY, hour)
+ .parseDefaulting(MINUTE_OF_HOUR, min)
+ .parseDefaulting(SECOND_OF_MINUTE, sec)
+ .parseDefaulting(NANO_OF_SECOND, nano).toFormatter();
+
+ ResolverStyle[] styles = (style != null ? new ResolverStyle[] {style} : ResolverStyle.values());
+ for (ResolverStyle s : styles) {
+ if (expectedTime != null) {
+ TemporalAccessor accessor = f.withResolverStyle(s).parse("");
+ assertEquals(accessor.query(TemporalQuery.localDate()), null, "ResolverStyle: " + s);
+ assertEquals(accessor.query(TemporalQuery.localTime()), expectedTime, "ResolverStyle: " + s);
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), excessPeriod, "ResolverStyle: " + s);
+ } else {
+ try {
+ f.withResolverStyle(style).parse("");
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider="resolveFourToTime")
+ public void test_resolveThreeToTime(ResolverStyle style,
+ long hour, long min, long sec, long nano, LocalTime expectedTime, Period excessPeriod) {
+ DateTimeFormatter f = new DateTimeFormatterBuilder()
+ .parseDefaulting(HOUR_OF_DAY, hour)
+ .parseDefaulting(MINUTE_OF_HOUR, min)
+ .parseDefaulting(SECOND_OF_MINUTE, sec).toFormatter();
+
+ ResolverStyle[] styles = (style != null ? new ResolverStyle[] {style} : ResolverStyle.values());
+ for (ResolverStyle s : styles) {
+ if (expectedTime != null) {
+ TemporalAccessor accessor = f.withResolverStyle(s).parse("");
+ assertEquals(accessor.query(TemporalQuery.localDate()), null, "ResolverStyle: " + s);
+ assertEquals(accessor.query(TemporalQuery.localTime()), expectedTime.minusNanos(nano), "ResolverStyle: " + s);
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), excessPeriod, "ResolverStyle: " + s);
+ } else {
+ try {
+ f.withResolverStyle(style).parse("");
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider="resolveFourToTime")
+ public void test_resolveFourToDateTime(ResolverStyle style,
+ long hour, long min, long sec, long nano, LocalTime expectedTime, Period excessPeriod) {
+ DateTimeFormatter f = new DateTimeFormatterBuilder()
+ .parseDefaulting(YEAR, 2012).parseDefaulting(MONTH_OF_YEAR, 6).parseDefaulting(DAY_OF_MONTH, 30)
+ .parseDefaulting(HOUR_OF_DAY, hour)
+ .parseDefaulting(MINUTE_OF_HOUR, min)
+ .parseDefaulting(SECOND_OF_MINUTE, sec)
+ .parseDefaulting(NANO_OF_SECOND, nano).toFormatter();
+
+ ResolverStyle[] styles = (style != null ? new ResolverStyle[] {style} : ResolverStyle.values());
+ if (expectedTime != null && excessPeriod != null) {
+ LocalDate expectedDate = LocalDate.of(2012, 6, 30).plus(excessPeriod);
+ for (ResolverStyle s : styles) {
+ TemporalAccessor accessor = f.withResolverStyle(s).parse("");
+ assertEquals(accessor.query(TemporalQuery.localDate()), expectedDate, "ResolverStyle: " + s);
+ assertEquals(accessor.query(TemporalQuery.localTime()), expectedTime, "ResolverStyle: " + s);
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO, "ResolverStyle: " + s);
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveSecondOfDay")
+ Object[][] data_resolveSecondOfDay() {
+ return new Object[][]{
+ {STRICT, 0, 0, 0},
+ {STRICT, 1, 1, 0},
+ {STRICT, 86399, 86399, 0},
+ {STRICT, -1, null, 0},
+ {STRICT, 86400, null, 0},
+
+ {SMART, 0, 0, 0},
+ {SMART, 1, 1, 0},
+ {SMART, 86399, 86399, 0},
+ {SMART, -1, null, 0},
+ {SMART, 86400, null, 0},
+
+ {LENIENT, 0, 0, 0},
+ {LENIENT, 1, 1, 0},
+ {LENIENT, 86399, 86399, 0},
+ {LENIENT, -1, 86399, -1},
+ {LENIENT, 86400, 0, 1},
+ };
+ }
+
+ @Test(dataProvider="resolveSecondOfDay")
+ public void test_resolveSecondOfDay(ResolverStyle style, long value, Integer expectedSecond, int expectedDays) {
+ String str = Long.toString(value);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(SECOND_OF_DAY).toFormatter();
+
+ if (expectedSecond != null) {
+ TemporalAccessor accessor = f.withResolverStyle(style).parse(str);
+ assertEquals(accessor.query(TemporalQuery.localDate()), null);
+ assertEquals(accessor.query(TemporalQuery.localTime()), LocalTime.ofSecondOfDay(expectedSecond));
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), Period.ofDays(expectedDays));
+ } else {
+ try {
+ f.withResolverStyle(style).parse(str);
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveMinuteOfDay")
+ Object[][] data_resolveMinuteOfDay() {
+ return new Object[][]{
+ {STRICT, 0, 0, 0},
+ {STRICT, 1, 1, 0},
+ {STRICT, 1439, 1439, 0},
+ {STRICT, -1, null, 0},
+ {STRICT, 1440, null, 0},
+
+ {SMART, 0, 0, 0},
+ {SMART, 1, 1, 0},
+ {SMART, 1439, 1439, 0},
+ {SMART, -1, null, 0},
+ {SMART, 1440, null, 0},
+
+ {LENIENT, 0, 0, 0},
+ {LENIENT, 1, 1, 0},
+ {LENIENT, 1439, 1439, 0},
+ {LENIENT, -1, 1439, -1},
+ {LENIENT, 1440, 0, 1},
+ };
+ }
+
+ @Test(dataProvider="resolveMinuteOfDay")
+ public void test_resolveMinuteOfDay(ResolverStyle style, long value, Integer expectedMinute, int expectedDays) {
+ String str = Long.toString(value);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(MINUTE_OF_DAY).toFormatter();
+
+ if (expectedMinute != null) {
+ TemporalAccessor accessor = f.withResolverStyle(style).parse(str);
+ assertEquals(accessor.query(TemporalQuery.localDate()), null);
+ assertEquals(accessor.query(TemporalQuery.localTime()), LocalTime.ofSecondOfDay(expectedMinute * 60));
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), Period.ofDays(expectedDays));
+ } else {
+ try {
+ f.withResolverStyle(style).parse(str);
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveClockHourOfDay")
+ Object[][] data_resolveClockHourOfDay() {
+ return new Object[][]{
+ {STRICT, 1, 1, 0},
+ {STRICT, 24, 0, 0},
+ {STRICT, 0, null, 0},
+ {STRICT, -1, null, 0},
+ {STRICT, 25, null, 0},
+
+ {SMART, 1, 1, 0},
+ {SMART, 24, 0, 0},
+ {SMART, 0, 0, 0},
+ {SMART, -1, null, 0},
+ {SMART, 25, null, 0},
+
+ {LENIENT, 1, 1, 0},
+ {LENIENT, 24, 0, 0},
+ {LENIENT, 0, 0, 0},
+ {LENIENT, -1, 23, -1},
+ {LENIENT, 25, 1, 1},
+ };
+ }
+
+ @Test(dataProvider="resolveClockHourOfDay")
+ public void test_resolveClockHourOfDay(ResolverStyle style, long value, Integer expectedHour, int expectedDays) {
+ String str = Long.toString(value);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(CLOCK_HOUR_OF_DAY).toFormatter();
+
+ if (expectedHour != null) {
+ TemporalAccessor accessor = f.withResolverStyle(style).parse(str);
+ assertEquals(accessor.query(TemporalQuery.localDate()), null);
+ assertEquals(accessor.query(TemporalQuery.localTime()), LocalTime.of(expectedHour, 0));
+ assertEquals(accessor.query(DateTimeFormatter.parsedExcessDays()), Period.ofDays(expectedDays));
+ } else {
+ try {
+ f.withResolverStyle(style).parse(str);
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveClockHourOfAmPm")
+ Object[][] data_resolveClockHourOfAmPm() {
+ return new Object[][]{
+ {STRICT, 1, 1},
+ {STRICT, 12, 0},
+ {STRICT, 0, null},
+ {STRICT, -1, null},
+ {STRICT, 13, null},
+
+ {SMART, 1, 1},
+ {SMART, 12, 0},
+ {SMART, 0, 0},
+ {SMART, -1, null},
+ {SMART, 13, null},
+
+ {LENIENT, 1, 1},
+ {LENIENT, 12, 0},
+ {LENIENT, 0, 0},
+ {LENIENT, -1, -1},
+ {LENIENT, 13, 13},
+ };
+ }
+
+ @Test(dataProvider="resolveClockHourOfAmPm")
+ public void test_resolveClockHourOfAmPm(ResolverStyle style, long value, Integer expectedValue) {
+ String str = Long.toString(value);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(CLOCK_HOUR_OF_AMPM).toFormatter();
+
+ if (expectedValue != null) {
+ TemporalAccessor accessor = f.withResolverStyle(style).parse(str);
+ assertEquals(accessor.query(TemporalQuery.localDate()), null);
+ assertEquals(accessor.query(TemporalQuery.localTime()), null);
+ assertEquals(accessor.isSupported(CLOCK_HOUR_OF_AMPM), false);
+ assertEquals(accessor.isSupported(HOUR_OF_AMPM), true);
+ assertEquals(accessor.getLong(HOUR_OF_AMPM), expectedValue.longValue());
+ } else {
+ try {
+ f.withResolverStyle(style).parse(str);
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="resolveAmPm")
+ Object[][] data_resolveAmPm() {
+ return new Object[][]{
+ {STRICT, 0, 0},
+ {STRICT, 1, 1},
+ {STRICT, -1, null},
+ {STRICT, 2, null},
+
+ {SMART, 0, 0},
+ {SMART, 1, 1},
+ {SMART, -1, null},
+ {SMART, 2, null},
+
+ {LENIENT, 0, 0},
+ {LENIENT, 1, 1},
+ {LENIENT, -1, -1},
+ {LENIENT, 2, 2},
+ };
+ }
+
+ @Test(dataProvider="resolveAmPm")
+ public void test_resolveAmPm(ResolverStyle style, long value, Integer expectedValue) {
+ String str = Long.toString(value);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(AMPM_OF_DAY).toFormatter();
+
+ if (expectedValue != null) {
+ TemporalAccessor accessor = f.withResolverStyle(style).parse(str);
+ assertEquals(accessor.query(TemporalQuery.localDate()), null);
+ assertEquals(accessor.query(TemporalQuery.localTime()), null);
+ assertEquals(accessor.isSupported(AMPM_OF_DAY), true);
+ assertEquals(accessor.getLong(AMPM_OF_DAY), expectedValue.longValue());
+ } else {
+ try {
+ f.withResolverStyle(style).parse(str);
+ fail();
+ } catch (DateTimeParseException ex) {
+ // expected
+ }
+ }
+ }
+
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/tck/java/time/format/TCKDecimalStyle.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package tck.java.time.format;
+
+import static org.testng.Assert.assertEquals;
+
+import java.time.format.DecimalStyle;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Set;
+
+import org.testng.annotations.Test;
+
+/**
+ * Test DecimalStyle.
+ */
+@Test
+public class TCKDecimalStyle {
+
+ @Test
+ public void test_getAvailableLocales() {
+ Set<Locale> locales = DecimalStyle.getAvailableLocales();
+ assertEquals(locales.size() > 0, true, "locales: " + locales);
+ assertEquals(locales.contains(Locale.US), true, "Locale.US not found in available Locales");
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_of_Locale() {
+ DecimalStyle loc1 = DecimalStyle.of(Locale.CANADA);
+ assertEquals(loc1.getZeroDigit(), '0');
+ assertEquals(loc1.getPositiveSign(), '+');
+ assertEquals(loc1.getNegativeSign(), '-');
+ assertEquals(loc1.getDecimalSeparator(), '.');
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_STANDARD() {
+ DecimalStyle loc1 = DecimalStyle.STANDARD;
+ assertEquals(loc1.getZeroDigit(), '0');
+ assertEquals(loc1.getPositiveSign(), '+');
+ assertEquals(loc1.getNegativeSign(), '-');
+ assertEquals(loc1.getDecimalSeparator(), '.');
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_zeroDigit() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.withZeroDigit('A').getZeroDigit(), 'A');
+ }
+
+ @Test
+ public void test_positiveSign() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.withPositiveSign('A').getPositiveSign(), 'A');
+ }
+
+ @Test
+ public void test_negativeSign() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.withNegativeSign('A').getNegativeSign(), 'A');
+ }
+
+ @Test
+ public void test_decimalSeparator() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.withDecimalSeparator('A').getDecimalSeparator(), 'A');
+ }
+
+ //-----------------------------------------------------------------------
+ /* TBD: convertToDigit and convertNumberToI18N are package-private methods
+ @Test
+ public void test_convertToDigit_base() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.convertToDigit('0'), 0);
+ assertEquals(base.convertToDigit('1'), 1);
+ assertEquals(base.convertToDigit('9'), 9);
+ assertEquals(base.convertToDigit(' '), -1);
+ assertEquals(base.convertToDigit('A'), -1);
+ }
+
+ @Test
+ public void test_convertToDigit_altered() {
+ DecimalStyle base = DecimalStyle.STANDARD.withZeroDigit('A');
+ assertEquals(base.convertToDigit('A'), 0);
+ assertEquals(base.convertToDigit('B'), 1);
+ assertEquals(base.convertToDigit('J'), 9);
+ assertEquals(base.convertToDigit(' '), -1);
+ assertEquals(base.convertToDigit('0'), -1);
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_convertNumberToI18N_base() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.convertNumberToI18N("134"), "134");
+ }
+
+ @Test
+ public void test_convertNumberToI18N_altered() {
+ DecimalStyle base = DecimalStyle.STANDARD.withZeroDigit('A');
+ assertEquals(base.convertNumberToI18N("134"), "BDE");
+ }
+ */
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_equalsHashCode1() {
+ DecimalStyle a = DecimalStyle.STANDARD;
+ DecimalStyle b = DecimalStyle.STANDARD;
+ assertEquals(a.equals(b), true);
+ assertEquals(b.equals(a), true);
+ assertEquals(a.hashCode(), b.hashCode());
+ }
+
+ @Test
+ public void test_equalsHashCode2() {
+ DecimalStyle a = DecimalStyle.STANDARD.withZeroDigit('A');
+ DecimalStyle b = DecimalStyle.STANDARD.withZeroDigit('A');
+ assertEquals(a.equals(b), true);
+ assertEquals(b.equals(a), true);
+ assertEquals(a.hashCode(), b.hashCode());
+ }
+
+ @Test
+ public void test_equalsHashCode3() {
+ DecimalStyle a = DecimalStyle.STANDARD.withZeroDigit('A');
+ DecimalStyle b = DecimalStyle.STANDARD.withDecimalSeparator('A');
+ assertEquals(a.equals(b), false);
+ assertEquals(b.equals(a), false);
+ }
+
+ @Test
+ public void test_equalsHashCode_bad() {
+ DecimalStyle a = DecimalStyle.STANDARD;
+ assertEquals(a.equals(""), false);
+ assertEquals(a.equals(null), false);
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_toString_base() {
+ DecimalStyle base = DecimalStyle.STANDARD;
+ assertEquals(base.toString(), "DecimalStyle[0+-.]");
+ }
+
+ @Test
+ public void test_toString_altered() {
+ DecimalStyle base = DecimalStyle.of(Locale.US).withZeroDigit('A').withDecimalSeparator('@');
+ assertEquals(base.toString(), "DecimalStyle[A+-@]");
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/tck/java/time/format/TCKInstantPrinterParser.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2010-2013, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package tck.java.time.format;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
+
+import java.time.DateTimeException;
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.Period;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.ResolverStyle;
+import java.time.temporal.TemporalAccessor;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/**
+ * Test DateTimeFormatterBuilder.appendInstant().
+ */
+@Test
+public class TCKInstantPrinterParser {
+
+ @DataProvider(name="printGrouped")
+ Object[][] data_printGrouped() {
+ return new Object[][] {
+ {0, 0, "1970-01-01T00:00:00Z"},
+
+ {-1, 0, "1969-12-31T23:59:59Z"},
+ {1, 0, "1970-01-01T00:00:01Z"},
+ {60, 0, "1970-01-01T00:01:00Z"},
+ {3600, 0, "1970-01-01T01:00:00Z"},
+ {86400, 0, "1970-01-02T00:00:00Z"},
+
+ {182, 2, "1970-01-01T00:03:02.000000002Z"},
+ {182, 20, "1970-01-01T00:03:02.000000020Z"},
+ {182, 200, "1970-01-01T00:03:02.000000200Z"},
+ {182, 2000, "1970-01-01T00:03:02.000002Z"},
+ {182, 20000, "1970-01-01T00:03:02.000020Z"},
+ {182, 200000, "1970-01-01T00:03:02.000200Z"},
+ {182, 2000000, "1970-01-01T00:03:02.002Z"},
+ {182, 20000000, "1970-01-01T00:03:02.020Z"},
+ {182, 200000000, "1970-01-01T00:03:02.200Z"},
+
+ {Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
+ {Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00Z"},
+ };
+ }
+
+ @Test(dataProvider="printGrouped")
+ public void test_print_grouped(long instantSecs, int nano, String expected) {
+ Instant instant = Instant.ofEpochSecond(instantSecs, nano);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant().toFormatter();
+ assertEquals(f.format(instant), expected);
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="printDigits")
+ Object[][] data_printDigits() {
+ return new Object[][] {
+ {-1, 0, 0, "1970-01-01T00:00:00Z"},
+ {0, 0, 0, "1970-01-01T00:00:00Z"},
+ {1, 0, 0, "1970-01-01T00:00:00.0Z"},
+ {3, 0, 0, "1970-01-01T00:00:00.000Z"},
+ {9, 0, 0, "1970-01-01T00:00:00.000000000Z"},
+
+ {-1, -1, 0, "1969-12-31T23:59:59Z"},
+ {-1, 1, 0, "1970-01-01T00:00:01Z"},
+ {-1, 60, 0, "1970-01-01T00:01:00Z"},
+ {-1, 3600, 0, "1970-01-01T01:00:00Z"},
+ {-1, 86400, 0, "1970-01-02T00:00:00Z"},
+
+ {-1, 182, 2, "1970-01-01T00:03:02.000000002Z"},
+ {-1, 182, 20, "1970-01-01T00:03:02.00000002Z"},
+ {-1, 182, 200, "1970-01-01T00:03:02.0000002Z"},
+ {-1, 182, 2000, "1970-01-01T00:03:02.000002Z"},
+ {-1, 182, 20000, "1970-01-01T00:03:02.00002Z"},
+ {-1, 182, 200000, "1970-01-01T00:03:02.0002Z"},
+ {-1, 182, 2000000, "1970-01-01T00:03:02.002Z"},
+ {-1, 182, 20000000, "1970-01-01T00:03:02.02Z"},
+ {-1, 182, 200000000, "1970-01-01T00:03:02.2Z"},
+
+ {0, 182, 2, "1970-01-01T00:03:02Z"},
+ {0, 182, 20, "1970-01-01T00:03:02Z"},
+ {0, 182, 200, "1970-01-01T00:03:02Z"},
+ {0, 182, 2000, "1970-01-01T00:03:02Z"},
+ {0, 182, 20000, "1970-01-01T00:03:02Z"},
+ {0, 182, 200000, "1970-01-01T00:03:02Z"},
+ {0, 182, 2000000, "1970-01-01T00:03:02Z"},
+ {0, 182, 20000000, "1970-01-01T00:03:02Z"},
+ {0, 182, 200000000, "1970-01-01T00:03:02Z"},
+
+ {1, 182, 2, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 20, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 200, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 2000, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 20000, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 200000, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 2000000, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 20000000, "1970-01-01T00:03:02.0Z"},
+ {1, 182, 200000000, "1970-01-01T00:03:02.2Z"},
+
+ {3, 182, 2, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 20, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 200, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 2000, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 20000, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 200000, "1970-01-01T00:03:02.000Z"},
+ {3, 182, 2000000, "1970-01-01T00:03:02.002Z"},
+ {3, 182, 20000000, "1970-01-01T00:03:02.020Z"},
+ {3, 182, 200000000, "1970-01-01T00:03:02.200Z"},
+
+ {9, 182, 2, "1970-01-01T00:03:02.000000002Z"},
+ {9, 182, 20, "1970-01-01T00:03:02.000000020Z"},
+ {9, 182, 200, "1970-01-01T00:03:02.000000200Z"},
+ {9, 182, 2000, "1970-01-01T00:03:02.000002000Z"},
+ {9, 182, 20000, "1970-01-01T00:03:02.000020000Z"},
+ {9, 182, 200000, "1970-01-01T00:03:02.000200000Z"},
+ {9, 182, 2000000, "1970-01-01T00:03:02.002000000Z"},
+ {9, 182, 20000000, "1970-01-01T00:03:02.020000000Z"},
+ {9, 182, 200000000, "1970-01-01T00:03:02.200000000Z"},
+
+ {9, Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
+ {9, Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
+ };
+ }
+
+ @Test(dataProvider="printDigits")
+ public void test_print_digits(int fractionalDigits, long instantSecs, int nano, String expected) {
+ Instant instant = Instant.ofEpochSecond(instantSecs, nano);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(fractionalDigits).toFormatter();
+ assertEquals(f.format(instant), expected);
+ }
+
+ //-----------------------------------------------------------------------
+ @DataProvider(name="parseDigits")
+ Object[][] data_parse_digits() {
+ return new Object[][] {
+ {0, 0, "1970-01-01T00:00:00Z"},
+ {0, 0, "1970-01-01T00:00:00Z"},
+ {0, 0, "1970-01-01T00:00:00.0Z"},
+ {0, 0, "1970-01-01T00:00:00.000Z"},
+ {0, 0, "1970-01-01T00:00:00.000000000Z"},
+
+ {-1, 0, "1969-12-31T23:59:59Z"},
+ {1, 0, "1970-01-01T00:00:01Z"},
+ {60, 0, "1970-01-01T00:01:00Z"},
+ {3600, 0, "1970-01-01T01:00:00Z"},
+ {86400, 0, "1970-01-02T00:00:00Z"},
+
+ {182, 234000000, "1970-01-01T00:03:02.234Z"},
+ {182, 234000000, "1970-01-01T00:03:02.2340Z"},
+ {182, 234000000, "1970-01-01T00:03:02.23400Z"},
+ {182, 234000000, "1970-01-01T00:03:02.234000Z"},
+ {182, 234000000, "1970-01-01T00:03:02.234000000Z"},
+
+ {((23 * 60) + 59) * 60 + 59, 123456789, "1970-01-01T23:59:59.123456789Z"},
+
+ {Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
+ {Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
+ };
+ }
+
+ @Test(dataProvider="parseDigits")
+ public void test_parse_digitsMinusOne(long instantSecs, int nano, String input) {
+ Instant expected = Instant.ofEpochSecond(instantSecs, nano);
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
+ assertEquals(f.parse(input, Instant::from), expected);
+ assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
+ assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
+ }
+
+ @Test(dataProvider="parseDigits")
+ public void test_parse_digitsNine(long instantSecs, int nano, String input) {
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(9).toFormatter();
+ if (input.charAt(input.length() - 11) == '.') {
+ Instant expected = Instant.ofEpochSecond(instantSecs, nano);
+ assertEquals(f.parse(input, Instant::from), expected);
+ assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
+ assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
+ } else {
+ try {
+ f.parse(input, Instant::from);
+ fail();
+ } catch (DateTimeException ex) {
+ // expected
+ }
+ }
+ }
+
+ @Test
+ public void test_parse_endOfDay() {
+ Instant expected = OffsetDateTime.of(1970, 2, 4, 0, 0, 0, 0, ZoneOffset.UTC).toInstant();
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
+ for (ResolverStyle style : ResolverStyle.values()) {
+ TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T24:00:00Z");
+ assertEquals(parsed.query(Instant::from), expected);
+ assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
+ assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
+ }
+ }
+
+ @Test
+ public void test_parse_leapSecond() {
+ Instant expected = OffsetDateTime.of(1970, 2, 3, 23, 59, 59, 123456789, ZoneOffset.UTC).toInstant();
+ DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
+ for (ResolverStyle style : ResolverStyle.values()) {
+ TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T23:59:60.123456789Z");
+ assertEquals(parsed.query(Instant::from), expected);
+ assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
+ assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.TRUE);
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ @Test(expectedExceptions=IllegalArgumentException.class)
+ public void test_appendInstant_tooSmall() {
+ new DateTimeFormatterBuilder().appendInstant(-2);
+ }
+
+ @Test(expectedExceptions=IllegalArgumentException.class)
+ public void test_appendInstant_tooBig() {
+ new DateTimeFormatterBuilder().appendInstant(10);
+ }
+
+}
--- a/jdk/test/java/time/tck/java/time/format/TCKTextStyle.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/format/TCKTextStyle.java Wed May 15 07:48:57 2013 -0700
@@ -67,7 +67,7 @@
import org.testng.annotations.Test;
/**
- * Test DateTimeFormatSymbols.
+ * Test DecimalStyle.
*/
@Test
public class TCKTextStyle {
--- a/jdk/test/java/time/tck/java/time/temporal/TCKWeekFields.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/tck/java/time/temporal/TCKWeekFields.java Wed May 15 07:48:57 2013 -0700
@@ -71,7 +71,6 @@
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoUnit;
-import java.time.temporal.JulianFields;
import java.time.temporal.TemporalField;
import java.time.temporal.ValueRange;
import java.time.temporal.WeekFields;
@@ -161,9 +160,6 @@
TemporalField dowField = week.dayOfWeek();
TemporalField womField = week.weekOfMonth();
- DayOfWeek isoDOW = day.getDayOfWeek();
- int dow = (7 + isoDOW.getValue() - firstDayOfWeek.getValue()) % 7 + 1;
-
for (int i = 1; i <= 15; i++) {
int actualDOW = day.get(dowField);
int actualWOM = day.get(womField);
@@ -197,9 +193,6 @@
TemporalField dowField = week.dayOfWeek();
TemporalField woyField = week.weekOfYear();
- DayOfWeek isoDOW = day.getDayOfWeek();
- int dow = (7 + isoDOW.getValue() - firstDayOfWeek.getValue()) % 7 + 1;
-
for (int i = 1; i <= 15; i++) {
int actualDOW = day.get(dowField);
int actualWOY = day.get(woyField);
@@ -470,6 +463,28 @@
public void test_parse_resolve_localizedWoWBY(DayOfWeek firstDayOfWeek, int minDays) {
LocalDate date = LocalDate.of(2012, 12, 31);
WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
+ TemporalField wowbyField = week.weekOfWeekBasedYear();
+ TemporalField yowbyField = week.weekBasedYear();
+
+ for (int i = 1; i <= 60; i++) {
+ // Test that with dayOfWeek, week of year and year of week-based-year it computes the date
+ DateTimeFormatter f = new DateTimeFormatterBuilder()
+ .appendValue(yowbyField).appendLiteral('-')
+ .appendValue(wowbyField).appendLiteral('-')
+ .appendValue(DAY_OF_WEEK).toFormatter();
+ String str = date.get(yowbyField) + "-" + date.get(wowbyField) + "-" +
+ date.get(DAY_OF_WEEK);
+ LocalDate parsed = LocalDate.parse(str, f);
+ assertEquals(parsed, date, " :: " + str + " " + i);
+
+ date = date.plusDays(1);
+ }
+ }
+
+ @Test(dataProvider="weekFields")
+ public void test_parse_resolve_localizedWoWBYDow(DayOfWeek firstDayOfWeek, int minDays) {
+ LocalDate date = LocalDate.of(2012, 12, 31);
+ WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
TemporalField dowField = week.dayOfWeek();
TemporalField wowbyField = week.weekOfWeekBasedYear();
TemporalField yowbyField = week.weekBasedYear();
--- a/jdk/test/java/time/test/java/time/chrono/TestChronologyPerf.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/chrono/TestChronologyPerf.java Wed May 15 07:48:57 2013 -0700
@@ -26,6 +26,8 @@
import java.time.Duration;
import java.time.chrono.Chronology;
+import java.time.chrono.HijrahChronology;
+import java.time.chrono.HijrahDate;
import java.time.temporal.ChronoUnit;
import java.util.Set;
@@ -42,7 +44,19 @@
Set<Chronology> chronos = Chronology.getAvailableChronologies();
long end = System.nanoTime();
Duration d = Duration.of(end - start, ChronoUnit.NANOS);
- System.out.printf(" Duration of Chronology.getAvailableChronologies(): %s%n", d);
+ System.out.printf(" Cold Duration of Chronology.getAvailableChronologies(): %s%n", d);
+
+ start = System.nanoTime();
+ chronos = Chronology.getAvailableChronologies();
+ end = System.nanoTime();
+ d = Duration.of(end - start, ChronoUnit.NANOS);
+ System.out.printf(" Warm Duration of Chronology.getAvailableChronologies(): %s%n", d);
+
+ start = System.nanoTime();
+ HijrahChronology.INSTANCE.date(1434, 1, 1);
+ end = System.nanoTime();
+ d = Duration.of(end - start, ChronoUnit.NANOS);
+ System.out.printf(" Warm Duration of HijrahDate.date(1434, 1, 1): %s%n", d);
}
}
--- a/jdk/test/java/time/test/java/time/chrono/TestExampleCode.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/chrono/TestExampleCode.java Wed May 15 07:48:57 2013 -0700
@@ -109,21 +109,20 @@
}
//-----------------------------------------------------------------------
- // Data provider for Hijrah Variant names
+ // Data provider for Hijrah Type names
//-----------------------------------------------------------------------
- @DataProvider(name = "HijrahVariantNames")
+ @DataProvider(name = "HijrahTypeNames")
Object[][] data_of_ummalqura() {
return new Object[][]{
- { "Hijrah-umalqura", "islamic", "umalqura"},
+ { "Hijrah-umalqura", "islamic-umalqura"},
};
}
- @Test(dataProvider= "HijrahVariantNames")
- public void test_HijrahVariantViaLocale(String calendarId, String calendarType, String variant) {
+ @Test(dataProvider= "HijrahTypeNames")
+ public void test_HijrahTypeViaLocale(String calendarId, String calendarType) {
Locale.Builder builder = new Locale.Builder();
builder.setLanguage("en").setRegion("US");
builder.setUnicodeLocaleKeyword("ca", calendarType);
- builder.setUnicodeLocaleKeyword("cv", variant);
Locale locale = builder.build();
Chronology chrono = Chronology.ofLocale(locale);
System.out.printf(" Locale language tag: %s, Chronology ID: %s, type: %s%n",
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/test/java/time/chrono/TestJapaneseChronology.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package test.java.time.chrono;
+
+import java.time.*;
+import java.time.chrono.*;
+import java.time.temporal.*;
+import java.util.List;
+import java.util.Locale;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import static org.testng.Assert.assertEquals;
+
+/**
+ * Tests for the Japanese chronology
+ */
+@Test
+public class TestJapaneseChronology {
+ private static final JapaneseChronology JAPANESE = JapaneseChronology.INSTANCE;
+ private static final Locale jaJPJP = Locale.forLanguageTag("ja-JP-u-ca-japanese");
+
+ @DataProvider(name="transitions")
+ Object[][] transitionData() {
+ return new Object[][] {
+ // Japanese era, yearOfEra, month, dayOfMonth, gregorianYear
+ { JapaneseEra.SEIREKI, Year.MIN_VALUE, 1, 1, Year.MIN_VALUE },
+ { JapaneseEra.SEIREKI, 1867, 12, 31, 1867 },
+ { JapaneseEra.MEIJI, 1, 1, 25, 1868 }, // Note: the dates of Meiji 1 to 5 are incorrect
+ { JapaneseEra.MEIJI, 6, 1, 1, 1873 },
+ // Meiji-Taisho transition isn't accurate. 1912-07-30 is the last day of Meiji
+ // and the first day of Taisho.
+ { JapaneseEra.MEIJI, 45, 7, 29, 1912 },
+ { JapaneseEra.TAISHO, 1, 7, 30, 1912 },
+ // Same for Taisho-Showa transition. 1926-12-25 is the last day of Taisho
+ // and the first day of Showa.
+ { JapaneseEra.TAISHO, 15, 12, 24, 1926 },
+ { JapaneseEra.SHOWA, 1, 12, 25, 1926 },
+ { JapaneseEra.SHOWA, 64, 1, 7, 1989 },
+ { JapaneseEra.HEISEI, 1, 1, 8, 1989 },
+ };
+ }
+
+ @DataProvider(name="day_year_data")
+ Object[][] dayYearData() {
+ return new Object[][] {
+ // Japanese era, yearOfEra, dayOfYear, month, dayOfMonth
+ { JapaneseEra.MEIJI, 45, 211, 7, 29 },
+ { JapaneseEra.TAISHO, 1, 1, 7, 30 },
+ { JapaneseEra.TAISHO, 2, 60, 3, 1 },
+ { JapaneseEra.TAISHO, 15, 358, 12, 24 },
+ { JapaneseEra.SHOWA, 1, 1, 12, 25 },
+ { JapaneseEra.SHOWA, 2, 8, 1, 8 },
+ { JapaneseEra.SHOWA, 64, 7, 1, 7 },
+ { JapaneseEra.HEISEI, 1, 1, 1, 8 },
+ { JapaneseEra.HEISEI, 2, 8, 1, 8 },
+ };
+ }
+
+ @DataProvider(name="range_data")
+ Object[][] rangeData() {
+ return new Object[][] {
+ // field, minSmallest, minLargest, maxSmallest, maxLargest
+ { ChronoField.ERA, -999, -999, 2, 2},
+ { ChronoField.YEAR_OF_ERA, -999999999, 1, 15, 999999999-1989 }, // depends on the current era
+ { ChronoField.DAY_OF_YEAR, 1, 1, 7, 366},
+ };
+ }
+
+ @DataProvider(name="invalid_dates")
+ Object[][] invalidDatesData() {
+ return new Object[][] {
+ // Japanese era, yearOfEra, month, dayOfMonth
+ { JapaneseEra.SEIREKI, Year.MIN_VALUE - 1, 1, 1 },
+ { JapaneseEra.SEIREKI, 1855, 2, 29 },
+ { JapaneseEra.SEIREKI, 1868, 1, 25 },
+ { JapaneseEra.MEIJI, 6, 2, 29 },
+ { JapaneseEra.MEIJI, 45, 7, 30 },
+ { JapaneseEra.MEIJI, 46, 1, 1 },
+ { JapaneseEra.TAISHO, 1, 7, 29 },
+ { JapaneseEra.TAISHO, 2, 2, 29 },
+ { JapaneseEra.TAISHO, 15, 12, 25 },
+ { JapaneseEra.TAISHO, 16, 1, 1 },
+ { JapaneseEra.SHOWA, 1, 12, 24 },
+ { JapaneseEra.SHOWA, 2, 2, 29 },
+ { JapaneseEra.SHOWA, 64, 1, 8 },
+ { JapaneseEra.SHOWA, 65, 1, 1 },
+ { JapaneseEra.HEISEI, 1, 1, 7 },
+ { JapaneseEra.HEISEI, 1, 2, 29 },
+ { JapaneseEra.HEISEI, Year.MAX_VALUE, 12, 31 },
+ };
+ }
+
+ @DataProvider(name="invalid_eraYear")
+ Object[][] invalidEraYearData() {
+ return new Object[][] {
+ // Japanese era, yearOfEra
+ { JapaneseEra.SEIREKI, Year.MIN_VALUE - 1 },
+ { JapaneseEra.SEIREKI, 2012 },
+ { JapaneseEra.MEIJI, -1 },
+ { JapaneseEra.MEIJI, 0 },
+ { JapaneseEra.MEIJI, 46 },
+ { JapaneseEra.TAISHO, -1 },
+ { JapaneseEra.TAISHO, 0 },
+ { JapaneseEra.TAISHO, 16 },
+ { JapaneseEra.SHOWA, -1 },
+ { JapaneseEra.SHOWA, 0 },
+ { JapaneseEra.SHOWA, 65 },
+ { JapaneseEra.HEISEI, -1 },
+ { JapaneseEra.HEISEI, 0 },
+ { JapaneseEra.HEISEI, Year.MAX_VALUE },
+ };
+ }
+
+ @DataProvider(name="invalid_day_year_data")
+ Object[][] invalidDayYearData() {
+ return new Object[][] {
+ // Japanese era, yearOfEra, dayOfYear
+ { JapaneseEra.MEIJI, 45, 240 },
+ { JapaneseEra.TAISHO, 1, 365 },
+ { JapaneseEra.TAISHO, 2, 366 },
+ { JapaneseEra.TAISHO, 15, 359 },
+ { JapaneseEra.SHOWA, 1, 8 },
+ { JapaneseEra.SHOWA, 2, 366 },
+ { JapaneseEra.SHOWA, 64, 8 },
+ { JapaneseEra.HEISEI, 1, 360 },
+ { JapaneseEra.HEISEI, 2, 366 },
+ };
+ }
+
+ @Test
+ public void test_ofLocale() {
+ // must be a singleton
+ assertEquals(Chronology.ofLocale(jaJPJP) == JAPANESE, true);
+ }
+
+ @Test(dataProvider="transitions")
+ public void test_transitions(JapaneseEra era, int yearOfEra, int month, int dayOfMonth, int gregorianYear) {
+ assertEquals(JAPANESE.prolepticYear(era, yearOfEra), gregorianYear);
+
+ JapaneseDate jdate1 = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
+ JapaneseDate jdate2 = JapaneseDate.of(gregorianYear, month, dayOfMonth);
+ assertEquals(jdate1, jdate2);
+ }
+
+ @Test(dataProvider="range_data")
+ public void test_range(ChronoField field, int minSmallest, int minLargest, int maxSmallest, int maxLargest) {
+ ValueRange range = JAPANESE.range(field);
+ assertEquals(range.getMinimum(), minSmallest);
+ assertEquals(range.getLargestMinimum(), minLargest);
+ assertEquals(range.getSmallestMaximum(), maxSmallest);
+ assertEquals(range.getMaximum(), maxLargest);
+ }
+
+ @Test(dataProvider="day_year_data")
+ public void test_firstDayOfEra(JapaneseEra era, int yearOfEra, int dayOfYear, int month, int dayOfMonth) {
+ JapaneseDate date1 = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
+ JapaneseDate date2 = JAPANESE.date(era, yearOfEra, month, dayOfMonth);
+ assertEquals(date1, date2);
+ }
+
+ @Test(dataProvider="invalid_dates", expectedExceptions=DateTimeException.class)
+ public void test_invalidDate(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
+ JapaneseDate jdate = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
+ System.out.printf("No DateTimeException with %s %d.%02d.%02d%n", era, yearOfEra, month, dayOfMonth);
+ }
+
+ @Test(dataProvider="invalid_eraYear", expectedExceptions=DateTimeException.class)
+ public void test_invalidEraYear(JapaneseEra era, int yearOfEra) {
+ int year = JAPANESE.prolepticYear(era, yearOfEra);
+ System.out.printf("No DateTimeException with era=%s, year=%d%n", era, yearOfEra);
+ }
+
+ @Test(dataProvider="invalid_day_year_data", expectedExceptions=DateTimeException.class)
+ public void test_invalidDayYear(JapaneseEra era, int yearOfEra, int dayOfYear) {
+ JapaneseDate date = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
+ System.out.printf("No DateTimeException with era=%s, year=%d, dayOfYear=%d%n", era, yearOfEra, dayOfYear);
+ }
+}
--- a/jdk/test/java/time/test/java/time/format/AbstractTestPrinterParser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/AbstractTestPrinterParser.java Wed May 15 07:48:57 2013 -0700
@@ -63,7 +63,7 @@
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
-import java.time.format.DateTimeFormatSymbols;
+import java.time.format.DecimalStyle;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.SignStyle;
@@ -85,7 +85,7 @@
protected DateTimeFormatterBuilder builder;
protected TemporalAccessor dta;
protected Locale locale;
- protected DateTimeFormatSymbols symbols;
+ protected DecimalStyle decimalStyle;
@BeforeMethod
@@ -94,7 +94,7 @@
builder = new DateTimeFormatterBuilder();
dta = ZonedDateTime.of(LocalDateTime.of(2011, 6, 30, 12, 30, 40, 0), ZoneId.of("Europe/Paris"));
locale = Locale.ENGLISH;
- symbols = DateTimeFormatSymbols.STANDARD;
+ decimalStyle = DecimalStyle.STANDARD;
}
protected void setCaseSensitive(boolean caseSensitive) {
@@ -114,35 +114,35 @@
}
protected DateTimeFormatter getFormatter() {
- return builder.toFormatter(locale).withSymbols(symbols);
+ return builder.toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(char c) {
- return builder.appendLiteral(c).toFormatter(locale).withSymbols(symbols);
+ return builder.appendLiteral(c).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(String s) {
- return builder.appendLiteral(s).toFormatter(locale).withSymbols(symbols);
+ return builder.appendLiteral(s).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(TemporalField field) {
- return builder.appendText(field).toFormatter(locale).withSymbols(symbols);
+ return builder.appendText(field).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(TemporalField field, TextStyle style) {
- return builder.appendText(field, style).toFormatter(locale).withSymbols(symbols);
+ return builder.appendText(field, style).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle) {
- return builder.appendValue(field, minWidth, maxWidth, signStyle).toFormatter(locale).withSymbols(symbols);
+ return builder.appendValue(field, minWidth, maxWidth, signStyle).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getFormatter(String pattern, String noOffsetText) {
- return builder.appendOffset(pattern, noOffsetText).toFormatter(locale).withSymbols(symbols);
+ return builder.appendOffset(pattern, noOffsetText).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected DateTimeFormatter getPatternFormatter(String pattern) {
- return builder.appendPattern(pattern).toFormatter(locale).withSymbols(symbols);
+ return builder.appendPattern(pattern).toFormatter(locale).withDecimalStyle(decimalStyle);
}
protected static final TemporalAccessor EMPTY_DTA = new TemporalAccessor() {
--- a/jdk/test/java/time/test/java/time/format/TestDateTimeFormatSymbols.java Wed May 15 15:01:59 2013 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/*
- * This file is available under and governed by the GNU General Public
- * License version 2 only, as published by the Free Software Foundation.
- * However, the following notice accompanied the original version of this
- * file:
- *
- * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * * Neither the name of JSR-310 nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package test.java.time.format;
-
-import static org.testng.Assert.assertSame;
-
-import java.time.format.DateTimeFormatSymbols;
-import java.util.Locale;
-
-import org.testng.annotations.Test;
-
-/**
- * Test DateTimeFormatSymbols.
- */
-@Test
-public class TestDateTimeFormatSymbols {
-
- @Test
- public void test_of_Locale_cached() {
- DateTimeFormatSymbols loc1 = DateTimeFormatSymbols.of(Locale.CANADA);
- DateTimeFormatSymbols loc2 = DateTimeFormatSymbols.of(Locale.CANADA);
- assertSame(loc1, loc2);
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void test_ofDefaultLocale_cached() {
- DateTimeFormatSymbols loc1 = DateTimeFormatSymbols.ofDefaultLocale();
- DateTimeFormatSymbols loc2 = DateTimeFormatSymbols.ofDefaultLocale();
- assertSame(loc1, loc2);
- }
-
-}
--- a/jdk/test/java/time/test/java/time/format/TestDateTimeFormatter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestDateTimeFormatter.java Wed May 15 07:48:57 2013 -0700
@@ -62,7 +62,7 @@
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static org.testng.Assert.assertSame;
-import java.time.format.DateTimeFormatSymbols;
+import java.time.format.DecimalStyle;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.SignStyle;
@@ -82,7 +82,7 @@
new DateTimeFormatterBuilder().appendLiteral("ONE")
.appendValue(DAY_OF_MONTH, 1, 2, SignStyle.NOT_NEGATIVE)
.toFormatter(Locale.ENGLISH)
- .withSymbols(DateTimeFormatSymbols.STANDARD);
+ .withDecimalStyle(DecimalStyle.STANDARD);
DateTimeFormatter test = base.withLocale(Locale.ENGLISH);
assertSame(test, base);
}
--- a/jdk/test/java/time/test/java/time/format/TestDateTimeFormatterBuilder.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestDateTimeFormatterBuilder.java Wed May 15 07:48:57 2013 -0700
@@ -65,13 +65,19 @@
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
import java.text.ParsePosition;
import java.time.LocalDate;
import java.time.YearMonth;
import java.time.ZoneOffset;
+import java.time.chrono.Chronology;
+import java.time.chrono.IsoChronology;
+import java.time.chrono.JapaneseChronology;
+import java.time.chrono.MinguoChronology;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.FormatStyle;
import java.time.format.SignStyle;
import java.time.format.TextStyle;
import java.time.temporal.Temporal;
@@ -268,7 +274,7 @@
public void test_appendValueReduced() throws Exception {
builder.appendValueReduced(YEAR, 2, 2000);
DateTimeFormatter f = builder.toFormatter();
- assertEquals(f.toString(), "ReducedValue(Year,2,2000)");
+ assertEquals(f.toString(), "ReducedValue(Year,2,2,2000)");
TemporalAccessor parsed = f.parseUnresolved("12", new ParsePosition(0));
assertEquals(parsed.getLong(YEAR), 2012L);
}
@@ -277,8 +283,10 @@
public void test_appendValueReduced_subsequent_parse() throws Exception {
builder.appendValue(MONTH_OF_YEAR, 1, 2, SignStyle.NORMAL).appendValueReduced(YEAR, 2, 2000);
DateTimeFormatter f = builder.toFormatter();
- assertEquals(f.toString(), "Value(MonthOfYear,1,2,NORMAL)ReducedValue(Year,2,2000)");
- TemporalAccessor parsed = f.parseUnresolved("123", new ParsePosition(0));
+ assertEquals(f.toString(), "Value(MonthOfYear,1,2,NORMAL)ReducedValue(Year,2,2,2000)");
+ ParsePosition ppos = new ParsePosition(0);
+ TemporalAccessor parsed = f.parseUnresolved("123", ppos);
+ assertNotNull(parsed, "Parse failed: " + ppos.toString());
assertEquals(parsed.getLong(MONTH_OF_YEAR), 1L);
assertEquals(parsed.getLong(YEAR), 2023L);
}
@@ -646,13 +654,13 @@
{"GGGGG", "Text(Era,NARROW)"},
{"u", "Value(Year)"},
- {"uu", "ReducedValue(Year,2,2000)"},
+ {"uu", "ReducedValue(Year,2,2,2000)"},
{"uuu", "Value(Year,3,19,NORMAL)"},
{"uuuu", "Value(Year,4,19,EXCEEDS_PAD)"},
{"uuuuu", "Value(Year,5,19,EXCEEDS_PAD)"},
{"y", "Value(YearOfEra)"},
- {"yy", "ReducedValue(YearOfEra,2,2000)"},
+ {"yy", "ReducedValue(YearOfEra,2,2,2000)"},
{"yyy", "Value(YearOfEra,3,19,NORMAL)"},
{"yyyy", "Value(YearOfEra,4,19,EXCEEDS_PAD)"},
{"yyyyy", "Value(YearOfEra,5,19,EXCEEDS_PAD)"},
@@ -892,6 +900,109 @@
assertEquals(test, expected);
}
+ //-----------------------------------------------------------------------
+ @DataProvider(name="localePatterns")
+ Object[][] localizedDateTimePatterns() {
+ return new Object[][] {
+ {FormatStyle.FULL, FormatStyle.FULL, IsoChronology.INSTANCE, Locale.US, "EEEE, MMMM d, yyyy h:mm:ss a z"},
+ {FormatStyle.LONG, FormatStyle.LONG, IsoChronology.INSTANCE, Locale.US, "MMMM d, yyyy h:mm:ss a z"},
+ {FormatStyle.MEDIUM, FormatStyle.MEDIUM, IsoChronology.INSTANCE, Locale.US, "MMM d, yyyy h:mm:ss a"},
+ {FormatStyle.SHORT, FormatStyle.SHORT, IsoChronology.INSTANCE, Locale.US, "M/d/yy h:mm a"},
+ {FormatStyle.FULL, null, IsoChronology.INSTANCE, Locale.US, "EEEE, MMMM d, yyyy"},
+ {FormatStyle.LONG, null, IsoChronology.INSTANCE, Locale.US, "MMMM d, yyyy"},
+ {FormatStyle.MEDIUM, null, IsoChronology.INSTANCE, Locale.US, "MMM d, yyyy"},
+ {FormatStyle.SHORT, null, IsoChronology.INSTANCE, Locale.US, "M/d/yy"},
+ {null, FormatStyle.FULL, IsoChronology.INSTANCE, Locale.US, "h:mm:ss a z"},
+ {null, FormatStyle.LONG, IsoChronology.INSTANCE, Locale.US, "h:mm:ss a z"},
+ {null, FormatStyle.MEDIUM, IsoChronology.INSTANCE, Locale.US, "h:mm:ss a"},
+ {null, FormatStyle.SHORT, IsoChronology.INSTANCE, Locale.US, "h:mm a"},
+
+ // French Locale and ISO Chronology
+ {FormatStyle.FULL, FormatStyle.FULL, IsoChronology.INSTANCE, Locale.FRENCH, "EEEE d MMMM yyyy HH' h 'mm z"},
+ {FormatStyle.LONG, FormatStyle.LONG, IsoChronology.INSTANCE, Locale.FRENCH, "d MMMM yyyy HH:mm:ss z"},
+ {FormatStyle.MEDIUM, FormatStyle.MEDIUM, IsoChronology.INSTANCE, Locale.FRENCH, "d MMM yyyy HH:mm:ss"},
+ {FormatStyle.SHORT, FormatStyle.SHORT, IsoChronology.INSTANCE, Locale.FRENCH, "dd/MM/yy HH:mm"},
+ {FormatStyle.FULL, null, IsoChronology.INSTANCE, Locale.FRENCH, "EEEE d MMMM yyyy"},
+ {FormatStyle.LONG, null, IsoChronology.INSTANCE, Locale.FRENCH, "d MMMM yyyy"},
+ {FormatStyle.MEDIUM, null, IsoChronology.INSTANCE, Locale.FRENCH, "d MMM yyyy"},
+ {FormatStyle.SHORT, null, IsoChronology.INSTANCE, Locale.FRENCH, "dd/MM/yy"},
+ {null, FormatStyle.FULL, IsoChronology.INSTANCE, Locale.FRENCH, "HH' h 'mm z"},
+ {null, FormatStyle.LONG, IsoChronology.INSTANCE, Locale.FRENCH, "HH:mm:ss z"},
+ {null, FormatStyle.MEDIUM, IsoChronology.INSTANCE, Locale.FRENCH, "HH:mm:ss"},
+ {null, FormatStyle.SHORT, IsoChronology.INSTANCE, Locale.FRENCH, "HH:mm"},
+
+ // Japanese Locale and JapaneseChronology
+ {FormatStyle.FULL, FormatStyle.FULL, JapaneseChronology.INSTANCE, Locale.JAPANESE, "Gy'\u5e74'M'\u6708'd'\u65e5' H'\u6642'mm'\u5206'ss'\u79d2' z"},
+ {FormatStyle.LONG, FormatStyle.LONG, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd H:mm:ss z"},
+ {FormatStyle.MEDIUM, FormatStyle.MEDIUM, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd H:mm:ss"},
+ {FormatStyle.SHORT, FormatStyle.SHORT, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd H:mm"},
+ {FormatStyle.FULL, null, JapaneseChronology.INSTANCE, Locale.JAPANESE, "Gy'\u5e74'M'\u6708'd'\u65e5'"},
+ {FormatStyle.LONG, null, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd"},
+ {FormatStyle.MEDIUM, null, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd"},
+ {FormatStyle.SHORT, null, JapaneseChronology.INSTANCE, Locale.JAPANESE, "GGGGGy.MM.dd"},
+ {null, FormatStyle.FULL, JapaneseChronology.INSTANCE, Locale.JAPANESE, "H'\u6642'mm'\u5206'ss'\u79d2' z"},
+ {null, FormatStyle.LONG, JapaneseChronology.INSTANCE, Locale.JAPANESE, "H:mm:ss z"},
+ {null, FormatStyle.MEDIUM, JapaneseChronology.INSTANCE, Locale.JAPANESE, "H:mm:ss"},
+ {null, FormatStyle.SHORT, JapaneseChronology.INSTANCE, Locale.JAPANESE, "H:mm"},
+
+ // Chinese Local and Chronology
+ {FormatStyle.FULL, FormatStyle.FULL, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy\u5e74M\u6708d\u65e5EEEE ahh'\u65f6'mm'\u5206'ss'\u79d2' z"},
+ {FormatStyle.LONG, FormatStyle.LONG, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy\u5e74M\u6708d\u65e5 ahh'\u65f6'mm'\u5206'ss'\u79d2'"},
+ {FormatStyle.MEDIUM, FormatStyle.MEDIUM, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy-M-d H:mm:ss"},
+ {FormatStyle.SHORT, FormatStyle.SHORT, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy-M-d ah:mm"},
+ {FormatStyle.FULL, null, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy\u5e74M\u6708d\u65e5EEEE"},
+ {FormatStyle.LONG, null, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy\u5e74M\u6708d\u65e5"},
+ {FormatStyle.MEDIUM, null, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy-M-d"},
+ {FormatStyle.SHORT, null, MinguoChronology.INSTANCE, Locale.CHINESE, "Gy-M-d"},
+ {null, FormatStyle.FULL, MinguoChronology.INSTANCE, Locale.CHINESE, "ahh'\u65f6'mm'\u5206'ss'\u79d2' z"},
+ {null, FormatStyle.LONG, MinguoChronology.INSTANCE, Locale.CHINESE, "ahh'\u65f6'mm'\u5206'ss'\u79d2'"},
+ {null, FormatStyle.MEDIUM, MinguoChronology.INSTANCE, Locale.CHINESE, "H:mm:ss"},
+ {null, FormatStyle.SHORT, MinguoChronology.INSTANCE, Locale.CHINESE, "ah:mm"},
+ };
+ }
+
+ @Test(dataProvider="localePatterns")
+ public void test_getLocalizedDateTimePattern(FormatStyle dateStyle, FormatStyle timeStyle,
+ Chronology chrono, Locale locale, String expected) {
+ String actual = DateTimeFormatterBuilder.getLocalizedDateTimePattern(dateStyle, timeStyle, chrono, locale);
+ assertEquals(actual, expected, "Pattern " + convertNonAscii(actual));
+ }
+
+ @Test(expectedExceptions=java.lang.IllegalArgumentException.class)
+ public void test_getLocalizedDateTimePatternIAE() {
+ DateTimeFormatterBuilder.getLocalizedDateTimePattern(null, null, IsoChronology.INSTANCE, Locale.US);
+ }
+
+ @Test(expectedExceptions=java.lang.NullPointerException.class)
+ public void test_getLocalizedChronoNPE() {
+ DateTimeFormatterBuilder.getLocalizedDateTimePattern(FormatStyle.SHORT, FormatStyle.SHORT, null, Locale.US);
+ }
+
+ @Test(expectedExceptions=java.lang.NullPointerException.class)
+ public void test_getLocalizedLocaleNPE() {
+ DateTimeFormatterBuilder.getLocalizedDateTimePattern(FormatStyle.SHORT, FormatStyle.SHORT, IsoChronology.INSTANCE, null);
+ }
+
+ /**
+ * Returns a string that includes non-ascii characters after expanding
+ * the non-ascii characters to their Java language \\uxxxx form.
+ * @param input an input string
+ * @return the encoded string.
+ */
+ private String convertNonAscii(String input) {
+ StringBuilder sb = new StringBuilder(input.length() * 6);
+ for (int i = 0; i < input.length(); i++) {
+ char ch = input.charAt(i);
+ if (ch < 255) {
+ sb.append(ch);
+ } else {
+ sb.append("\\u");
+ sb.append(Integer.toHexString(ch));
+ }
+ }
+ return sb.toString();
+ }
+
private static Temporal date(int y, int m, int d) {
return LocalDate.of(y, m, d);
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/test/java/time/format/TestDecimalStyle.java Wed May 15 07:48:57 2013 -0700
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package test.java.time.format;
+
+import static org.testng.Assert.assertSame;
+
+import java.time.format.DecimalStyle;
+import java.util.Locale;
+
+import org.testng.annotations.Test;
+
+/**
+ * Test DecimalStyle.
+ */
+@Test
+public class TestDecimalStyle {
+
+ @Test
+ public void test_of_Locale_cached() {
+ DecimalStyle loc1 = DecimalStyle.of(Locale.CANADA);
+ DecimalStyle loc2 = DecimalStyle.of(Locale.CANADA);
+ assertSame(loc1, loc2);
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void test_ofDefaultLocale_cached() {
+ DecimalStyle loc1 = DecimalStyle.ofDefaultLocale();
+ DecimalStyle loc2 = DecimalStyle.ofDefaultLocale();
+ assertSame(loc1, loc2);
+ }
+
+}
--- a/jdk/test/java/time/test/java/time/format/TestFractionPrinterParser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestFractionPrinterParser.java Wed May 15 07:48:57 2013 -0700
@@ -82,7 +82,7 @@
public class TestFractionPrinterParser extends AbstractTestPrinterParser {
private DateTimeFormatter getFormatter(TemporalField field, int minWidth, int maxWidth, boolean decimalPoint) {
- return builder.appendFraction(field, minWidth, maxWidth, decimalPoint).toFormatter(locale).withSymbols(symbols);
+ return builder.appendFraction(field, minWidth, maxWidth, decimalPoint).toFormatter(locale).withDecimalStyle(decimalStyle);
}
//-----------------------------------------------------------------------
--- a/jdk/test/java/time/test/java/time/format/TestNonIsoFormatter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestNonIsoFormatter.java Wed May 15 07:48:57 2013 -0700
@@ -32,7 +32,7 @@
import java.time.chrono.JapaneseChronology;
import java.time.chrono.MinguoChronology;
import java.time.chrono.ThaiBuddhistChronology;
-import java.time.format.DateTimeFormatSymbols;
+import java.time.format.DecimalStyle;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.DateTimeParseException;
@@ -129,7 +129,7 @@
ChronoLocalDate<?> date, String expected) {
DateTimeFormatter dtf = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)
.withChronology(chrono).withLocale(formatLocale)
- .withSymbols(DateTimeFormatSymbols.of(numberingLocale));
+ .withDecimalStyle(DecimalStyle.of(numberingLocale));
String text = dtf.format(date);
assertEquals(text, expected);
}
@@ -139,7 +139,7 @@
ChronoLocalDate<?> expected, String text) {
DateTimeFormatter dtf = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)
.withChronology(chrono).withLocale(formatLocale)
- .withSymbols(DateTimeFormatSymbols.of(numberingLocale));
+ .withDecimalStyle(DecimalStyle.of(numberingLocale));
TemporalAccessor temporal = dtf.parse(text);
ChronoLocalDate<?> date = chrono.date(temporal);
assertEquals(date, expected);
--- a/jdk/test/java/time/test/java/time/format/TestNumberParser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestNumberParser.java Wed May 15 07:48:57 2013 -0700
@@ -169,7 +169,7 @@
DateTimeFormatter dtf = getFormatter(DAY_OF_MONTH, minWidth, maxWidth, signStyle);
if (subsequentWidth > 0) {
// hacky, to reserve space
- dtf = builder.appendValue(DAY_OF_YEAR, subsequentWidth).toFormatter(locale).withSymbols(symbols);
+ dtf = builder.appendValue(DAY_OF_YEAR, subsequentWidth).toFormatter(locale).withDecimalStyle(decimalStyle);
}
TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
if (ppos.getErrorIndex() != -1) {
@@ -189,7 +189,7 @@
DateTimeFormatter dtf = getFormatter(DAY_OF_WEEK, minWidth, maxWidth, signStyle);
if (subsequentWidth > 0) {
// hacky, to reserve space
- dtf = builder.appendValue(DAY_OF_YEAR, subsequentWidth).toFormatter(locale).withSymbols(symbols);
+ dtf = builder.appendValue(DAY_OF_YEAR, subsequentWidth).toFormatter(locale).withDecimalStyle(decimalStyle);
}
TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
if (ppos.getErrorIndex() != -1) {
@@ -326,16 +326,16 @@
{"0", 1, 2, SignStyle.NEVER, 1, 0},
{"5", 1, 2, SignStyle.NEVER, 1, 5},
{"50", 1, 2, SignStyle.NEVER, 2, 50},
- {"500", 1, 2, SignStyle.NEVER, 2, 50},
+ {"500", 1, 2, SignStyle.NEVER, 3, 500},
{"-0", 1, 2, SignStyle.NEVER, 2, 0},
{"-5", 1, 2, SignStyle.NEVER, 2, -5},
{"-50", 1, 2, SignStyle.NEVER, 3, -50},
- {"-500", 1, 2, SignStyle.NEVER, 3, -50},
+ {"-500", 1, 2, SignStyle.NEVER, 4, -500},
{"-AAA", 1, 2, SignStyle.NEVER, 1, null},
{"+0", 1, 2, SignStyle.NEVER, 2, 0},
{"+5", 1, 2, SignStyle.NEVER, 2, 5},
{"+50", 1, 2, SignStyle.NEVER, 3, 50},
- {"+500", 1, 2, SignStyle.NEVER, 3, 50},
+ {"+500", 1, 2, SignStyle.NEVER, 4, 500},
{"+AAA", 1, 2, SignStyle.NEVER, 1, null},
{"50", 2, 2, SignStyle.NEVER, 2, 50},
{"-50", 2, 2, SignStyle.NEVER, 0, null},
@@ -345,16 +345,16 @@
{"0", 1, 2, SignStyle.NOT_NEGATIVE, 1, 0},
{"5", 1, 2, SignStyle.NOT_NEGATIVE, 1, 5},
{"50", 1, 2, SignStyle.NOT_NEGATIVE, 2, 50},
- {"500", 1, 2, SignStyle.NOT_NEGATIVE, 2, 50},
+ {"500", 1, 2, SignStyle.NOT_NEGATIVE, 3, 500},
{"-0", 1, 2, SignStyle.NOT_NEGATIVE, 2, 0},
{"-5", 1, 2, SignStyle.NOT_NEGATIVE, 2, -5},
{"-50", 1, 2, SignStyle.NOT_NEGATIVE, 3, -50},
- {"-500", 1, 2, SignStyle.NOT_NEGATIVE, 3, -50},
+ {"-500", 1, 2, SignStyle.NOT_NEGATIVE, 4, -500},
{"-AAA", 1, 2, SignStyle.NOT_NEGATIVE, 1, null},
{"+0", 1, 2, SignStyle.NOT_NEGATIVE, 2, 0},
{"+5", 1, 2, SignStyle.NOT_NEGATIVE, 2, 5},
{"+50", 1, 2, SignStyle.NOT_NEGATIVE, 3, 50},
- {"+500", 1, 2, SignStyle.NOT_NEGATIVE, 3, 50},
+ {"+500", 1, 2, SignStyle.NOT_NEGATIVE, 4, 500},
{"+AAA", 1, 2, SignStyle.NOT_NEGATIVE, 1, null},
{"50", 2, 2, SignStyle.NOT_NEGATIVE, 2, 50},
{"-50", 2, 2, SignStyle.NOT_NEGATIVE, 0, null},
@@ -364,16 +364,16 @@
{"0", 1, 2, SignStyle.NORMAL, 1, 0},
{"5", 1, 2, SignStyle.NORMAL, 1, 5},
{"50", 1, 2, SignStyle.NORMAL, 2, 50},
- {"500", 1, 2, SignStyle.NORMAL, 2, 50},
+ {"500", 1, 2, SignStyle.NORMAL, 3, 500},
{"-0", 1, 2, SignStyle.NORMAL, 2, 0},
{"-5", 1, 2, SignStyle.NORMAL, 2, -5},
{"-50", 1, 2, SignStyle.NORMAL, 3, -50},
- {"-500", 1, 2, SignStyle.NORMAL, 3, -50},
+ {"-500", 1, 2, SignStyle.NORMAL, 4, -500},
{"-AAA", 1, 2, SignStyle.NORMAL, 1, null},
{"+0", 1, 2, SignStyle.NORMAL, 2, 0},
{"+5", 1, 2, SignStyle.NORMAL, 2, 5},
{"+50", 1, 2, SignStyle.NORMAL, 3, 50},
- {"+500", 1, 2, SignStyle.NORMAL, 3, 50},
+ {"+500", 1, 2, SignStyle.NORMAL, 4, 500},
{"+AAA", 1, 2, SignStyle.NORMAL, 1, null},
{"50", 2, 2, SignStyle.NORMAL, 2, 50},
{"-50", 2, 2, SignStyle.NORMAL, 3, -50},
@@ -383,32 +383,32 @@
{"0", 1, 2, SignStyle.ALWAYS, 1, 0},
{"5", 1, 2, SignStyle.ALWAYS, 1, 5},
{"50", 1, 2, SignStyle.ALWAYS, 2, 50},
- {"500", 1, 2, SignStyle.ALWAYS, 2, 50},
+ {"500", 1, 2, SignStyle.ALWAYS, 3, 500},
{"-0", 1, 2, SignStyle.ALWAYS, 2, 0},
{"-5", 1, 2, SignStyle.ALWAYS, 2, -5},
{"-50", 1, 2, SignStyle.ALWAYS, 3, -50},
- {"-500", 1, 2, SignStyle.ALWAYS, 3, -50},
+ {"-500", 1, 2, SignStyle.ALWAYS, 4, -500},
{"-AAA", 1, 2, SignStyle.ALWAYS, 1, null},
{"+0", 1, 2, SignStyle.ALWAYS, 2, 0},
{"+5", 1, 2, SignStyle.ALWAYS, 2, 5},
{"+50", 1, 2, SignStyle.ALWAYS, 3, 50},
- {"+500", 1, 2, SignStyle.ALWAYS, 3, 50},
+ {"+500", 1, 2, SignStyle.ALWAYS, 4, 500},
{"+AAA", 1, 2, SignStyle.ALWAYS, 1, null},
// exceeds pad
{"0", 1, 2, SignStyle.EXCEEDS_PAD, 1, 0},
{"5", 1, 2, SignStyle.EXCEEDS_PAD, 1, 5},
{"50", 1, 2, SignStyle.EXCEEDS_PAD, 2, 50},
- {"500", 1, 2, SignStyle.EXCEEDS_PAD, 2, 50},
+ {"500", 1, 2, SignStyle.EXCEEDS_PAD, 3, 500},
{"-0", 1, 2, SignStyle.EXCEEDS_PAD, 2, 0},
{"-5", 1, 2, SignStyle.EXCEEDS_PAD, 2, -5},
{"-50", 1, 2, SignStyle.EXCEEDS_PAD, 3, -50},
- {"-500", 1, 2, SignStyle.EXCEEDS_PAD, 3, -50},
+ {"-500", 1, 2, SignStyle.EXCEEDS_PAD, 4, -500},
{"-AAA", 1, 2, SignStyle.EXCEEDS_PAD, 1, null},
{"+0", 1, 2, SignStyle.EXCEEDS_PAD, 2, 0},
{"+5", 1, 2, SignStyle.EXCEEDS_PAD, 2, 5},
{"+50", 1, 2, SignStyle.EXCEEDS_PAD, 3, 50},
- {"+500", 1, 2, SignStyle.EXCEEDS_PAD, 3, 50},
+ {"+500", 1, 2, SignStyle.EXCEEDS_PAD, 4, 500},
{"+AAA", 1, 2, SignStyle.EXCEEDS_PAD, 1, null},
};
}
@@ -441,9 +441,9 @@
{"543", 1, 3, SignStyle.NEVER, 3, 543},
{"543", 2, 3, SignStyle.NEVER, 3, 543},
{"543", 3, 3, SignStyle.NEVER, 3, 543},
- {"5432", 1, 3, SignStyle.NEVER, 3, 543},
- {"5432", 2, 3, SignStyle.NEVER, 3, 543},
- {"5432", 3, 3, SignStyle.NEVER, 3, 543},
+ {"5432", 1, 3, SignStyle.NEVER, 4, 5432},
+ {"5432", 2, 3, SignStyle.NEVER, 4, 5432},
+ {"5432", 3, 3, SignStyle.NEVER, 4, 5432},
{"5AAA", 2, 3, SignStyle.NEVER, 1, 5},
// not negative
@@ -455,9 +455,9 @@
{"543", 1, 3, SignStyle.NOT_NEGATIVE, 3, 543},
{"543", 2, 3, SignStyle.NOT_NEGATIVE, 3, 543},
{"543", 3, 3, SignStyle.NOT_NEGATIVE, 3, 543},
- {"5432", 1, 3, SignStyle.NOT_NEGATIVE, 3, 543},
- {"5432", 2, 3, SignStyle.NOT_NEGATIVE, 3, 543},
- {"5432", 3, 3, SignStyle.NOT_NEGATIVE, 3, 543},
+ {"5432", 1, 3, SignStyle.NOT_NEGATIVE, 4, 5432},
+ {"5432", 2, 3, SignStyle.NOT_NEGATIVE, 4, 5432},
+ {"5432", 3, 3, SignStyle.NOT_NEGATIVE, 4, 5432},
{"5AAA", 2, 3, SignStyle.NOT_NEGATIVE, 1, 5},
// normal
@@ -469,9 +469,9 @@
{"543", 1, 3, SignStyle.NORMAL, 3, 543},
{"543", 2, 3, SignStyle.NORMAL, 3, 543},
{"543", 3, 3, SignStyle.NORMAL, 3, 543},
- {"5432", 1, 3, SignStyle.NORMAL, 3, 543},
- {"5432", 2, 3, SignStyle.NORMAL, 3, 543},
- {"5432", 3, 3, SignStyle.NORMAL, 3, 543},
+ {"5432", 1, 3, SignStyle.NORMAL, 4, 5432},
+ {"5432", 2, 3, SignStyle.NORMAL, 4, 5432},
+ {"5432", 3, 3, SignStyle.NORMAL, 4, 5432},
{"5AAA", 2, 3, SignStyle.NORMAL, 1, 5},
// always
@@ -483,9 +483,9 @@
{"543", 1, 3, SignStyle.ALWAYS, 3, 543},
{"543", 2, 3, SignStyle.ALWAYS, 3, 543},
{"543", 3, 3, SignStyle.ALWAYS, 3, 543},
- {"5432", 1, 3, SignStyle.ALWAYS, 3, 543},
- {"5432", 2, 3, SignStyle.ALWAYS, 3, 543},
- {"5432", 3, 3, SignStyle.ALWAYS, 3, 543},
+ {"5432", 1, 3, SignStyle.ALWAYS, 4, 5432},
+ {"5432", 2, 3, SignStyle.ALWAYS, 4, 5432},
+ {"5432", 3, 3, SignStyle.ALWAYS, 4, 5432},
{"5AAA", 2, 3, SignStyle.ALWAYS, 1, 5},
// exceeds pad
@@ -497,9 +497,9 @@
{"543", 1, 3, SignStyle.EXCEEDS_PAD, 3, 543},
{"543", 2, 3, SignStyle.EXCEEDS_PAD, 3, 543},
{"543", 3, 3, SignStyle.EXCEEDS_PAD, 3, 543},
- {"5432", 1, 3, SignStyle.EXCEEDS_PAD, 3, 543},
- {"5432", 2, 3, SignStyle.EXCEEDS_PAD, 3, 543},
- {"5432", 3, 3, SignStyle.EXCEEDS_PAD, 3, 543},
+ {"5432", 1, 3, SignStyle.EXCEEDS_PAD, 4, 5432},
+ {"5432", 2, 3, SignStyle.EXCEEDS_PAD, 4, 5432},
+ {"5432", 3, 3, SignStyle.EXCEEDS_PAD, 4, 5432},
{"5AAA", 2, 3, SignStyle.EXCEEDS_PAD, 1, 5},
};
}
@@ -533,8 +533,8 @@
{"5432", 4, 54, 32},
{"5432A", 4, 54, 32},
- {"54321", 4, 54, 32},
- {"54321A", 4, 54, 32},
+ {"54321", 5, 543, 21},
+ {"54321A", 5, 543, 21},
};
}
@@ -544,7 +544,7 @@
ParsePosition pos = new ParsePosition(0);
DateTimeFormatter f = builder
.appendValue(MONTH_OF_YEAR, 1, 2, SignStyle.NORMAL)
- .appendValue(DAY_OF_MONTH, 2).toFormatter(locale).withSymbols(symbols);
+ .appendValue(DAY_OF_MONTH, 2).toFormatter(locale).withDecimalStyle(decimalStyle);
TemporalAccessor parsed = f.parseUnresolved(input, pos);
if (pos.getErrorIndex() != -1) {
assertEquals(pos.getErrorIndex(), parseLen);
--- a/jdk/test/java/time/test/java/time/format/TestReducedParser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestReducedParser.java Wed May 15 07:48:57 2013 -0700
@@ -59,13 +59,18 @@
*/
package test.java.time.format;
+import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static java.time.temporal.ChronoField.DAY_OF_YEAR;
+import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
+import static java.time.temporal.ChronoField.YEAR_OF_ERA;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.assertNotNull;
import java.text.ParsePosition;
import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
@@ -77,9 +82,15 @@
*/
@Test
public class TestReducedParser extends AbstractTestPrinterParser {
+ private static final boolean STRICT = true;
+ private static final boolean LENIENT = false;
private DateTimeFormatter getFormatter0(TemporalField field, int width, int baseValue) {
- return builder.appendValueReduced(field, width, baseValue).toFormatter(locale).withSymbols(symbols);
+ return builder.appendValueReduced(field, width, baseValue).toFormatter(locale).withDecimalStyle(decimalStyle);
+ }
+
+ private DateTimeFormatter getFormatter0(TemporalField field, int minWidth, int maxWidth, int baseValue) {
+ return builder.appendValueReduced(field, minWidth, maxWidth, baseValue).toFormatter(locale).withDecimalStyle(decimalStyle);
}
//-----------------------------------------------------------------------
@@ -109,89 +120,242 @@
}
//-----------------------------------------------------------------------
- @DataProvider(name="Parse")
- Object[][] provider_parse() {
+ // Parse data and values that are consistent whether strict or lenient
+ // The data is the ChronoField, width, baseValue, text, startPos, endPos, value
+ //-----------------------------------------------------------------------
+ @DataProvider(name="ParseAll")
+ Object[][] provider_parseAll() {
return new Object[][] {
// negative zero
{YEAR, 1, 2010, "-0", 0, 0, null},
// general
{YEAR, 2, 2010, "Xxx12Xxx", 3, 5, 2012},
- {YEAR, 2, 2010, "12345", 0, 2, 2012},
{YEAR, 2, 2010, "12-45", 0, 2, 2012},
- // insufficient digits
- {YEAR, 2, 2010, "0", 0, 0, null},
- {YEAR, 2, 2010, "1", 0, 0, null},
- {YEAR, 2, 2010, "1", 1, 1, null},
- {YEAR, 2, 2010, "1-2", 0, 0, null},
- {YEAR, 2, 2010, "9", 0, 0, null},
-
// other junk
{YEAR, 2, 2010, "A0", 0, 0, null},
- {YEAR, 2, 2010, "0A", 0, 0, null},
{YEAR, 2, 2010, " 1", 0, 0, null},
{YEAR, 2, 2010, "-1", 0, 0, null},
{YEAR, 2, 2010, "-10", 0, 0, null},
+ {YEAR, 2, 2000, " 1", 0, 0, null},
// parse OK 1
- {YEAR, 1, 2010, "0", 0, 1, 2010},
+ {YEAR, 1, 2010, "1", 0, 1, 2011},
+ {YEAR, 1, 2010, "3", 1, 1, null},
{YEAR, 1, 2010, "9", 0, 1, 2019},
- {YEAR, 1, 2010, "10", 0, 1, 2011},
{YEAR, 1, 2005, "0", 0, 1, 2010},
{YEAR, 1, 2005, "4", 0, 1, 2014},
{YEAR, 1, 2005, "5", 0, 1, 2005},
{YEAR, 1, 2005, "9", 0, 1, 2009},
- {YEAR, 1, 2005, "10", 0, 1, 2011},
+ {YEAR, 1, 2010, "1-2", 0, 1, 2011},
// parse OK 2
{YEAR, 2, 2010, "00", 0, 2, 2100},
{YEAR, 2, 2010, "09", 0, 2, 2109},
{YEAR, 2, 2010, "10", 0, 2, 2010},
{YEAR, 2, 2010, "99", 0, 2, 2099},
- {YEAR, 2, 2010, "100", 0, 2, 2010},
// parse OK 2
{YEAR, 2, -2005, "05", 0, 2, -2005},
{YEAR, 2, -2005, "00", 0, 2, -2000},
{YEAR, 2, -2005, "99", 0, 2, -1999},
{YEAR, 2, -2005, "06", 0, 2, -1906},
- {YEAR, 2, -2005, "100", 0, 2, -1910},
- };
+
+ {YEAR, 2, -2005, "43", 0, 2, -1943},
+ };
}
- @Test(dataProvider="Parse")
- public void test_parse(TemporalField field, int width, int baseValue, String input, int pos, int parseLen, Integer parseVal) {
+ @Test(dataProvider="ParseAll")
+ public void test_parseAllStrict(TemporalField field, int width, int baseValue, String input, int pos, int parseLen, Integer parseVal) {
ParsePosition ppos = new ParsePosition(pos);
+ setStrict(true);
TemporalAccessor parsed = getFormatter0(field, width, baseValue).parseUnresolved(input, ppos);
if (ppos.getErrorIndex() != -1) {
- assertEquals(ppos.getErrorIndex(), parseLen);
+ assertEquals(ppos.getErrorIndex(), parseLen, "error case parse position");
+ assertEquals(parsed, parseVal, "unexpected parse result");
} else {
- assertEquals(ppos.getIndex(), parseLen);
+ assertEquals(ppos.getIndex(), parseLen, "parse position");
+ assertParsed(parsed, YEAR, parseVal != null ? (long) parseVal : null);
+ }
+ }
+
+ @Test(dataProvider="ParseAll")
+ public void test_parseAllLenient(TemporalField field, int width, int baseValue, String input, int pos, int parseLen, Integer parseVal) {
+ ParsePosition ppos = new ParsePosition(pos);
+ setStrict(false);
+ TemporalAccessor parsed = getFormatter0(field, width, baseValue).parseUnresolved(input, ppos);
+ if (ppos.getErrorIndex() != -1) {
+ assertEquals(ppos.getErrorIndex(), parseLen, "error case parse position");
+ assertEquals(parsed, parseVal, "unexpected parse result");
+ } else {
+ assertEquals(ppos.getIndex(), parseLen, "parse position");
assertParsed(parsed, YEAR, parseVal != null ? (long) parseVal : null);
}
}
- @Test(dataProvider="Parse")
- public void test_parseLenient(TemporalField field, int width, int baseValue, String input, int pos, int parseLen, Integer parseVal) {
- setStrict(false);
+ //-----------------------------------------------------------------------
+ // Parse data and values in strict and lenient modes.
+ // The data is the ChronoField, minWidth, maxWidth, baseValue, text, startPos,
+ // Strict Pair(endPos, value), Lenient Pair(endPos, value)
+ //-----------------------------------------------------------------------
+ @DataProvider(name="ParseLenientSensitive")
+ Object[][] provider_parseLenientSensitive() {
+ return new Object[][] {
+ // few digits supplied
+ {YEAR, 2, 2, 2010, "3", 0, strict(0, null), lenient(1, 3)},
+ {YEAR, 2, 2, 2010, "4", 0, strict(0, null), lenient(1, 4)},
+ {YEAR, 2, 2, 2010, "5", 1, strict(1, null), lenient(1, null)},
+ {YEAR, 2, 2, 2010, "6-2", 0, strict(0, null), lenient(1, 6)},
+ {YEAR, 2, 2, 2010, "9", 0, strict(0, null), lenient(1, 9)},
+
+ // other junk
+ {YEAR, 1, 4, 2000, "7A", 0, strict(1, 2007), lenient(1, 2007)},
+ {YEAR, 2, 2, 2010, "8A", 0, strict(0, null), lenient(1, 8)},
+
+ // Negative sign cases
+ {YEAR, 2, 4, 2000, "-1", 0, strict(0, null), lenient(2, -1)},
+ {YEAR, 2, 4, 2000, "-10", 0, strict(0, null), lenient(3, -10)},
+
+ // Positive sign cases
+ {YEAR, 2, 4, 2000, "+1", 0, strict(0, null), lenient(2, 1)},
+ {YEAR, 2, 4, 2000, "+10", 0, strict(0, null), lenient(3, 2010)},
+
+ // No sign cases
+ {YEAR, 1, 1, 2005, "21", 0, strict(1, 2012), lenient(2, 21)},
+ {YEAR, 1, 2, 2010, "12", 0, strict(2, 12), lenient(2, 12)},
+ {YEAR, 1, 4, 2000, "87", 0, strict(2, 87), lenient(2, 87)},
+ {YEAR, 1, 4, 2000, "9876", 0, strict(4, 9876), lenient(4, 9876)},
+ {YEAR, 2, 2, 2010, "321", 0, strict(2, 2032), lenient(3, 321)},
+ {YEAR, 2, 4, 2010, "2", 0, strict(0, null), lenient(1, 2)},
+ {YEAR, 2, 4, 2010, "21", 0, strict(2, 2021), lenient(2, 2021)},
+ {YEAR, 2, 4, 2010, "321", 0, strict(3, 321), lenient(3, 321)},
+ {YEAR, 2, 4, 2010, "4321", 0, strict(4, 4321), lenient(4, 4321)},
+ {YEAR, 2, 4, 2010, "54321", 0, strict(4, 5432), lenient(5, 54321)},
+ {YEAR, 2, 8, 2010, "87654321", 3, strict(8, 54321), lenient(8, 54321)},
+ {YEAR, 2, 9, 2010, "987654321", 0, strict(9, 987654321), lenient(9, 987654321)},
+ {YEAR, 3, 3, 2010, "765", 0, strict(3, 2765), lenient(3, 2765)},
+ {YEAR, 3, 4, 2010, "76", 0, strict(0, null), lenient(2, 76)},
+ {YEAR, 3, 4, 2010, "765", 0, strict(3, 2765), lenient(3, 2765)},
+ {YEAR, 3, 4, 2010, "7654", 0, strict(4, 7654), lenient(4, 7654)},
+ {YEAR, 3, 4, 2010, "76543", 0, strict(4, 7654), lenient(5, 76543)},
+
+ // Negative baseValue
+ {YEAR, 2, 4, -2005, "123", 0, strict(3, 123), lenient(3, 123)},
+ };
+ }
+
+ //-----------------------------------------------------------------------
+ // Parsing tests for strict mode
+ //-----------------------------------------------------------------------
+ @Test(dataProvider="ParseLenientSensitive")
+ public void test_parseStrict(TemporalField field, int minWidth, int maxWidth, int baseValue, String input, int pos,
+ Pair strict, Pair lenient) {
ParsePosition ppos = new ParsePosition(pos);
- TemporalAccessor parsed = getFormatter0(field, width, baseValue).parseUnresolved(input, ppos);
+ setStrict(true);
+ TemporalAccessor parsed = getFormatter0(field, minWidth, maxWidth, baseValue).parseUnresolved(input, ppos);
if (ppos.getErrorIndex() != -1) {
- assertEquals(ppos.getErrorIndex(), parseLen);
+ assertEquals(ppos.getErrorIndex(), strict.parseLen, "error case parse position");
+ assertEquals(parsed, strict.parseVal, "unexpected parse result");
} else {
- assertEquals(ppos.getIndex(), parseLen);
- assertParsed(parsed, YEAR, parseVal != null ? (long) parseVal : null);
+ assertEquals(ppos.getIndex(), strict.parseLen, "parse position");
+ assertParsed(parsed, YEAR, strict.parseVal != null ? (long) strict.parseVal : null);
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ // Parsing tests for lenient mode
+ //-----------------------------------------------------------------------
+ @Test(dataProvider="ParseLenientSensitive")
+ public void test_parseLenient(TemporalField field, int minWidth, int maxWidth, int baseValue, String input, int pos,
+ Pair strict, Pair lenient) {
+ ParsePosition ppos = new ParsePosition(pos);
+ setStrict(false);
+ TemporalAccessor parsed = getFormatter0(field, minWidth, maxWidth, baseValue).parseUnresolved(input, ppos);
+ if (ppos.getErrorIndex() != -1) {
+ assertEquals(ppos.getErrorIndex(), lenient.parseLen, "error case parse position");
+ assertEquals(parsed, lenient.parseVal, "unexpected parse result");
+ } else {
+ assertEquals(ppos.getIndex(), lenient.parseLen, "parse position");
+ assertParsed(parsed, YEAR, lenient.parseVal != null ? (long) lenient.parseVal : null);
}
}
private void assertParsed(TemporalAccessor parsed, TemporalField field, Long value) {
if (value == null) {
- assertEquals(parsed, null);
+ assertEquals(parsed, null, "Parsed Value");
} else {
- assertEquals(parsed.isSupported(field), true);
- assertEquals(parsed.getLong(field), (long) value);
+ assertEquals(parsed.isSupported(field), true, "isSupported: " + field);
+ assertEquals(parsed.getLong(field), (long) value, "Temporal.getLong: " + field);
+ }
+ }
+
+
+ //-----------------------------------------------------------------------
+ // Cases and values in adjacent parsing mode
+ //-----------------------------------------------------------------------
+ @DataProvider(name="ParseAdjacent")
+ Object[][] provider_parseAdjacent() {
+ return new Object[][] {
+ // general
+ {"yyMMdd", "19990703", LENIENT, 0, 8, 1999, 7, 3},
+ {"yyMMdd", "19990703", STRICT, 0, 6, 2019, 99, 7},
+ {"yyMMdd", "990703", LENIENT, 0, 6, 2099, 7, 3},
+ {"yyMMdd", "990703", STRICT, 0, 6, 2099, 7, 3},
+ {"yyMMdd", "200703", LENIENT, 0, 6, 2020, 7, 3},
+ {"yyMMdd", "200703", STRICT, 0, 6, 2020, 7, 3},
+ {"ddMMyy", "230714", LENIENT, 0, 6, 2014, 7, 23},
+ {"ddMMyy", "230714", STRICT, 0, 6, 2014, 7, 23},
+ {"ddMMyy", "25062001", LENIENT, 0, 8, 2001, 20, 2506},
+ {"ddMMyy", "25062001", STRICT, 0, 6, 2020, 6, 25},
+ {"ddMMy", "27052002", LENIENT, 0, 8, 2002, 5, 27},
+ {"ddMMy", "27052002", STRICT, 0, 8, 2002, 5, 27},
+ };
+ }
+
+ @Test(dataProvider="ParseAdjacent")
+ public void test_parseAdjacent(String pattern, String input, boolean strict, int pos, int parseLen, int year, int month, int day) {
+ ParsePosition ppos = new ParsePosition(0);
+ builder = new DateTimeFormatterBuilder();
+ setStrict(strict);
+ builder.appendPattern(pattern);
+ DateTimeFormatter dtf = builder.toFormatter();
+
+ TemporalAccessor parsed = dtf.parseUnresolved(input, ppos);
+ assertNotNull(parsed, String.format("parse failed: ppos: %s, formatter: %s%n", ppos.toString(), dtf));
+ if (ppos.getErrorIndex() != -1) {
+ assertEquals(ppos.getErrorIndex(), parseLen, "error case parse position");
+ } else {
+ assertEquals(ppos.getIndex(), parseLen, "parse position");
+ assertParsed(parsed, YEAR_OF_ERA, Long.valueOf(year));
+ assertParsed(parsed, MONTH_OF_YEAR, Long.valueOf(month));
+ assertParsed(parsed, DAY_OF_MONTH, Long.valueOf(day));
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ // Class to structure the test data
+ //-----------------------------------------------------------------------
+
+ private static Pair strict(int parseLen, Integer parseVal) {
+ return new Pair(parseLen, parseVal, STRICT);
+ }
+ private static Pair lenient(int parseLen, Integer parseVal) {
+ return new Pair(parseLen, parseVal, LENIENT);
+ }
+
+ private static class Pair {
+ public final int parseLen;
+ public final Integer parseVal;
+ private final boolean strict;
+ public Pair(int parseLen, Integer parseVal, boolean strict) {
+ this.parseLen = parseLen;
+ this.parseVal = parseVal;
+ this.strict = strict;
+ }
+ public String toString() {
+ return (strict ? "strict" : "lenient") + "(" + parseLen + "," + parseVal + ")";
}
}
--- a/jdk/test/java/time/test/java/time/format/TestReducedPrinter.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestReducedPrinter.java Wed May 15 07:48:57 2013 -0700
@@ -59,6 +59,7 @@
*/
package test.java.time.format;
+import java.text.ParsePosition;
import static java.time.temporal.ChronoField.YEAR;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
@@ -66,6 +67,11 @@
import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import static java.time.temporal.ChronoField.DAY_OF_MONTH;
+import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
+import static java.time.temporal.ChronoField.YEAR_OF_ERA;
+import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
import org.testng.annotations.DataProvider;
@@ -79,7 +85,11 @@
public class TestReducedPrinter extends AbstractTestPrinterParser {
private DateTimeFormatter getFormatter0(TemporalField field, int width, int baseValue) {
- return builder.appendValueReduced(field, width, baseValue).toFormatter(locale).withSymbols(symbols);
+ return builder.appendValueReduced(field, width, baseValue).toFormatter(locale).withDecimalStyle(decimalStyle);
+ }
+
+ private DateTimeFormatter getFormatter0(TemporalField field, int minWidth, int maxWidth, int baseValue) {
+ return builder.appendValueReduced(field, minWidth, maxWidth, baseValue).toFormatter(locale).withDecimalStyle(decimalStyle);
}
//-----------------------------------------------------------------------
@@ -99,66 +109,76 @@
@DataProvider(name="Pivot")
Object[][] provider_pivot() {
return new Object[][] {
- {1, 2010, 2010, "0"},
- {1, 2010, 2011, "1"},
- {1, 2010, 2012, "2"},
- {1, 2010, 2013, "3"},
- {1, 2010, 2014, "4"},
- {1, 2010, 2015, "5"},
- {1, 2010, 2016, "6"},
- {1, 2010, 2017, "7"},
- {1, 2010, 2018, "8"},
- {1, 2010, 2019, "9"},
- {1, 2010, 2009, "9"},
- {1, 2010, 2020, "0"},
+ {1, 1, 2010, 2010, "0"},
+ {1, 1, 2010, 2011, "1"},
+ {1, 1, 2010, 2012, "2"},
+ {1, 1, 2010, 2013, "3"},
+ {1, 1, 2010, 2014, "4"},
+ {1, 1, 2010, 2015, "5"},
+ {1, 1, 2010, 2016, "6"},
+ {1, 1, 2010, 2017, "7"},
+ {1, 1, 2010, 2018, "8"},
+ {1, 1, 2010, 2019, "9"},
+ {1, 1, 2010, 2009, "9"},
+ {1, 1, 2010, 2020, "0"},
- {2, 2010, 2010, "10"},
- {2, 2010, 2011, "11"},
- {2, 2010, 2021, "21"},
- {2, 2010, 2099, "99"},
- {2, 2010, 2100, "00"},
- {2, 2010, 2109, "09"},
- {2, 2010, 2009, "09"},
- {2, 2010, 2110, "10"},
+ {2, 2, 2010, 2010, "10"},
+ {2, 2, 2010, 2011, "11"},
+ {2, 2, 2010, 2021, "21"},
+ {2, 2, 2010, 2099, "99"},
+ {2, 2, 2010, 2100, "00"},
+ {2, 2, 2010, 2109, "09"},
+ {2, 2, 2010, 2009, "09"},
+ {2, 2, 2010, 2110, "10"},
+
+ {2, 2, 2005, 2005, "05"},
+ {2, 2, 2005, 2099, "99"},
+ {2, 2, 2005, 2100, "00"},
+ {2, 2, 2005, 2104, "04"},
+ {2, 2, 2005, 2004, "04"},
+ {2, 2, 2005, 2105, "05"},
- {2, 2005, 2005, "05"},
- {2, 2005, 2099, "99"},
- {2, 2005, 2100, "00"},
- {2, 2005, 2104, "04"},
- {2, 2005, 2004, "04"},
- {2, 2005, 2105, "05"},
+ {3, 3, 2005, 2005, "005"},
+ {3, 3, 2005, 2099, "099"},
+ {3, 3, 2005, 2100, "100"},
+ {3, 3, 2005, 2999, "999"},
+ {3, 3, 2005, 3000, "000"},
+ {3, 3, 2005, 3004, "004"},
+ {3, 3, 2005, 2004, "004"},
+ {3, 3, 2005, 3005, "005"},
- {3, 2005, 2005, "005"},
- {3, 2005, 2099, "099"},
- {3, 2005, 2100, "100"},
- {3, 2005, 2999, "999"},
- {3, 2005, 3000, "000"},
- {3, 2005, 3004, "004"},
- {3, 2005, 2004, "004"},
- {3, 2005, 3005, "005"},
+ {9, 9, 2005, 2005, "000002005"},
+ {9, 9, 2005, 2099, "000002099"},
+ {9, 9, 2005, 2100, "000002100"},
+ {9, 9, 2005, 999999999, "999999999"},
+ {9, 9, 2005, 1000000000, "000000000"},
+ {9, 9, 2005, 1000002004, "000002004"},
+ {9, 9, 2005, 2004, "000002004"},
+ {9, 9, 2005, 1000002005, "000002005"},
- {9, 2005, 2005, "000002005"},
- {9, 2005, 2099, "000002099"},
- {9, 2005, 2100, "000002100"},
- {9, 2005, 999999999, "999999999"},
- {9, 2005, 1000000000, "000000000"},
- {9, 2005, 1000002004, "000002004"},
- {9, 2005, 2004, "000002004"},
- {9, 2005, 1000002005, "000002005"},
+ {2, 2, -2005, -2005, "05"},
+ {2, 2, -2005, -2000, "00"},
+ {2, 2, -2005, -1999, "99"},
+ {2, 2, -2005, -1904, "04"},
+ {2, 2, -2005, -2006, "06"},
+ {2, 2, -2005, -1905, "05"},
- {2, -2005, -2005, "05"},
- {2, -2005, -2000, "00"},
- {2, -2005, -1999, "99"},
- {2, -2005, -1904, "04"},
- {2, -2005, -2006, "06"},
- {2, -2005, -1905, "05"},
- };
+ {2, 4, 2005, 2099, "99"},
+ {2, 4, 2005, 2100, "00"},
+ {2, 4, 2005, 9999, "9999"},
+ {2, 4, 2005, 1000000000, "00"},
+ {2, 4, 2005, 1000002004, "2004"},
+ {2, 4, 2005, 2004, "2004"},
+ {2, 4, 2005, 2005, "05"},
+ {2, 4, 2005, 2104, "04"},
+ {2, 4, 2005, 2105, "2105"},
+ };
}
@Test(dataProvider="Pivot")
- public void test_pivot(int width, int baseValue, int value, String result) throws Exception {
+ public void test_pivot(int minWidth, int maxWidth, int baseValue, int value, String result) throws Exception {
try {
- getFormatter0(YEAR, width, baseValue).formatTo(new MockFieldValue(YEAR, value), buf);
+ getFormatter0(YEAR, minWidth, maxWidth, baseValue).formatTo(new MockFieldValue(YEAR, value), buf);
if (result == null) {
fail("Expected exception");
}
@@ -174,7 +194,34 @@
//-----------------------------------------------------------------------
public void test_toString() throws Exception {
- assertEquals(getFormatter0(YEAR, 2, 2005).toString(), "ReducedValue(Year,2,2005)");
+ assertEquals(getFormatter0(YEAR, 2, 2, 2005).toString(), "ReducedValue(Year,2,2,2005)");
+ }
+
+ //-----------------------------------------------------------------------
+ // Cases and values in adjacent parsing mode
+ //-----------------------------------------------------------------------
+ @DataProvider(name="PrintAdjacent")
+ Object[][] provider_printAdjacent() {
+ return new Object[][] {
+ // general
+ {"yyMMdd", "990703", 1999, 7, 3},
+ {"yyMMdd", "990703", 2099, 7, 3},
+ {"yyMMdd", "200703", 2020, 7, 3},
+ {"ddMMyy", "030714", 2014, 7, 3},
+ {"ddMMyy", "030720", 2020, 7, 3},
+ {"ddMMy", "03072001", 2001, 7, 3},
+ };
+ }
+
+ @Test(dataProvider="PrintAdjacent")
+ public void test_printAdjacent(String pattern, String text, int year, int month, int day) {
+ builder = new DateTimeFormatterBuilder();
+ builder.appendPattern(pattern);
+ DateTimeFormatter dtf = builder.toFormatter();
+
+ LocalDate ld = LocalDate.of(year, month, day);
+ String actual = dtf.format(ld);
+ assertEquals(actual, text, "formatter output: " + dtf);
}
}
--- a/jdk/test/java/time/test/java/time/format/TestZoneTextPrinterParser.java Wed May 15 15:01:59 2013 +0100
+++ b/jdk/test/java/time/test/java/time/format/TestZoneTextPrinterParser.java Wed May 15 07:48:57 2013 -0700
@@ -28,7 +28,7 @@
import java.text.DateFormatSymbols;
import java.time.ZoneId;
import java.time.ZonedDateTime;
-import java.time.format.DateTimeFormatSymbols;
+import java.time.format.DecimalStyle;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.TextStyle;
@@ -55,7 +55,7 @@
protected static DateTimeFormatter getFormatter(Locale locale, TextStyle style) {
return new DateTimeFormatterBuilder().appendZoneText(style)
.toFormatter(locale)
- .withSymbols(DateTimeFormatSymbols.of(locale));
+ .withDecimalStyle(DecimalStyle.of(locale));
}
public void test_printText() {
@@ -148,7 +148,7 @@
public void test_ParseText(String expected, String text, Set<ZoneId> preferred, Locale locale, TextStyle style) {
DateTimeFormatter fmt = new DateTimeFormatterBuilder().appendZoneText(style, preferred)
.toFormatter(locale)
- .withSymbols(DateTimeFormatSymbols.of(locale));
+ .withDecimalStyle(DecimalStyle.of(locale));
String ret = fmt.parse(text, TemporalQuery.zone()).getId();
@@ -209,7 +209,7 @@
}
return db.appendZoneText(style)
.toFormatter(locale)
- .withSymbols(DateTimeFormatSymbols.of(locale));
+ .withDecimalStyle(DecimalStyle.of(locale));
}
}