changeset 7159:0465f27f19f5

Merge
author vinnie
date Thu, 16 May 2013 02:43:58 -0700
parents 5153f5154162 59357ea7f131
children 9783f07d43e6
files src/share/classes/java/time/format/DateTimeFormatSymbols.java test/java/time/tck/java/time/format/TCKDateTimeFormatSymbols.java test/java/time/test/java/time/format/TestDateTimeFormatSymbols.java
diffstat 121 files changed, 4071 insertions(+), 1591 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/java/time/Clock.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Clock.java	Thu May 16 02:43:58 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/src/share/classes/java/time/DateTimeException.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/DateTimeException.java	Thu May 16 02:43:58 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/src/share/classes/java/time/DayOfWeek.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/DayOfWeek.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Duration.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Duration.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Instant.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Instant.java	Thu May 16 02:43:58 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).
+ * There are currently, as of 2013, two segments in the Java time-scale.
  * <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
+ * 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>
- * 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 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>
- * 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.
- * <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/src/share/classes/java/time/LocalDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/LocalDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/LocalDateTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/LocalDateTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/LocalTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/LocalTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Month.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Month.java	Thu May 16 02:43:58 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/src/share/classes/java/time/MonthDay.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/MonthDay.java	Thu May 16 02:43:58 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/src/share/classes/java/time/OffsetDateTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/OffsetDateTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/OffsetTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/OffsetTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Period.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Period.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Ser.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Ser.java	Thu May 16 02:43:58 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/src/share/classes/java/time/Year.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/Year.java	Thu May 16 02:43:58 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/src/share/classes/java/time/YearMonth.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/YearMonth.java	Thu May 16 02:43:58 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/src/share/classes/java/time/ZoneId.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/ZoneId.java	Thu May 16 02:43:58 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/src/share/classes/java/time/ZoneOffset.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/ZoneOffset.java	Thu May 16 02:43:58 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/src/share/classes/java/time/ZoneRegion.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/ZoneRegion.java	Thu May 16 02:43:58 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/src/share/classes/java/time/ZonedDateTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/ZonedDateTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoDateImpl.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoDateImpl.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoLocalDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoLocalDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoLocalDateTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoLocalDateTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoLocalDateTimeImpl.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoLocalDateTimeImpl.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoZonedDateTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoZonedDateTime.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ChronoZonedDateTimeImpl.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ChronoZonedDateTimeImpl.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/Chronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/Chronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/Era.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/Era.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/HijrahChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/HijrahChronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/HijrahDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/HijrahDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/HijrahEra.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/HijrahEra.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/IsoChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/IsoChronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/IsoEra.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/IsoEra.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/JapaneseChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/JapaneseChronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/JapaneseDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/JapaneseDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/JapaneseEra.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/JapaneseEra.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/MinguoChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/MinguoChronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/MinguoDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/MinguoDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/MinguoEra.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/MinguoEra.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/Ser.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/Ser.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ThaiBuddhistChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ThaiBuddhistChronology.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ThaiBuddhistDate.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ThaiBuddhistDate.java	Thu May 16 02:43:58 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/src/share/classes/java/time/chrono/ThaiBuddhistEra.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/chrono/ThaiBuddhistEra.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimeFormatSymbols.java	Wed May 15 15:39:28 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/src/share/classes/java/time/format/DateTimeFormatter.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimeFormatter.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimeFormatterBuilder.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimeFormatterBuilder.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimeParseContext.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimeParseContext.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimeParseException.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimeParseException.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimePrintContext.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimePrintContext.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DateTimeTextProvider.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/DateTimeTextProvider.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/DecimalStyle.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/FormatStyle.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/FormatStyle.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/Parsed.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/Parsed.java	Thu May 16 02:43:58 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
+                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);
             }
+        }
 
-            // 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);
+        // 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/src/share/classes/java/time/format/ResolverStyle.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/ResolverStyle.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/SignStyle.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/SignStyle.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/TextStyle.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/TextStyle.java	Thu May 16 02:43:58 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/src/share/classes/java/time/format/package-info.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/format/package-info.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/ChronoField.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/ChronoField.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/ChronoUnit.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/ChronoUnit.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/IsoFields.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/IsoFields.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/JulianFields.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/JulianFields.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/Temporal.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/Temporal.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalAccessor.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalAccessor.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalAdjuster.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalAdjuster.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalAmount.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalAmount.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalField.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalField.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalQuery.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalQuery.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/TemporalUnit.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/TemporalUnit.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/UnsupportedTemporalTypeException.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/ValueRange.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/ValueRange.java	Thu May 16 02:43:58 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/src/share/classes/java/time/temporal/WeekFields.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/temporal/WeekFields.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/Ser.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/Ser.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/ZoneOffsetTransition.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/ZoneOffsetTransition.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/ZoneOffsetTransitionRule.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/ZoneRules.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/ZoneRules.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/ZoneRulesException.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/ZoneRulesException.java	Thu May 16 02:43:58 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/src/share/classes/java/time/zone/ZoneRulesProvider.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/time/zone/ZoneRulesProvider.java	Thu May 16 02:43:58 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/src/share/classes/java/util/JapaneseImperialCalendar.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/util/JapaneseImperialCalendar.java	Thu May 16 02:43:58 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/src/share/classes/java/util/Objects.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/java/util/Objects.java	Thu May 16 02:43:58 2013 -0700
@@ -269,7 +269,7 @@
      * Checks that the specified object reference is not {@code null} and
      * throws a customized {@link NullPointerException} if it is.
      *
