| /* |
| * 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) 2008-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 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; |
| import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_YEAR; |
| import static java.time.temporal.ChronoField.AMPM_OF_DAY; |
| import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_AMPM; |
| import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_DAY; |
| import static java.time.temporal.ChronoField.DAY_OF_MONTH; |
| import static java.time.temporal.ChronoField.DAY_OF_WEEK; |
| import static java.time.temporal.ChronoField.DAY_OF_YEAR; |
| import static java.time.temporal.ChronoField.EPOCH_DAY; |
| import static java.time.temporal.ChronoField.ERA; |
| import static java.time.temporal.ChronoField.HOUR_OF_AMPM; |
| import static java.time.temporal.ChronoField.HOUR_OF_DAY; |
| import static java.time.temporal.ChronoField.INSTANT_SECONDS; |
| import static java.time.temporal.ChronoField.MICRO_OF_DAY; |
| import static java.time.temporal.ChronoField.MICRO_OF_SECOND; |
| import static java.time.temporal.ChronoField.MILLI_OF_DAY; |
| import static java.time.temporal.ChronoField.MILLI_OF_SECOND; |
| import static java.time.temporal.ChronoField.MINUTE_OF_DAY; |
| 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_DAY; |
| import static java.time.temporal.ChronoField.NANO_OF_SECOND; |
| import static java.time.temporal.ChronoField.PROLEPTIC_MONTH; |
| import static java.time.temporal.ChronoField.SECOND_OF_DAY; |
| import static java.time.temporal.ChronoField.SECOND_OF_MINUTE; |
| 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.Instant; |
| import java.time.LocalDate; |
| import java.time.LocalDateTime; |
| import java.time.LocalTime; |
| import java.time.Period; |
| import java.time.ZoneId; |
| import java.time.ZoneOffset; |
| import java.time.ZonedDateTime; |
| import java.time.chrono.ChronoLocalDate; |
| import java.time.chrono.ChronoLocalDateTime; |
| import java.time.chrono.ChronoZonedDateTime; |
| import java.time.chrono.IsoChronology; |
| import java.time.chrono.MinguoChronology; |
| import java.time.chrono.MinguoDate; |
| import java.time.chrono.ThaiBuddhistChronology; |
| 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.Temporal; |
| import java.time.temporal.TemporalAccessor; |
| import java.time.temporal.TemporalField; |
| import java.time.temporal.TemporalQueries; |
| import java.time.temporal.TemporalUnit; |
| import java.time.temporal.ValueRange; |
| import java.util.Map; |
| |
| import org.testng.annotations.DataProvider; |
| import org.testng.annotations.Test; |
| |
| /** |
| * Test parse resolving. |
| */ |
| @Test |
| public class TCKDateTimeParseResolver { |
| // TODO: tests with weird TenporalField implementations |
| // TODO: tests with non-ISO chronologies |
| |
| private static final ZoneId EUROPE_ATHENS = ZoneId.of("Europe/Athens"); |
| private static final ZoneId EUROPE_PARIS = ZoneId.of("Europe/Paris"); |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveOneNoChange") |
| Object[][] data_resolveOneNoChange() { |
| return new Object[][]{ |
| {YEAR, 2012}, |
| {MONTH_OF_YEAR, 8}, |
| {DAY_OF_MONTH, 7}, |
| {DAY_OF_YEAR, 6}, |
| {DAY_OF_WEEK, 5}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveOneNoChange") |
| public void test_resolveOneNoChange(TemporalField field1, long value1) { |
| String str = Long.toString(value1); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(field1).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.isSupported(field1), true); |
| assertEquals(accessor.getLong(field1), value1); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveTwoNoChange") |
| Object[][] data_resolveTwoNoChange() { |
| return new Object[][]{ |
| {YEAR, 2012, MONTH_OF_YEAR, 5}, |
| {YEAR, 2012, DAY_OF_MONTH, 5}, |
| {YEAR, 2012, DAY_OF_WEEK, 5}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_MONTH, 5}, |
| {YEAR, 2012, IsoFields.QUARTER_OF_YEAR, 3}, |
| {YEAR, 2012, MINUTE_OF_HOUR, 5}, |
| {YEAR, 2012, SECOND_OF_MINUTE, 5}, |
| {YEAR, 2012, NANO_OF_SECOND, 5}, |
| |
| {MONTH_OF_YEAR, 5, DAY_OF_MONTH, 5}, |
| {MONTH_OF_YEAR, 5, DAY_OF_WEEK, 5}, |
| {MONTH_OF_YEAR, 5, ALIGNED_WEEK_OF_YEAR, 5}, |
| {MONTH_OF_YEAR, 5, ALIGNED_WEEK_OF_MONTH, 5}, |
| {MONTH_OF_YEAR, 3, IsoFields.QUARTER_OF_YEAR, 5}, |
| {MONTH_OF_YEAR, 5, MINUTE_OF_HOUR, 5}, |
| {MONTH_OF_YEAR, 5, SECOND_OF_MINUTE, 5}, |
| {MONTH_OF_YEAR, 5, NANO_OF_SECOND, 5}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveTwoNoChange") |
| public void test_resolveTwoNoChange(TemporalField field1, long value1, TemporalField field2, long value2) { |
| String str = value1 + " " + value2; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).toFormatter(); |
| TemporalAccessor accessor = f.parse(str); |
| |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.isSupported(field1), true); |
| assertEquals(accessor.isSupported(field2), true); |
| assertEquals(accessor.getLong(field1), value1); |
| assertEquals(accessor.getLong(field2), value2); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveThreeNoChange") |
| Object[][] data_resolveThreeNoChange() { |
| return new Object[][]{ |
| {YEAR, 2012, MONTH_OF_YEAR, 5, DAY_OF_WEEK, 5}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5, DAY_OF_MONTH, 5}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_MONTH, 5, DAY_OF_MONTH, 5}, |
| {YEAR, 2012, MONTH_OF_YEAR, 5, DAY_OF_WEEK, 5}, |
| {ERA, 1, MONTH_OF_YEAR, 5, DAY_OF_MONTH, 5}, |
| {MONTH_OF_YEAR, 1, DAY_OF_MONTH, 5, IsoFields.QUARTER_OF_YEAR, 3}, |
| {HOUR_OF_DAY, 1, SECOND_OF_MINUTE, 5, NANO_OF_SECOND, 5}, |
| {MINUTE_OF_HOUR, 1, SECOND_OF_MINUTE, 5, NANO_OF_SECOND, 5}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveThreeNoChange") |
| public void test_resolveThreeNoChange(TemporalField field1, long value1, TemporalField field2, long value2, TemporalField field3, long value3) { |
| String str = value1 + " " + value2 + " " + value3; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).appendLiteral(' ') |
| .appendValue(field3).toFormatter(); |
| TemporalAccessor accessor = f.parse(str); |
| |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.isSupported(field1), true); |
| assertEquals(accessor.isSupported(field2), true); |
| assertEquals(accessor.isSupported(field3), true); |
| assertEquals(accessor.getLong(field1), value1); |
| assertEquals(accessor.getLong(field2), value2); |
| assertEquals(accessor.getLong(field3), value3); |
| } |
| |
| //----------------------------------------------------------------------- |
| //----------------------------------------------------------------------- |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveOneToField") |
| Object[][] data_resolveOneToField() { |
| return new Object[][]{ |
| {YEAR_OF_ERA, 2012, YEAR, 2012L, null, null}, |
| {PROLEPTIC_MONTH, 2012 * 12L + (3 - 1), YEAR, 2012L, MONTH_OF_YEAR, 3L}, |
| |
| {CLOCK_HOUR_OF_AMPM, 8, HOUR_OF_AMPM, 8L, null, null}, |
| {CLOCK_HOUR_OF_AMPM, 12, HOUR_OF_AMPM, 0L, null, null}, |
| {MICRO_OF_SECOND, 12, NANO_OF_SECOND, 12_000L, null, null}, |
| {MILLI_OF_SECOND, 12, NANO_OF_SECOND, 12_000_000L, null, null}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveOneToField") |
| public void test_resolveOneToField(TemporalField field1, long value1, |
| TemporalField expectedField1, Long expectedValue1, |
| TemporalField expectedField2, Long expectedValue2) { |
| String str = Long.toString(value1); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(field1).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| if (expectedField1 != null) { |
| assertEquals(accessor.isSupported(expectedField1), true); |
| assertEquals(accessor.getLong(expectedField1), expectedValue1.longValue()); |
| } |
| if (expectedField2 != null) { |
| assertEquals(accessor.isSupported(expectedField2), true); |
| assertEquals(accessor.getLong(expectedField2), expectedValue2.longValue()); |
| } |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveOneToDate") |
| Object[][] data_resolveOneToDate() { |
| return new Object[][]{ |
| {EPOCH_DAY, 32, LocalDate.of(1970, 2, 2)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveOneToDate") |
| public void test_resolveOneToDate(TemporalField field1, long value1, LocalDate expectedDate) { |
| String str = Long.toString(value1); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(field1).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), expectedDate); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveOneToTime") |
| Object[][] data_resolveOneToTime() { |
| return new Object[][]{ |
| {HOUR_OF_DAY, 8, LocalTime.of(8, 0)}, |
| {CLOCK_HOUR_OF_DAY, 8, LocalTime.of(8, 0)}, |
| {CLOCK_HOUR_OF_DAY, 24, LocalTime.of(0, 0)}, |
| {MINUTE_OF_DAY, 650, LocalTime.of(10, 50)}, |
| {SECOND_OF_DAY, 3600 + 650, LocalTime.of(1, 10, 50)}, |
| {MILLI_OF_DAY, (3600 + 650) * 1_000L + 2, LocalTime.of(1, 10, 50, 2_000_000)}, |
| {MICRO_OF_DAY, (3600 + 650) * 1_000_000L + 2, LocalTime.of(1, 10, 50, 2_000)}, |
| {NANO_OF_DAY, (3600 + 650) * 1_000_000_000L + 2, LocalTime.of(1, 10, 50, 2)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveOneToTime") |
| public void test_resolveOneToTime(TemporalField field1, long value1, LocalTime expectedTime) { |
| String str = Long.toString(value1); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(field1).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), expectedTime); |
| } |
| |
| //----------------------------------------------------------------------- |
| //----------------------------------------------------------------------- |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveTwoToField") |
| Object[][] data_resolveTwoToField() { |
| return new Object[][]{ |
| // cross-check |
| {PROLEPTIC_MONTH, 2012 * 12L + (3 - 1), YEAR, 2012, YEAR, 2012L, MONTH_OF_YEAR, 3L}, |
| {PROLEPTIC_MONTH, 2012 * 12L + (3 - 1), YEAR_OF_ERA, 2012, YEAR, 2012L, MONTH_OF_YEAR, 3L}, |
| {PROLEPTIC_MONTH, 2012 * 12L + (3 - 1), ERA, 1, YEAR, 2012L, MONTH_OF_YEAR, 3L}, |
| {PROLEPTIC_MONTH, (3 - 1), YEAR, 0, YEAR, 0L, MONTH_OF_YEAR, 3L}, |
| {PROLEPTIC_MONTH, (3 - 1), YEAR_OF_ERA, 1, YEAR, 0L, MONTH_OF_YEAR, 3L}, |
| {PROLEPTIC_MONTH, (3 - 1), ERA, 0, YEAR, 0L, MONTH_OF_YEAR, 3L}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveTwoToField") |
| public void test_resolveTwoToField(TemporalField field1, long value1, |
| TemporalField field2, long value2, |
| TemporalField expectedField1, Long expectedValue1, |
| TemporalField expectedField2, Long expectedValue2) { |
| String str = value1 + " " + value2; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| if (expectedField1 != null) { |
| assertEquals(accessor.isSupported(expectedField1), true); |
| assertEquals(accessor.getLong(expectedField1), expectedValue1.longValue()); |
| } |
| if (expectedField2 != null) { |
| assertEquals(accessor.isSupported(expectedField2), true); |
| assertEquals(accessor.getLong(expectedField2), expectedValue2.longValue()); |
| } |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveTwoToDate") |
| Object[][] data_resolveTwoToDate() { |
| return new Object[][]{ |
| // merge |
| {YEAR, 2012, DAY_OF_YEAR, 32, LocalDate.of(2012, 2, 1)}, |
| {YEAR_OF_ERA, 2012, DAY_OF_YEAR, 32, LocalDate.of(2012, 2, 1)}, |
| |
| // merge |
| {PROLEPTIC_MONTH, 2012 * 12 + (2 - 1), DAY_OF_MONTH, 25, LocalDate.of(2012, 2, 25)}, |
| {PROLEPTIC_MONTH, 2012 * 12 + (2 - 1), DAY_OF_YEAR, 56, LocalDate.of(2012, 2, 25)}, |
| |
| // cross-check |
| {EPOCH_DAY, 32, ERA, 1, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, -146097 * 5L, ERA, 0, LocalDate.of(1970 - (400 * 5), 1, 1)}, |
| {EPOCH_DAY, 32, YEAR, 1970, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, -146097 * 5L, YEAR, 1970 - (400 * 5), LocalDate.of(1970 - (400 * 5), 1, 1)}, |
| {EPOCH_DAY, 32, YEAR_OF_ERA, 1970, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, -146097 * 5L, YEAR_OF_ERA, 1 - (1970 - (400 * 5)), LocalDate.of(1970 - (400 * 5), 1, 1)}, |
| {EPOCH_DAY, 32, MONTH_OF_YEAR, 2, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, 32, DAY_OF_YEAR, 33, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, 32, DAY_OF_MONTH, 2, LocalDate.of(1970, 2, 2)}, |
| {EPOCH_DAY, 32, DAY_OF_WEEK, 1, LocalDate.of(1970, 2, 2)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveTwoToDate") |
| public void test_resolveTwoToDate(TemporalField field1, long value1, |
| TemporalField field2, long value2, |
| LocalDate expectedDate) { |
| String str = value1 + " " + value2; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), expectedDate); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveTwoToTime") |
| Object[][] data_resolveTwoToTime() { |
| return new Object[][]{ |
| // merge |
| {HOUR_OF_DAY, 8, MINUTE_OF_HOUR, 6, LocalTime.of(8, 6)}, |
| |
| // merge |
| {AMPM_OF_DAY, 0, HOUR_OF_AMPM, 5, LocalTime.of(5, 0)}, |
| {AMPM_OF_DAY, 1, HOUR_OF_AMPM, 5, LocalTime.of(17, 0)}, |
| {AMPM_OF_DAY, 0, CLOCK_HOUR_OF_AMPM, 5, LocalTime.of(5, 0)}, |
| {AMPM_OF_DAY, 1, CLOCK_HOUR_OF_AMPM, 5, LocalTime.of(17, 0)}, |
| {AMPM_OF_DAY, 0, HOUR_OF_DAY, 5, LocalTime.of(5, 0)}, |
| {AMPM_OF_DAY, 1, HOUR_OF_DAY, 17, LocalTime.of(17, 0)}, |
| {AMPM_OF_DAY, 0, CLOCK_HOUR_OF_DAY, 5, LocalTime.of(5, 0)}, |
| {AMPM_OF_DAY, 1, CLOCK_HOUR_OF_DAY, 17, LocalTime.of(17, 0)}, |
| |
| // merge |
| {CLOCK_HOUR_OF_DAY, 8, MINUTE_OF_HOUR, 6, LocalTime.of(8, 6)}, |
| {CLOCK_HOUR_OF_DAY, 24, MINUTE_OF_HOUR, 6, LocalTime.of(0, 6)}, |
| // cross-check |
| {CLOCK_HOUR_OF_DAY, 8, HOUR_OF_DAY, 8, LocalTime.of(8, 0)}, |
| {CLOCK_HOUR_OF_DAY, 8, CLOCK_HOUR_OF_AMPM, 8, LocalTime.of(8, 0)}, |
| {CLOCK_HOUR_OF_DAY, 20, CLOCK_HOUR_OF_AMPM, 8, LocalTime.of(20, 0)}, |
| {CLOCK_HOUR_OF_DAY, 8, AMPM_OF_DAY, 0, LocalTime.of(8, 0)}, |
| {CLOCK_HOUR_OF_DAY, 20, AMPM_OF_DAY, 1, LocalTime.of(20, 0)}, |
| |
| // merge |
| {MINUTE_OF_DAY, 650, SECOND_OF_MINUTE, 8, LocalTime.of(10, 50, 8)}, |
| // cross-check |
| {MINUTE_OF_DAY, 650, HOUR_OF_DAY, 10, LocalTime.of(10, 50)}, |
| {MINUTE_OF_DAY, 650, CLOCK_HOUR_OF_DAY, 10, LocalTime.of(10, 50)}, |
| {MINUTE_OF_DAY, 650, CLOCK_HOUR_OF_AMPM, 10, LocalTime.of(10, 50)}, |
| {MINUTE_OF_DAY, 650, AMPM_OF_DAY, 0, LocalTime.of(10, 50)}, |
| {MINUTE_OF_DAY, 650, MINUTE_OF_HOUR, 50, LocalTime.of(10, 50)}, |
| |
| // merge |
| {SECOND_OF_DAY, 3600 + 650, MILLI_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2_000_000)}, |
| {SECOND_OF_DAY, 3600 + 650, MICRO_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2_000)}, |
| {SECOND_OF_DAY, 3600 + 650, NANO_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2)}, |
| // cross-check |
| {SECOND_OF_DAY, 3600 + 650, HOUR_OF_DAY, 1, LocalTime.of(1, 10, 50)}, |
| {SECOND_OF_DAY, 3600 + 650, MINUTE_OF_HOUR, 10, LocalTime.of(1, 10, 50)}, |
| {SECOND_OF_DAY, 3600 + 650, SECOND_OF_MINUTE, 50, LocalTime.of(1, 10, 50)}, |
| |
| // merge |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, MICRO_OF_SECOND, 2_004, LocalTime.of(1, 10, 50, 2_004_000)}, |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, NANO_OF_SECOND, 2_000_004, LocalTime.of(1, 10, 50, 2_000_004)}, |
| // cross-check |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, HOUR_OF_DAY, 1, LocalTime.of(1, 10, 50, 2_000_000)}, |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, MINUTE_OF_HOUR, 10, LocalTime.of(1, 10, 50, 2_000_000)}, |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, SECOND_OF_MINUTE, 50, LocalTime.of(1, 10, 50, 2_000_000)}, |
| {MILLI_OF_DAY, (3600 + 650) * 1000L + 2, MILLI_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2_000_000)}, |
| |
| // merge |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, NANO_OF_SECOND, 2_004, LocalTime.of(1, 10, 50, 2_004)}, |
| // cross-check |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, HOUR_OF_DAY, 1, LocalTime.of(1, 10, 50, 2_000)}, |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, MINUTE_OF_HOUR, 10, LocalTime.of(1, 10, 50, 2_000)}, |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, SECOND_OF_MINUTE, 50, LocalTime.of(1, 10, 50, 2_000)}, |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, MILLI_OF_SECOND, 0, LocalTime.of(1, 10, 50, 2_000)}, |
| {MICRO_OF_DAY, (3600 + 650) * 1000_000L + 2, MICRO_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2_000)}, |
| |
| // cross-check |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, HOUR_OF_DAY, 1, LocalTime.of(1, 10, 50, 2)}, |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, MINUTE_OF_HOUR, 10, LocalTime.of(1, 10, 50, 2)}, |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, SECOND_OF_MINUTE, 50, LocalTime.of(1, 10, 50, 2)}, |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, MILLI_OF_SECOND, 0, LocalTime.of(1, 10, 50, 2)}, |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, MICRO_OF_SECOND, 0, LocalTime.of(1, 10, 50, 2)}, |
| {NANO_OF_DAY, (3600 + 650) * 1000_000_000L + 2, NANO_OF_SECOND, 2, LocalTime.of(1, 10, 50, 2)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveTwoToTime") |
| public void test_resolveTwoToTime(TemporalField field1, long value1, |
| TemporalField field2, long value2, |
| LocalTime expectedTime) { |
| String str = value1 + " " + value2; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), expectedTime); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveThreeToDate") |
| Object[][] data_resolveThreeToDate() { |
| return new Object[][]{ |
| // merge |
| {YEAR, 2012, MONTH_OF_YEAR, 2, DAY_OF_MONTH, 1, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5, ALIGNED_DAY_OF_WEEK_IN_YEAR, 4, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5, DAY_OF_WEEK, 3, LocalDate.of(2012, 2, 1)}, |
| |
| // cross-check |
| {YEAR, 2012, DAY_OF_YEAR, 32, DAY_OF_MONTH, 1, LocalDate.of(2012, 2, 1)}, |
| {YEAR_OF_ERA, 2012, DAY_OF_YEAR, 32, DAY_OF_MONTH, 1, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, DAY_OF_YEAR, 32, DAY_OF_WEEK, 3, LocalDate.of(2012, 2, 1)}, |
| {PROLEPTIC_MONTH, 2012 * 12 + (2 - 1), DAY_OF_MONTH, 25, DAY_OF_WEEK, 6, LocalDate.of(2012, 2, 25)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveThreeToDate") |
| public void test_resolveThreeToDate(TemporalField field1, long value1, |
| TemporalField field2, long value2, |
| TemporalField field3, long value3, |
| LocalDate expectedDate) { |
| String str = value1 + " " + value2 + " " + value3; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).appendLiteral(' ') |
| .appendValue(field3).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), expectedDate); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @DataProvider(name="resolveFourToDate") |
| Object[][] data_resolveFourToDate() { |
| return new Object[][]{ |
| // merge |
| {YEAR, 2012, MONTH_OF_YEAR, 2, ALIGNED_WEEK_OF_MONTH, 1, ALIGNED_DAY_OF_WEEK_IN_MONTH, 1, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, MONTH_OF_YEAR, 2, ALIGNED_WEEK_OF_MONTH, 1, DAY_OF_WEEK, 3, LocalDate.of(2012, 2, 1)}, |
| |
| // cross-check |
| {YEAR, 2012, MONTH_OF_YEAR, 2, DAY_OF_MONTH, 1, DAY_OF_WEEK, 3, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5, ALIGNED_DAY_OF_WEEK_IN_YEAR, 4, DAY_OF_WEEK, 3, LocalDate.of(2012, 2, 1)}, |
| {YEAR, 2012, ALIGNED_WEEK_OF_YEAR, 5, DAY_OF_WEEK, 3, DAY_OF_MONTH, 1, LocalDate.of(2012, 2, 1)}, |
| }; |
| } |
| |
| @Test(dataProvider="resolveFourToDate") |
| public void test_resolveFourToDate(TemporalField field1, long value1, |
| TemporalField field2, long value2, |
| TemporalField field3, long value3, |
| TemporalField field4, long value4, |
| LocalDate expectedDate) { |
| String str = value1 + " " + value2 + " " + value3 + " " + value4; |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(field1).appendLiteral(' ') |
| .appendValue(field2).appendLiteral(' ') |
| .appendValue(field3).appendLiteral(' ') |
| .appendValue(field4).toFormatter(); |
| |
| TemporalAccessor accessor = f.parse(str); |
| assertEquals(accessor.query(TemporalQueries.localDate()), expectedDate); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null, "ResolverStyle: " + s); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null, "ResolverStyle: " + s); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), expectedDate, "ResolverStyle: " + s); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.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(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.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 |
| } |
| } |
| } |
| |
| //----------------------------------------------------------------------- |
| // SPEC: DateTimeFormatter.withChronology() |
| @Test |
| public void test_withChronology_noOverride() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).toFormatter(); |
| TemporalAccessor accessor = f.parse(""); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), IsoChronology.INSTANCE); |
| } |
| |
| @Test |
| public void test_withChronology_override() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| TemporalAccessor accessor = f.parse(""); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), MinguoChronology.INSTANCE); |
| } |
| |
| @Test |
| public void test_withChronology_parsedChronology_noOverride() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).appendChronologyId().toFormatter(); |
| TemporalAccessor accessor = f.parse("ThaiBuddhist"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), ThaiBuddhistChronology.INSTANCE); |
| } |
| |
| @Test |
| public void test_withChronology_parsedChronology_override() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).appendChronologyId().toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| TemporalAccessor accessor = f.parse("ThaiBuddhist"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), ThaiBuddhistChronology.INSTANCE); |
| } |
| |
| //----------------------------------------------------------------------- |
| // SPEC: DateTimeFormatter.withZone() |
| @Test |
| public void test_withZone_noOverride() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).toFormatter(); |
| TemporalAccessor accessor = f.parse(""); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), null); |
| } |
| |
| @Test |
| public void test_withZone_override() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).toFormatter(); |
| f = f.withZone(EUROPE_ATHENS); |
| TemporalAccessor accessor = f.parse(""); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), EUROPE_ATHENS); |
| } |
| |
| @Test |
| public void test_withZone_parsedZone_noOverride() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).appendZoneId().toFormatter(); |
| TemporalAccessor accessor = f.parse("Europe/Paris"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), EUROPE_PARIS); |
| } |
| |
| @Test |
| public void test_withZone_parsedZone_override() { |
| DateTimeFormatter f = new DateTimeFormatterBuilder().parseDefaulting(EPOCH_DAY, 2).appendZoneId().toFormatter(); |
| f = f.withZone(EUROPE_ATHENS); |
| TemporalAccessor accessor = f.parse("Europe/Paris"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(1970, 1, 3)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), EUROPE_PARIS); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_fieldResolvesToLocalTime() { |
| LocalTime lt = LocalTime.of(12, 30, 40); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(lt)).toFormatter(); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), null); |
| assertEquals(accessor.query(TemporalQueries.localTime()), lt); |
| } |
| |
| //------------------------------------------------------------------------- |
| @Test |
| public void test_fieldResolvesToChronoLocalDate_noOverrideChrono_matches() { |
| LocalDate ldt = LocalDate.of(2010, 6, 30); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(ldt)).toFormatter(); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(2010, 6, 30)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), IsoChronology.INSTANCE); |
| } |
| |
| @Test |
| public void test_fieldResolvesToChronoLocalDate_overrideChrono_matches() { |
| MinguoDate mdt = MinguoDate.of(100, 6, 30); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(mdt)).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.from(mdt)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), null); |
| assertEquals(accessor.query(TemporalQueries.chronology()), MinguoChronology.INSTANCE); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoLocalDate_noOverrideChrono_wrongChrono() { |
| ChronoLocalDate cld = ThaiBuddhistChronology.INSTANCE.dateNow(); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cld)).toFormatter(); |
| f.parse("1234567890"); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoLocalDate_overrideChrono_wrongChrono() { |
| ChronoLocalDate cld = ThaiBuddhistChronology.INSTANCE.dateNow(); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cld)).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| f.parse("1234567890"); |
| } |
| |
| //------------------------------------------------------------------------- |
| @Test |
| public void test_fieldResolvesToChronoLocalDateTime_noOverrideChrono_matches() { |
| LocalDateTime ldt = LocalDateTime.of(2010, 6, 30, 12, 30); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(ldt)).toFormatter(); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(2010, 6, 30)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), LocalTime.of(12, 30)); |
| assertEquals(accessor.query(TemporalQueries.chronology()), IsoChronology.INSTANCE); |
| } |
| |
| @Test |
| public void test_fieldResolvesToChronoLocalDateTime_overrideChrono_matches() { |
| MinguoDate mdt = MinguoDate.of(100, 6, 30); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(mdt.atTime(LocalTime.NOON))).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.from(mdt)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), LocalTime.NOON); |
| assertEquals(accessor.query(TemporalQueries.chronology()), MinguoChronology.INSTANCE); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoLocalDateTime_noOverrideChrono_wrongChrono() { |
| ChronoLocalDateTime<?> cldt = ThaiBuddhistChronology.INSTANCE.dateNow().atTime(LocalTime.NOON); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cldt)).toFormatter(); |
| f.parse("1234567890"); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoLocalDateTime_overrideChrono_wrongChrono() { |
| ChronoLocalDateTime<?> cldt = ThaiBuddhistChronology.INSTANCE.dateNow().atTime(LocalTime.NOON); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cldt)).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| f.parse("1234567890"); |
| } |
| |
| //------------------------------------------------------------------------- |
| @Test |
| public void test_fieldResolvesToChronoZonedDateTime_noOverrideChrono_matches() { |
| ZonedDateTime zdt = ZonedDateTime.of(2010, 6, 30, 12, 30, 0, 0, EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(zdt)).toFormatter(); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.of(2010, 6, 30)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), LocalTime.of(12, 30)); |
| assertEquals(accessor.query(TemporalQueries.chronology()), IsoChronology.INSTANCE); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), EUROPE_PARIS); |
| } |
| |
| @Test |
| public void test_fieldResolvesToChronoZonedDateTime_overrideChrono_matches() { |
| MinguoDate mdt = MinguoDate.of(100, 6, 30); |
| ChronoZonedDateTime<MinguoDate> mzdt = mdt.atTime(LocalTime.NOON).atZone(EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(mzdt)).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| TemporalAccessor accessor = f.parse("1234567890"); |
| assertEquals(accessor.query(TemporalQueries.localDate()), LocalDate.from(mdt)); |
| assertEquals(accessor.query(TemporalQueries.localTime()), LocalTime.NOON); |
| assertEquals(accessor.query(TemporalQueries.chronology()), MinguoChronology.INSTANCE); |
| assertEquals(accessor.query(TemporalQueries.zoneId()), EUROPE_PARIS); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoZonedDateTime_noOverrideChrono_wrongChrono() { |
| ChronoZonedDateTime<?> cldt = ThaiBuddhistChronology.INSTANCE.dateNow().atTime(LocalTime.NOON).atZone(EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cldt)).toFormatter(); |
| f.parse("1234567890"); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoZonedDateTime_overrideChrono_wrongChrono() { |
| ChronoZonedDateTime<?> cldt = ThaiBuddhistChronology.INSTANCE.dateNow().atTime(LocalTime.NOON).atZone(EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(cldt)).toFormatter(); |
| f = f.withChronology(MinguoChronology.INSTANCE); |
| f.parse("1234567890"); |
| } |
| |
| @Test |
| public void test_fieldResolvesToChronoZonedDateTime_overrideZone_matches() { |
| ZonedDateTime zdt = ZonedDateTime.of(2010, 6, 30, 12, 30, 0, 0, EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(zdt)).toFormatter(); |
| f = f.withZone(EUROPE_PARIS); |
| assertEquals(f.parse("1234567890", ZonedDateTime::from), zdt); |
| } |
| |
| @Test(expectedExceptions = DateTimeParseException.class) |
| public void test_fieldResolvesToChronoZonedDateTime_overrideZone_wrongZone() { |
| ZonedDateTime zdt = ZonedDateTime.of(2010, 6, 30, 12, 30, 0, 0, EUROPE_PARIS); |
| DateTimeFormatter f = new DateTimeFormatterBuilder().appendValue(new ResolvingField(zdt)).toFormatter(); |
| f = f.withZone(ZoneId.of("Europe/London")); |
| f.parse("1234567890"); |
| } |
| |
| //------------------------------------------------------------------------- |
| private static class ResolvingField implements TemporalField { |
| private final TemporalAccessor resolvedValue; |
| ResolvingField(TemporalAccessor resolvedValue) { |
| this.resolvedValue = resolvedValue; |
| } |
| @Override |
| public TemporalUnit getBaseUnit() { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public TemporalUnit getRangeUnit() { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public ValueRange range() { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public boolean isDateBased() { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public boolean isTimeBased() { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public boolean isSupportedBy(TemporalAccessor temporal) { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public long getFrom(TemporalAccessor temporal) { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public <R extends Temporal> R adjustInto(R temporal, long newValue) { |
| throw new UnsupportedOperationException(); |
| } |
| @Override |
| public TemporalAccessor resolve( |
| Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) { |
| fieldValues.remove(this); |
| return resolvedValue; |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // SPEC: ChronoField.INSTANT_SECONDS |
| @Test |
| public void test_parse_fromField_InstantSeconds() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(INSTANT_SECONDS).toFormatter(); |
| TemporalAccessor acc = fmt.parse("86402"); |
| Instant expected = Instant.ofEpochSecond(86402); |
| assertEquals(acc.isSupported(INSTANT_SECONDS), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(INSTANT_SECONDS), 86402L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 0L); |
| assertEquals(Instant.from(acc), expected); |
| } |
| |
| @Test |
| public void test_parse_fromField_InstantSeconds_NanoOfSecond() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(INSTANT_SECONDS).appendLiteral('.').appendValue(NANO_OF_SECOND).toFormatter(); |
| TemporalAccessor acc = fmt.parse("86402.123456789"); |
| Instant expected = Instant.ofEpochSecond(86402, 123456789); |
| assertEquals(acc.isSupported(INSTANT_SECONDS), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(INSTANT_SECONDS), 86402L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 123456789L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 123456L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 123L); |
| assertEquals(Instant.from(acc), expected); |
| } |
| |
| // SPEC: ChronoField.SECOND_OF_DAY |
| @Test |
| public void test_parse_fromField_SecondOfDay() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(SECOND_OF_DAY).toFormatter(); |
| TemporalAccessor acc = fmt.parse("864"); |
| assertEquals(acc.isSupported(SECOND_OF_DAY), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(SECOND_OF_DAY), 864L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 0L); |
| } |
| |
| @Test |
| public void test_parse_fromField_SecondOfDay_NanoOfSecond() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(SECOND_OF_DAY).appendLiteral('.').appendValue(NANO_OF_SECOND).toFormatter(); |
| TemporalAccessor acc = fmt.parse("864.123456789"); |
| assertEquals(acc.isSupported(SECOND_OF_DAY), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(SECOND_OF_DAY), 864L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 123456789L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 123456L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 123L); |
| } |
| |
| // SPEC: ChronoField.SECOND_OF_MINUTE |
| @Test |
| public void test_parse_fromField_SecondOfMinute() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(SECOND_OF_MINUTE).toFormatter(); |
| TemporalAccessor acc = fmt.parse("32"); |
| assertEquals(acc.isSupported(SECOND_OF_MINUTE), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(SECOND_OF_MINUTE), 32L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 0L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 0L); |
| } |
| |
| @Test |
| public void test_parse_fromField_SecondOfMinute_NanoOfSecond() { |
| DateTimeFormatter fmt = new DateTimeFormatterBuilder() |
| .appendValue(SECOND_OF_MINUTE).appendLiteral('.').appendValue(NANO_OF_SECOND).toFormatter(); |
| TemporalAccessor acc = fmt.parse("32.123456789"); |
| assertEquals(acc.isSupported(SECOND_OF_MINUTE), true); |
| assertEquals(acc.isSupported(NANO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MICRO_OF_SECOND), true); |
| assertEquals(acc.isSupported(MILLI_OF_SECOND), true); |
| assertEquals(acc.getLong(SECOND_OF_MINUTE), 32L); |
| assertEquals(acc.getLong(NANO_OF_SECOND), 123456789L); |
| assertEquals(acc.getLong(MICRO_OF_SECOND), 123456L); |
| assertEquals(acc.getLong(MILLI_OF_SECOND), 123L); |
| } |
| |
| } |
