| /* |
| * 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) 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 tck.java.time.format; |
| |
| 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.HOUR_OF_DAY; |
| 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.assertNull; |
| import static org.testng.Assert.assertTrue; |
| import static org.testng.Assert.fail; |
| |
| import java.text.Format; |
| import java.text.ParseException; |
| import java.text.ParsePosition; |
| import java.time.DateTimeException; |
| import java.time.DayOfWeek; |
| import java.time.Instant; |
| import java.time.LocalDate; |
| import java.time.LocalDateTime; |
| import java.time.LocalTime; |
| import java.time.OffsetDateTime; |
| import java.time.OffsetTime; |
| import java.time.YearMonth; |
| import java.time.ZoneId; |
| import java.time.ZoneOffset; |
| import java.time.ZonedDateTime; |
| import java.time.chrono.ChronoZonedDateTime; |
| import java.time.chrono.Chronology; |
| import java.time.chrono.IsoChronology; |
| import java.time.chrono.ThaiBuddhistChronology; |
| import java.time.chrono.ThaiBuddhistDate; |
| import java.time.format.DecimalStyle; |
| import java.time.format.DateTimeFormatter; |
| import java.time.format.DateTimeFormatterBuilder; |
| import java.time.format.DateTimeParseException; |
| import java.time.format.SignStyle; |
| import java.time.temporal.IsoFields; |
| import java.time.temporal.TemporalAccessor; |
| import java.time.temporal.TemporalField; |
| import java.time.temporal.TemporalQuery; |
| import java.time.temporal.UnsupportedTemporalTypeException; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Locale; |
| import java.util.Set; |
| |
| import org.testng.annotations.BeforeMethod; |
| import org.testng.annotations.DataProvider; |
| import org.testng.annotations.Test; |
| |
| /** |
| * Test DateTimeFormatter. |
| */ |
| @Test |
| public class TCKDateTimeFormatter { |
| |
| private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1); |
| private static final ZoneOffset OFFSET_PTHREE = ZoneOffset.ofHours(3); |
| private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris"); |
| |
| private static final DateTimeFormatter BASIC_FORMATTER = DateTimeFormatter.ofPattern("'ONE'd"); |
| private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("'ONE'yyyy MM dd"); |
| |
| private DateTimeFormatter fmt; |
| |
| @BeforeMethod |
| public void setUp() { |
| fmt = new DateTimeFormatterBuilder().appendLiteral("ONE") |
| .appendValue(DAY_OF_MONTH, 1, 2, SignStyle.NOT_NEGATIVE) |
| .toFormatter(); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_withLocale() { |
| 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).withDecimalStyle(DecimalStyle.STANDARD); |
| base.withLocale((Locale) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_withChronology() { |
| DateTimeFormatter test = fmt; |
| assertEquals(test.getChronology(), null); |
| test = test.withChronology(IsoChronology.INSTANCE); |
| assertEquals(test.getChronology(), IsoChronology.INSTANCE); |
| test = test.withChronology(null); |
| assertEquals(test.getChronology(), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_withZone() { |
| DateTimeFormatter test = fmt; |
| assertEquals(test.getZone(), null); |
| test = test.withZone(ZoneId.of("Europe/Paris")); |
| assertEquals(test.getZone(), ZoneId.of("Europe/Paris")); |
| test = test.withZone(ZoneOffset.UTC); |
| assertEquals(test.getZone(), ZoneOffset.UTC); |
| test = test.withZone(null); |
| assertEquals(test.getZone(), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_resolverFields_selectOneDateResolveYMD() throws Exception { |
| DateTimeFormatter base = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).appendLiteral('-').appendValue(MONTH_OF_YEAR).appendLiteral('-') |
| .appendValue(DAY_OF_MONTH).appendLiteral('-').appendValue(DAY_OF_YEAR).toFormatter(); |
| DateTimeFormatter f = base.withResolverFields(YEAR, MONTH_OF_YEAR, DAY_OF_MONTH); |
| try { |
| base.parse("2012-6-30-321", LocalDate::from); // wrong day-of-year |
| fail(); |
| } catch (DateTimeException ex) { |
| // expected, fails as it produces two different dates |
| } |
| LocalDate parsed = f.parse("2012-6-30-321", LocalDate::from); // ignored day-of-year |
| assertEquals(parsed, LocalDate.of(2012, 6, 30)); |
| } |
| |
| @Test |
| public void test_resolverFields_selectOneDateResolveYD() throws Exception { |
| DateTimeFormatter base = new DateTimeFormatterBuilder() |
| .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); |
| 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(); |
| } catch (DateTimeException ex) { |
| // expected, fails as it produces two different dates |
| } |
| LocalDate parsed = f.parse("2012-6-30-321", LocalDate::from); // ignored month/day-of-month |
| assertEquals(parsed, LocalDate.of(2012, 11, 16)); |
| } |
| |
| @Test |
| public void test_resolverFields_ignoreCrossCheck() throws Exception { |
| DateTimeFormatter base = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).appendLiteral('-').appendValue(DAY_OF_YEAR).appendLiteral('-') |
| .appendValue(DAY_OF_WEEK).toFormatter(); |
| DateTimeFormatter f = base.withResolverFields(YEAR, DAY_OF_YEAR); |
| try { |
| base.parse("2012-321-1", LocalDate::from); // wrong day-of-week |
| fail(); |
| } catch (DateTimeException ex) { |
| // expected, should fail in cross-check of day-of-week |
| } |
| LocalDate parsed = f.parse("2012-321-1", LocalDate::from); // ignored wrong day-of-week |
| assertEquals(parsed, LocalDate.of(2012, 11, 16)); |
| } |
| |
| @Test |
| public void test_resolverFields_emptyList() throws Exception { |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).toFormatter().withResolverFields(); |
| TemporalAccessor parsed = f.parse("2012"); |
| assertEquals(parsed.isSupported(YEAR), false); // not in the list of resolverFields |
| } |
| |
| @Test |
| public void test_resolverFields_listOfOneMatching() throws Exception { |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).toFormatter().withResolverFields(YEAR); |
| TemporalAccessor parsed = f.parse("2012"); |
| assertEquals(parsed.isSupported(YEAR), true); |
| } |
| |
| @Test |
| public void test_resolverFields_listOfOneNotMatching() throws Exception { |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).toFormatter().withResolverFields(MONTH_OF_YEAR); |
| TemporalAccessor parsed = f.parse("2012"); |
| assertEquals(parsed.isSupported(YEAR), false); // not in the list of resolverFields |
| assertEquals(parsed.isSupported(MONTH_OF_YEAR), false); |
| } |
| |
| @Test |
| public void test_resolverFields_listOfOneNull() throws Exception { |
| DateTimeFormatter f = new DateTimeFormatterBuilder() |
| .appendValue(YEAR).toFormatter().withResolverFields((TemporalField) null); |
| TemporalAccessor parsed = f.parse("2012"); |
| assertEquals(parsed.isSupported(YEAR), false); // not in the list of resolverFields |
| } |
| |
| @Test |
| public void test_resolverFields_Array_null() throws Exception { |
| DateTimeFormatter f = DateTimeFormatter.ISO_DATE.withResolverFields(MONTH_OF_YEAR); |
| assertEquals(f.getResolverFields().size(), 1); |
| f = f.withResolverFields((TemporalField[]) null); |
| assertEquals(f.getResolverFields(), null); |
| } |
| |
| @Test |
| public void test_resolverFields_Set_null() throws Exception { |
| DateTimeFormatter f = DateTimeFormatter.ISO_DATE.withResolverFields(MONTH_OF_YEAR); |
| assertEquals(f.getResolverFields().size(), 1); |
| f = f.withResolverFields((Set<TemporalField>) null); |
| assertEquals(f.getResolverFields(), null); |
| } |
| |
| //----------------------------------------------------------------------- |
| // format |
| //----------------------------------------------------------------------- |
| @DataProvider(name="formatWithZoneWithChronology") |
| Object[][] data_format_withZone_withChronology() { |
| YearMonth ym = YearMonth.of(2008, 6); |
| LocalDate ld = LocalDate.of(2008, 6, 30); |
| LocalTime lt = LocalTime.of(11, 30); |
| LocalDateTime ldt = LocalDateTime.of(2008, 6, 30, 11, 30); |
| OffsetTime ot = OffsetTime.of(LocalTime.of(11, 30), OFFSET_PONE); |
| OffsetDateTime odt = OffsetDateTime.of(LocalDateTime.of(2008, 6, 30, 11, 30), OFFSET_PONE); |
| ZonedDateTime zdt = ZonedDateTime.of(LocalDateTime.of(2008, 6, 30, 11, 30), ZONE_PARIS); |
| ChronoZonedDateTime<ThaiBuddhistDate> thaiZdt = ThaiBuddhistChronology.INSTANCE.zonedDateTime(zdt); |
| Instant instant = Instant.ofEpochSecond(3600); |
| return new Object[][] { |
| {null, null, DayOfWeek.MONDAY, "::::"}, |
| {null, null, ym, "2008::::ISO"}, |
| {null, null, ld, "2008::::ISO"}, |
| {null, null, lt, ":11:::"}, |
| {null, null, ldt, "2008:11:::ISO"}, |
| {null, null, ot, ":11:+01:00::"}, |
| {null, null, odt, "2008:11:+01:00::ISO"}, |
| {null, null, zdt, "2008:11:+02:00:Europe/Paris:ISO"}, |
| {null, null, instant, "::::"}, |
| |
| {IsoChronology.INSTANCE, null, DayOfWeek.MONDAY, "::::ISO"}, |
| {IsoChronology.INSTANCE, null, ym, "2008::::ISO"}, |
| {IsoChronology.INSTANCE, null, ld, "2008::::ISO"}, |
| {IsoChronology.INSTANCE, null, lt, ":11:::ISO"}, |
| {IsoChronology.INSTANCE, null, ldt, "2008:11:::ISO"}, |
| {IsoChronology.INSTANCE, null, ot, ":11:+01:00::ISO"}, |
| {IsoChronology.INSTANCE, null, odt, "2008:11:+01:00::ISO"}, |
| {IsoChronology.INSTANCE, null, zdt, "2008:11:+02:00:Europe/Paris:ISO"}, |
| {IsoChronology.INSTANCE, null, instant, "::::ISO"}, |
| |
| {null, ZONE_PARIS, DayOfWeek.MONDAY, ":::Europe/Paris:"}, |
| {null, ZONE_PARIS, ym, "2008:::Europe/Paris:ISO"}, |
| {null, ZONE_PARIS, ld, "2008:::Europe/Paris:ISO"}, |
| {null, ZONE_PARIS, lt, ":11::Europe/Paris:"}, |
| {null, ZONE_PARIS, ldt, "2008:11::Europe/Paris:ISO"}, |
| {null, ZONE_PARIS, ot, ":11:+01:00:Europe/Paris:"}, |
| {null, ZONE_PARIS, odt, "2008:12:+02:00:Europe/Paris:ISO"}, |
| {null, ZONE_PARIS, zdt, "2008:11:+02:00:Europe/Paris:ISO"}, |
| {null, ZONE_PARIS, instant, "1970:02:+01:00:Europe/Paris:ISO"}, |
| |
| {null, OFFSET_PTHREE, DayOfWeek.MONDAY, ":::+03:00:"}, |
| {null, OFFSET_PTHREE, ym, "2008:::+03:00:ISO"}, |
| {null, OFFSET_PTHREE, ld, "2008:::+03:00:ISO"}, |
| {null, OFFSET_PTHREE, lt, ":11::+03:00:"}, |
| {null, OFFSET_PTHREE, ldt, "2008:11::+03:00:ISO"}, |
| {null, OFFSET_PTHREE, ot, null}, // offset and zone clash |
| {null, OFFSET_PTHREE, odt, "2008:13:+03:00:+03:00:ISO"}, |
| {null, OFFSET_PTHREE, zdt, "2008:12:+03:00:+03:00:ISO"}, |
| {null, OFFSET_PTHREE, instant, "1970:04:+03:00:+03:00:ISO"}, |
| |
| {ThaiBuddhistChronology.INSTANCE, null, DayOfWeek.MONDAY, null}, // not a complete date |
| {ThaiBuddhistChronology.INSTANCE, null, ym, null}, // not a complete date |
| {ThaiBuddhistChronology.INSTANCE, null, ld, "2551::::ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, lt, ":11:::ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, ldt, "2551:11:::ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, ot, ":11:+01:00::ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, odt, "2551:11:+01:00::ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, zdt, "2551:11:+02:00:Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, null, instant, "::::ThaiBuddhist"}, |
| |
| {ThaiBuddhistChronology.INSTANCE, null, DayOfWeek.MONDAY, null}, // not a complete date |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, ym, null}, // not a complete date |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, ld, "2551:::Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, lt, ":11::Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, ldt, "2551:11::Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, ot, ":11:+01:00:Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, odt, "2551:12:+02:00:Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, zdt, "2551:11:+02:00:Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, instant, "2513:02:+01:00:Europe/Paris:ThaiBuddhist"}, |
| |
| {null, ZONE_PARIS, thaiZdt, "2551:11:+02:00:Europe/Paris:ThaiBuddhist"}, |
| {ThaiBuddhistChronology.INSTANCE, ZONE_PARIS, thaiZdt, "2551:11:+02:00:Europe/Paris:ThaiBuddhist"}, |
| {IsoChronology.INSTANCE, ZONE_PARIS, thaiZdt, "2008:11:+02:00:Europe/Paris:ISO"}, |
| }; |
| } |
| |
| @Test(dataProvider="formatWithZoneWithChronology") |
| public void test_format_withZone_withChronology(Chronology overrideChrono, ZoneId overrideZone, TemporalAccessor temporal, String expected) { |
| DateTimeFormatter test = new DateTimeFormatterBuilder() |
| .optionalStart().appendValue(YEAR, 4).optionalEnd() |
| .appendLiteral(':').optionalStart().appendValue(HOUR_OF_DAY, 2).optionalEnd() |
| .appendLiteral(':').optionalStart().appendOffsetId().optionalEnd() |
| .appendLiteral(':').optionalStart().appendZoneId().optionalEnd() |
| .appendLiteral(':').optionalStart().appendChronologyId().optionalEnd() |
| .toFormatter(Locale.ENGLISH) |
| .withChronology(overrideChrono).withZone(overrideZone); |
| if (expected != null) { |
| String result = test.format(temporal); |
| assertEquals(result, expected); |
| } else { |
| try { |
| test.format(temporal); |
| fail("Formatting should have failed"); |
| } catch (DateTimeException ex) { |
| // expected |
| } |
| } |
| } |
| |
| @Test |
| public void test_format_withChronology_nonChronoFieldMapLink() { |
| TemporalAccessor temporal = new TemporalAccessor() { |
| @Override |
| public boolean isSupported(TemporalField field) { |
| return field == IsoFields.WEEK_BASED_YEAR; |
| } |
| @Override |
| public long getLong(TemporalField field) { |
| if (field == IsoFields.WEEK_BASED_YEAR) { |
| return 2345; |
| } |
| throw new UnsupportedTemporalTypeException("Unsupported field: " + field); |
| } |
| }; |
| DateTimeFormatter test = new DateTimeFormatterBuilder() |
| .appendValue(IsoFields.WEEK_BASED_YEAR, 4) |
| .toFormatter(Locale.ENGLISH) |
| .withChronology(IsoChronology.INSTANCE); |
| String result = test.format(temporal); |
| assertEquals(result, "2345"); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_format_TemporalAccessor_simple() { |
| 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).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).withDecimalStyle(DecimalStyle.STANDARD); |
| test.format((TemporalAccessor) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_print_TemporalAppendable() throws Exception { |
| 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"); |
| } |
| |
| @Test(expectedExceptions=DateTimeException.class) |
| public void test_print_TemporalAppendable_noSuchField() throws Exception { |
| 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).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).withDecimalStyle(DecimalStyle.STANDARD); |
| test.formatTo(LocalDate.of(2008, 6, 30), (Appendable) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| // parse(CharSequence) |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_parse_CharSequence() { |
| 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); |
| assertEquals(result.isSupported(HOUR_OF_DAY), false); |
| } |
| |
| @Test |
| public void test_parse_CharSequence_resolved() { |
| DateTimeFormatter test = DateTimeFormatter.ISO_DATE; |
| TemporalAccessor result = test.parse("2012-06-30"); |
| assertEquals(result.isSupported(YEAR), true); |
| assertEquals(result.isSupported(MONTH_OF_YEAR), true); |
| assertEquals(result.isSupported(DAY_OF_MONTH), true); |
| assertEquals(result.isSupported(HOUR_OF_DAY), false); |
| assertEquals(result.getLong(YEAR), 2012L); |
| assertEquals(result.getLong(MONTH_OF_YEAR), 6L); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| assertEquals(result.query(LocalDate::from), LocalDate.of(2012, 6, 30)); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parse_CharSequence_null() { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| test.parse((String) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| // parse(CharSequence) |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_parse_CharSequence_ParsePosition() { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(3); |
| TemporalAccessor result = test.parse("XXXONE30XXX", pos); |
| assertEquals(pos.getIndex(), 8); |
| assertEquals(pos.getErrorIndex(), -1); |
| assertEquals(result.isSupported(DAY_OF_MONTH), true); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| assertEquals(result.isSupported(HOUR_OF_DAY), false); |
| } |
| |
| @Test |
| public void test_parse_CharSequence_ParsePosition_resolved() { |
| DateTimeFormatter test = DateTimeFormatter.ISO_DATE; |
| ParsePosition pos = new ParsePosition(3); |
| TemporalAccessor result = test.parse("XXX2012-06-30XXX", pos); |
| assertEquals(pos.getIndex(), 13); |
| assertEquals(pos.getErrorIndex(), -1); |
| assertEquals(result.isSupported(YEAR), true); |
| assertEquals(result.isSupported(MONTH_OF_YEAR), true); |
| assertEquals(result.isSupported(DAY_OF_MONTH), true); |
| assertEquals(result.isSupported(HOUR_OF_DAY), false); |
| assertEquals(result.getLong(YEAR), 2012L); |
| assertEquals(result.getLong(MONTH_OF_YEAR), 6L); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| assertEquals(result.query(LocalDate::from), LocalDate.of(2012, 6, 30)); |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parse_CharSequence_ParsePosition_parseError() { |
| DateTimeFormatter test = DateTimeFormatter.ISO_DATE; |
| ParsePosition pos = new ParsePosition(3); |
| try { |
| test.parse("XXX2012XXX", pos); |
| fail(); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getErrorIndex(), 7); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=IndexOutOfBoundsException.class) |
| public void test_parse_CharSequence_ParsePosition_indexTooBig() { |
| DateTimeFormatter test = DateTimeFormatter.ISO_DATE; |
| test.parse("Text", new ParsePosition(5)); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parse_CharSequence_ParsePosition_nullText() { |
| 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).withDecimalStyle(DecimalStyle.STANDARD); |
| test.parse("Text", (ParsePosition) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| // parse(Query) |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_parse_Query_String() throws Exception { |
| LocalDate result = DATE_FORMATTER.parse("ONE2012 07 27", LocalDate::from); |
| assertEquals(result, LocalDate.of(2012, 7, 27)); |
| } |
| |
| @Test |
| public void test_parse_Query_CharSequence() throws Exception { |
| LocalDate result = DATE_FORMATTER.parse(new StringBuilder("ONE2012 07 27"), LocalDate::from); |
| assertEquals(result, LocalDate.of(2012, 7, 27)); |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parse_Query_String_parseError() throws Exception { |
| try { |
| DATE_FORMATTER.parse("ONE2012 07 XX", LocalDate::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("ONE2012 07 XX"), true); |
| assertEquals(ex.getParsedString(), "ONE2012 07 XX"); |
| assertEquals(ex.getErrorIndex(), 11); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parse_Query_String_parseErrorLongText() throws Exception { |
| try { |
| DATE_FORMATTER.parse("ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789", LocalDate::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("ONEXXX6789012345678901234567890123456789012345678901234567890123..."), true); |
| assertEquals(ex.getParsedString(), "ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789"); |
| assertEquals(ex.getErrorIndex(), 3); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parse_Query_String_parseIncomplete() throws Exception { |
| try { |
| DATE_FORMATTER.parse("ONE2012 07 27SomethingElse", LocalDate::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("ONE2012 07 27SomethingElse"), true); |
| assertEquals(ex.getParsedString(), "ONE2012 07 27SomethingElse"); |
| assertEquals(ex.getErrorIndex(), 13); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parse_Query_String_nullText() throws Exception { |
| DATE_FORMATTER.parse((String) null, LocalDate::from); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parse_Query_String_nullRule() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| test.parse("30", (TemporalQuery<?>) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_parseBest_firstOption() throws Exception { |
| DateTimeFormatter test = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm[XXX]"); |
| TemporalAccessor result = test.parseBest("2011-06-30 12:30+03:00", ZonedDateTime::from, LocalDateTime::from); |
| LocalDateTime ldt = LocalDateTime.of(2011, 6, 30, 12, 30); |
| assertEquals(result, ZonedDateTime.of(ldt, ZoneOffset.ofHours(3))); |
| } |
| |
| @Test |
| public void test_parseBest_secondOption() throws Exception { |
| DateTimeFormatter test = DateTimeFormatter.ofPattern("yyyy-MM-dd[ HH:mm[XXX]]"); |
| TemporalAccessor result = test.parseBest("2011-06-30", ZonedDateTime::from, LocalDate::from); |
| assertEquals(result, LocalDate.of(2011, 6, 30)); |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parseBest_String_parseError() throws Exception { |
| DateTimeFormatter test = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm[XXX]"); |
| try { |
| test.parseBest("2011-06-XX", ZonedDateTime::from, LocalDateTime::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("XX"), true); |
| assertEquals(ex.getParsedString(), "2011-06-XX"); |
| assertEquals(ex.getErrorIndex(), 8); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parseBest_String_parseErrorLongText() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| try { |
| test.parseBest("ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789", ZonedDateTime::from, LocalDate::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("ONEXXX6789012345678901234567890123456789012345678901234567890123..."), true); |
| assertEquals(ex.getParsedString(), "ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789"); |
| assertEquals(ex.getErrorIndex(), 3); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=DateTimeParseException.class) |
| public void test_parseBest_String_parseIncomplete() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| try { |
| test.parseBest("ONE30SomethingElse", ZonedDateTime::from, LocalDate::from); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("could not be parsed"), true); |
| assertEquals(ex.getMessage().contains("ONE30SomethingElse"), true); |
| assertEquals(ex.getParsedString(), "ONE30SomethingElse"); |
| assertEquals(ex.getErrorIndex(), 5); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parseBest_String_nullText() throws Exception { |
| 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).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).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).withDecimalStyle(DecimalStyle.STANDARD); |
| test.parseBest("30", LocalDate::from); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_parseUnresolved_StringParsePosition() { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(0); |
| TemporalAccessor result = test.parseUnresolved("ONE30XXX", pos); |
| assertEquals(pos.getIndex(), 5); |
| assertEquals(pos.getErrorIndex(), -1); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| } |
| |
| @Test |
| public void test_parseUnresolved_StringParsePosition_parseError() { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(0); |
| TemporalAccessor result = test.parseUnresolved("ONEXXX", pos); |
| assertEquals(pos.getIndex(), 0); |
| assertEquals(pos.getErrorIndex(), 3); |
| assertEquals(result, null); |
| } |
| |
| @Test |
| public void test_parseUnresolved_StringParsePosition_duplicateFieldSameValue() { |
| DateTimeFormatter test = new DateTimeFormatterBuilder() |
| .appendValue(MONTH_OF_YEAR).appendLiteral('-').appendValue(MONTH_OF_YEAR).toFormatter(); |
| ParsePosition pos = new ParsePosition(3); |
| TemporalAccessor result = test.parseUnresolved("XXX6-6", pos); |
| assertEquals(pos.getIndex(), 6); |
| assertEquals(pos.getErrorIndex(), -1); |
| assertEquals(result.getLong(MONTH_OF_YEAR), 6); |
| } |
| |
| @Test |
| public void test_parseUnresolved_StringParsePosition_duplicateFieldDifferentValue() { |
| DateTimeFormatter test = new DateTimeFormatterBuilder() |
| .appendValue(MONTH_OF_YEAR).appendLiteral('-').appendValue(MONTH_OF_YEAR).toFormatter(); |
| ParsePosition pos = new ParsePosition(3); |
| TemporalAccessor result = test.parseUnresolved("XXX6-7", pos); |
| assertEquals(pos.getIndex(), 3); |
| assertEquals(pos.getErrorIndex(), 5); |
| assertEquals(result, null); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_parseUnresolved_StringParsePosition_nullString() { |
| 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).withDecimalStyle(DecimalStyle.STANDARD); |
| test.parseUnresolved("ONE30", (ParsePosition) null); |
| } |
| |
| @Test(expectedExceptions=IndexOutOfBoundsException.class) |
| public void test_parseUnresolved_StringParsePosition_invalidPosition() { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(6); |
| test.parseUnresolved("ONE30", pos); |
| } |
| |
| //----------------------------------------------------------------------- |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_toFormat_format() throws Exception { |
| 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"); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_toFormat_format_null() throws Exception { |
| 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).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| format.format("Not a Temporal"); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_toFormat_parseObject_String() throws Exception { |
| 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); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| } |
| |
| @Test(expectedExceptions=ParseException.class) |
| public void test_toFormat_parseObject_String_parseError() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| try { |
| format.parseObject("ONEXXX"); |
| } catch (ParseException ex) { |
| assertEquals(ex.getMessage().contains("ONEXXX"), true); |
| assertEquals(ex.getErrorOffset(), 3); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=ParseException.class) |
| public void test_toFormat_parseObject_String_parseErrorLongText() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| try { |
| format.parseObject("ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789"); |
| } catch (DateTimeParseException ex) { |
| assertEquals(ex.getMessage().contains("ONEXXX6789012345678901234567890123456789012345678901234567890123..."), true); |
| assertEquals(ex.getParsedString(), "ONEXXX67890123456789012345678901234567890123456789012345678901234567890123456789"); |
| assertEquals(ex.getErrorIndex(), 3); |
| throw ex; |
| } |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_toFormat_parseObject_String_null() throws Exception { |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| format.parseObject((String) null); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_toFormat_parseObject_StringParsePosition() throws Exception { |
| 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); |
| assertEquals(pos.getIndex(), 5); |
| assertEquals(pos.getErrorIndex(), -1); |
| assertEquals(result.isSupported(DAY_OF_MONTH), true); |
| assertEquals(result.getLong(DAY_OF_MONTH), 30L); |
| } |
| |
| @Test |
| public void test_toFormat_parseObject_StringParsePosition_parseError() throws Exception { |
| 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); |
| assertEquals(pos.getIndex(), 0); // TODO: is this right? |
| assertEquals(pos.getErrorIndex(), 3); |
| assertEquals(result, null); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_toFormat_parseObject_StringParsePosition_nullString() throws Exception { |
| // SimpleDateFormat has this behavior |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| ParsePosition pos = new ParsePosition(0); |
| format.parseObject((String) null, pos); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_toFormat_parseObject_StringParsePosition_nullParsePosition() throws Exception { |
| // SimpleDateFormat has this behavior |
| DateTimeFormatter test = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| Format format = test.toFormat(); |
| format.parseObject("ONE30", (ParsePosition) null); |
| } |
| |
| @Test |
| public void test_toFormat_parseObject_StringParsePosition_invalidPosition_tooBig() throws Exception { |
| // SimpleDateFormat has this behavior |
| DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(6); |
| Format test = dtf.toFormat(); |
| assertNull(test.parseObject("ONE30", pos)); |
| assertTrue(pos.getErrorIndex() >= 0); |
| } |
| |
| @Test |
| public void test_toFormat_parseObject_StringParsePosition_invalidPosition_tooSmall() throws Exception { |
| // SimpleDateFormat throws StringIndexOutOfBoundException |
| DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD); |
| ParsePosition pos = new ParsePosition(-1); |
| Format test = dtf.toFormat(); |
| assertNull(test.parseObject("ONE30", pos)); |
| assertTrue(pos.getErrorIndex() >= 0); |
| } |
| |
| //----------------------------------------------------------------------- |
| @Test |
| public void test_toFormat_Query_format() throws Exception { |
| Format format = BASIC_FORMATTER.toFormat(); |
| String result = format.format(LocalDate.of(2008, 6, 30)); |
| assertEquals(result, "ONE30"); |
| } |
| |
| @Test |
| public void test_toFormat_Query_parseObject_String() throws Exception { |
| Format format = DATE_FORMATTER.toFormat(LocalDate::from); |
| LocalDate result = (LocalDate) format.parseObject("ONE2012 07 27"); |
| assertEquals(result, LocalDate.of(2012, 7, 27)); |
| } |
| |
| @Test(expectedExceptions=ParseException.class) |
| public void test_toFormat_parseObject_StringParsePosition_dateTimeError() throws Exception { |
| Format format = DATE_FORMATTER.toFormat(LocalDate::from); |
| format.parseObject("ONE2012 07 32"); |
| } |
| |
| @Test(expectedExceptions=NullPointerException.class) |
| public void test_toFormat_Query() throws Exception { |
| BASIC_FORMATTER.toFormat(null); |
| } |
| |
| } |