-     * <p>Unlike the method {@link requireNonNull(Object, String},
+     * <p>Unlike the method {@link #requireNonNull(Object, String)},
      * this method allows creation of the message to be deferred until
      * after the null check is made. While this may confer a
      * performance advantage in the non-null case, when deciding to
--- a/src/share/classes/sun/security/pkcs11/Config.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/sun/security/pkcs11/Config.java	Thu May 16 02:43:58 2013 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -643,9 +643,7 @@
     //
 
     private String parseLibrary(String keyword) throws IOException {
-        checkDup(keyword);
-        parseEquals();
-        String lib = parseLine();
+        String lib = parseStringEntry(keyword);
         lib = expand(lib);
         int i = lib.indexOf("/$ISA/");
         if (i != -1) {
--- a/src/share/classes/sun/security/pkcs11/P11Cipher.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/sun/security/pkcs11/P11Cipher.java	Thu May 16 02:43:58 2013 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -460,7 +460,7 @@
         }
 
         int result = inLen + bytesBuffered;
-        if (blockSize != 0) {
+        if (blockSize != 0 && blockMode != MODE_CTR) {
             // minus the number of bytes in the last incomplete block.
             result -= (result & (blockSize - 1));
         }
--- a/src/share/classes/sun/security/pkcs11/wrapper/PKCS11.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/sun/security/pkcs11/wrapper/PKCS11.java	Thu May 16 02:43:58 2013 -0700
@@ -1528,7 +1528,7 @@
      *
      * @exception Throwable If finalization fails.
      */
-    public void finalize() throws Throwable {
+    protected void finalize() throws Throwable {
         disconnect();
     }
 
--- a/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java	Wed May 15 15:39:28 2013 +0100
+++ b/src/share/classes/sun/util/calendar/LocalGregorianCalendar.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKInstant.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKInstant.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKLocalTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKLocalTime.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKOffsetTime.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKOffsetTime.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKYear.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKYear.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKYearMonth.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKYearMonth.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/TCKZoneOffset.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/TCKZoneOffset.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/chrono/TCKChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/chrono/TCKChronology.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/chrono/TCKChronologySerialization.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/chrono/TCKChronologySerialization.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/chrono/TCKHijrahChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/chrono/TCKHijrahChronology.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/chrono/TCKThaiBuddhistChronology.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/chrono/TCKThaiBuddhistChronology.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKDateTimeFormatSymbols.java	Wed May 15 15:39:28 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/test/java/time/tck/java/time/format/TCKDateTimeFormatter.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/format/TCKDateTimeFormatter.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKDateTimeFormatters.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/format/TCKDateTimeFormatters.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKDateTimeParseResolver.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/format/TCKDateTimeParseResolver.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKDecimalStyle.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKInstantPrinterParser.java	Thu May 16 02:43:58 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/test/java/time/tck/java/time/format/TCKTextStyle.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/format/TCKTextStyle.java	Thu May 16 02:43:58 2013 -0700
@@ -67,7 +67,7 @@
 import org.testng.annotations.Test;
 
 /**
- * Test DateTimeFormatSymbols.
+ * Test DecimalStyle.
  */
 @Test
 public class TCKTextStyle {
--- a/test/java/time/tck/java/time/temporal/TCKWeekFields.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/tck/java/time/temporal/TCKWeekFields.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/chrono/TestChronologyPerf.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/chrono/TestChronologyPerf.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/chrono/TestExampleCode.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/chrono/TestExampleCode.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/chrono/TestJapaneseChronology.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/AbstractTestPrinterParser.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/AbstractTestPrinterParser.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestDateTimeFormatSymbols.java	Wed May 15 15:39:28 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/test/java/time/test/java/time/format/TestDateTimeFormatter.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestDateTimeFormatter.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestDateTimeFormatterBuilder.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestDateTimeFormatterBuilder.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestDecimalStyle.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestFractionPrinterParser.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestFractionPrinterParser.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestNonIsoFormatter.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestNonIsoFormatter.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestNumberParser.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestNumberParser.java	Thu May 16 02:43:58 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/test/java/time/test/java/time/format/TestReducedParser.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestReducedParser.java	Thu May 16 02:43:58 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="Parse")
-    public void test_parseLenient(TemporalField field, int width, int baseValue, String input, int pos, int parseLen, Integer parseVal) {
+   @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);
-        ParsePosition ppos = new ParsePosition(pos);
         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);
         }
     }
 
+    //-----------------------------------------------------------------------
+    // 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);
+        setStrict(true);
+        TemporalAccessor parsed = getFormatter0(field, minWidth, maxWidth, baseValue).parseUnresolved(input, ppos);
+        if (ppos.getErrorIndex() != -1) {
+            assertEquals(ppos.getErrorIndex(), strict.parseLen, "error case parse position");
+            assertEquals(parsed, strict.parseVal, "unexpected parse result");
+        } else {
+            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/test/java/time/test/java/time/format/TestReducedPrinter.java	Wed May 15 15:39:28 2013 +0100
+++ b/test/java/time/test/java/time/format/TestReducedPrinter.java	Thu May 16 02:43:58 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, 2005, 2005, "05"},
-            {2, 2005, 2099, "99"},
-            {2, 2005, 2100, "00"},
-            {2, 2005, 2104, "04"},
-            {2, 2005, 2004, "04"},
-            {2, 2005, 2105, "05"},
+            {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"},
 
-            {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"},
+            {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"},
 
-            {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"},
+            {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"},
 
-            {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, 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, 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);