/*
* 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) 2009-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.MINUTE_OF_HOUR;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
import static org.testng.Assert.assertEquals;
import java.time.LocalDate;
import java.time.YearMonth;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.SignStyle;
import java.time.format.TextStyle;
import java.time.temporal.Temporal;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/**
* Test DateTimeFormatterBuilder.
*/
@Test
public class TCKDateTimeFormatterBuilder {
private DateTimeFormatterBuilder builder;
@BeforeMethod
public void setUp() {
builder = new DateTimeFormatterBuilder();
}
//-----------------------------------------------------------------------
@Test
public void test_toFormatter_empty() throws Exception {
DateTimeFormatter f = builder.toFormatter();
assertEquals(f.format(LocalDate.of(2012, 6, 30)), "");
}
//-----------------------------------------------------------------------
@Test
public void test_parseDefaulting_entireDate() {
DateTimeFormatter f = builder
.parseDefaulting(YEAR, 2012).parseDefaulting(MONTH_OF_YEAR, 6)
.parseDefaulting(DAY_OF_MONTH, 30).toFormatter();
LocalDate parsed = f.parse("", LocalDate::from); // blank string can be parsed
assertEquals(parsed, LocalDate.of(2012, 6, 30));
}
@Test
public void test_parseDefaulting_yearOptionalMonthOptionalDay() {
DateTimeFormatter f = builder
.appendValue(YEAR)
.optionalStart().appendLiteral('-').appendValue(MONTH_OF_YEAR)
.optionalStart().appendLiteral('-').appendValue(DAY_OF_MONTH)
.optionalEnd().optionalEnd()
.parseDefaulting(MONTH_OF_YEAR, 1)
.parseDefaulting(DAY_OF_MONTH, 1).toFormatter();
assertEquals(f.parse("2012", LocalDate::from), LocalDate.of(2012, 1, 1));
assertEquals(f.parse("2012-6", LocalDate::from), LocalDate.of(2012, 6, 1));
assertEquals(f.parse("2012-6-30", LocalDate::from), LocalDate.of(2012, 6, 30));
}
@Test(expectedExceptions = NullPointerException.class)
public void test_parseDefaulting_null() {
builder.parseDefaulting(null, 1);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendValue_1arg_null() throws Exception {
builder.appendValue(null);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendValue_2arg_null() throws Exception {
builder.appendValue(null, 3);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_2arg_widthTooSmall() throws Exception {
builder.appendValue(DAY_OF_MONTH, 0);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_2arg_widthTooBig() throws Exception {
builder.appendValue(DAY_OF_MONTH, 20);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendValue_3arg_nullField() throws Exception {
builder.appendValue(null, 2, 3, SignStyle.NORMAL);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_3arg_minWidthTooSmall() throws Exception {
builder.appendValue(DAY_OF_MONTH, 0, 2, SignStyle.NORMAL);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_3arg_minWidthTooBig() throws Exception {
builder.appendValue(DAY_OF_MONTH, 20, 2, SignStyle.NORMAL);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_3arg_maxWidthTooSmall() throws Exception {
builder.appendValue(DAY_OF_MONTH, 2, 0, SignStyle.NORMAL);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_3arg_maxWidthTooBig() throws Exception {
builder.appendValue(DAY_OF_MONTH, 2, 20, SignStyle.NORMAL);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendValue_3arg_maxWidthMinWidth() throws Exception {
builder.appendValue(DAY_OF_MONTH, 4, 2, SignStyle.NORMAL);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_appendValue_3arg_nullSignStyle() throws Exception {
builder.appendValue(DAY_OF_MONTH, 2, 3, null);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendValueReduced_null() throws Exception {
builder.appendValueReduced(null, 2, 2000);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendFraction_4arg_nullRule() throws Exception {
builder.appendFraction(null, 1, 9, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_invalidRuleNotFixedSet() throws Exception {
builder.appendFraction(DAY_OF_MONTH, 1, 9, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_minTooSmall() throws Exception {
builder.appendFraction(MINUTE_OF_HOUR, -1, 9, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_minTooBig() throws Exception {
builder.appendFraction(MINUTE_OF_HOUR, 10, 9, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_maxTooSmall() throws Exception {
builder.appendFraction(MINUTE_OF_HOUR, 0, -1, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_maxTooBig() throws Exception {
builder.appendFraction(MINUTE_OF_HOUR, 1, 10, false);
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_appendFraction_4arg_maxWidthMinWidth() throws Exception {
builder.appendFraction(MINUTE_OF_HOUR, 9, 3, false);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendText_1arg_null() throws Exception {
builder.appendText(null);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendText_2arg_nullRule() throws Exception {
builder.appendText(null, TextStyle.SHORT);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_appendText_2arg_nullStyle() throws Exception {
builder.appendText(MONTH_OF_YEAR, (TextStyle) null);
}
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendTextMap_nullRule() throws Exception {
builder.appendText(null, new HashMap<>());
}
@Test(expectedExceptions=NullPointerException.class)
public void test_appendTextMap_nullStyle() throws Exception {
builder.appendText(MONTH_OF_YEAR, (Map<Long, String>) null);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@DataProvider(name="offsetPatterns")
Object[][] data_offsetPatterns() {
return new Object[][] {
{"+HH", 2, 0, 0, "+02"},
{"+HH", -2, 0, 0, "-02"},
{"+HH", 2, 30, 0, "+02"},
{"+HH", 2, 0, 45, "+02"},
{"+HH", 2, 30, 45, "+02"},
{"+HHMM", 2, 0, 0, "+0200"},
{"+HHMM", -2, 0, 0, "-0200"},
{"+HHMM", 2, 30, 0, "+0230"},
{"+HHMM", 2, 0, 45, "+0200"},
{"+HHMM", 2, 30, 45, "+0230"},
{"+HH:MM", 2, 0, 0, "+02:00"},
{"+HH:MM", -2, 0, 0, "-02:00"},
{"+HH:MM", 2, 30, 0, "+02:30"},
{"+HH:MM", 2, 0, 45, "+02:00"},
{"+HH:MM", 2, 30, 45, "+02:30"},
{"+HHMMss", 2, 0, 0, "+0200"},
{"+HHMMss", -2, 0, 0, "-0200"},
{"+HHMMss", 2, 30, 0, "+0230"},
{"+HHMMss", 2, 0, 45, "+020045"},
{"+HHMMss", 2, 30, 45, "+023045"},
{"+HH:MM:ss", 2, 0, 0, "+02:00"},
{"+HH:MM:ss", -2, 0, 0, "-02:00"},
{"+HH:MM:ss", 2, 30, 0, "+02:30"},
{"+HH:MM:ss", 2, 0, 45, "+02:00:45"},
{"+HH:MM:ss", 2, 30, 45, "+02:30:45"},
{"+HHMMSS", 2, 0, 0, "+020000"},
{"+HHMMSS", -2, 0, 0, "-020000"},
{"+HHMMSS", 2, 30, 0, "+023000"},
{"+HHMMSS", 2, 0, 45, "+020045"},
{"+HHMMSS", 2, 30, 45, "+023045"},
{"+HH:MM:SS", 2, 0, 0, "+02:00:00"},
{"+HH:MM:SS", -2, 0, 0, "-02:00:00"},
{"+HH:MM:SS", 2, 30, 0, "+02:30:00"},
{"+HH:MM:SS", 2, 0, 45, "+02:00:45"},
{"+HH:MM:SS", 2, 30, 45, "+02:30:45"},
};
}
@Test(dataProvider="offsetPatterns")
public void test_appendOffset_format(String pattern, int h, int m, int s, String expected) throws Exception {
builder.appendOffset(pattern, "Z");
DateTimeFormatter f = builder.toFormatter();
ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(h, m, s);
assertEquals(f.format(offset), expected);
}
@Test(dataProvider="offsetPatterns")
public void test_appendOffset_parse(String pattern, int h, int m, int s, String expected) throws Exception {
builder.appendOffset(pattern, "Z");
DateTimeFormatter f = builder.toFormatter();
ZoneOffset parsed = f.parse(expected, ZoneOffset::from);
assertEquals(f.format(parsed), expected);
}
@DataProvider(name="badOffsetPatterns")
Object[][] data_badOffsetPatterns() {
return new Object[][] {
{"HH"},
{"HHMM"},
{"HH:MM"},
{"HHMMss"},
{"HH:MM:ss"},
{"HHMMSS"},
{"HH:MM:SS"},
{"+H"},
{"+HMM"},
{"+HHM"},
{"+A"},
};
}
@Test(dataProvider="badOffsetPatterns", expectedExceptions=IllegalArgumentException.class)
public void test_appendOffset_badPattern(String pattern) throws Exception {
builder.appendOffset(pattern, "Z");
}
@Test(expectedExceptions=NullPointerException.class)
public void test_appendOffset_3arg_nullText() throws Exception {
builder.appendOffset("+HH:MM", null);
}
@Test(expectedExceptions=NullPointerException.class)
public void test_appendOffset_3arg_nullPattern() throws Exception {
builder.appendOffset(null, "Z");
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@Test(expectedExceptions=NullPointerException.class)
public void test_appendZoneText_1arg_nullText() throws Exception {
builder.appendZoneText(null);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@Test
public void test_padNext_1arg() {
builder.appendValue(MONTH_OF_YEAR).appendLiteral(':').padNext(2).appendValue(DAY_OF_MONTH);
assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2: 1");
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_padNext_1arg_invalidWidth() throws Exception {
builder.padNext(0);
}
//-----------------------------------------------------------------------
@Test
public void test_padNext_2arg_dash() throws Exception {
builder.appendValue(MONTH_OF_YEAR).appendLiteral(':').padNext(2, '-').appendValue(DAY_OF_MONTH);
assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2:-1");
}
@Test(expectedExceptions=IllegalArgumentException.class)
public void test_padNext_2arg_invalidWidth() throws Exception {
builder.padNext(0, '-');
}
//-----------------------------------------------------------------------
@Test
public void test_padOptional() throws Exception {
builder.appendValue(MONTH_OF_YEAR).appendLiteral(':')
.padNext(5).optionalStart().appendValue(DAY_OF_MONTH).optionalEnd()
.appendLiteral(':').appendValue(YEAR);
assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2: 1:2013");
assertEquals(builder.toFormatter().format(YearMonth.of(2013, 2)), "2: :2013");
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@Test(expectedExceptions=IllegalStateException.class)
public void test_optionalEnd_noStart() throws Exception {
builder.optionalEnd();
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
@DataProvider(name="validPatterns")
Object[][] dataValid() {
return new Object[][] {
{"'a'"},
{"''"},
{"'!'"},
{"!"},
{"'#'"},
{"'hello_people,][)('"},
{"'hi'"},
{"'yyyy'"},
{"''''"},
{"'o''clock'"},
{"G"},
{"GG"},
{"GGG"},
{"GGGG"},
{"GGGGG"},
{"y"},
{"yy"},
{"yyy"},
{"yyyy"},
{"yyyyy"},
{"M"},
{"MM"},
{"MMM"},
{"MMMM"},
{"MMMMM"},
{"L"},
{"LL"},
{"LLL"},
{"LLLL"},
{"LLLLL"},
{"D"},
{"DD"},
{"DDD"},
{"d"},
{"dd"},
{"F"},
{"Q"},
{"QQ"},
{"QQQ"},
{"QQQQ"},
{"QQQQQ"},
{"q"},
{"qq"},
{"qqq"},
{"qqqq"},
{"qqqqq"},
{"E"},
{"EE"},
{"EEE"},
{"EEEE"},
{"EEEEE"},
{"e"},
{"ee"},
{"eee"},
{"eeee"},
{"eeeee"},
{"c"},
{"ccc"},
{"cccc"},
{"ccccc"},
{"a"},
{"H"},
{"HH"},
{"K"},
{"KK"},
{"k"},
{"kk"},
{"h"},
{"hh"},
{"m"},
{"mm"},
{"s"},
{"ss"},
{"S"},
{"SS"},
{"SSS"},
{"SSSSSSSSS"},
{"A"},
{"AA"},
{"AAA"},
{"n"},
{"nn"},
{"nnn"},
{"N"},
{"NN"},
{"NNN"},
{"z"},
{"zz"},
{"zzz"},
{"zzzz"},
{"VV"},
{"Z"},
{"ZZ"},
{"ZZZ"},
{"X"},
{"XX"},
{"XXX"},
{"XXXX"},
{"XXXXX"},
{"x"},
{"xx"},
{"xxx"},
{"xxxx"},
{"xxxxx"},
{"ppH"},
{"pppDD"},
{"yyyy[-MM[-dd"},
{"yyyy[-MM[-dd]]"},
{"yyyy[-MM[]-dd]"},
{"yyyy-MM-dd'T'HH:mm:ss.SSS"},
{"e"},
{"w"},
{"ww"},
{"W"},
{"W"},
};
}
@Test(dataProvider="validPatterns")
public void test_appendPattern_valid(String input) throws Exception {
builder.appendPattern(input); // test is for no error here
}
//-----------------------------------------------------------------------
@DataProvider(name="invalidPatterns")
Object[][] dataInvalid() {
return new Object[][] {
{"'"},
{"'hello"},
{"'hel''lo"},
{"'hello''"},
{"{"},
{"}"},
{"{}"},
{"#"},
{"]"},
{"yyyy]"},
{"yyyy]MM"},
{"yyyy[MM]]"},
{"aa"},
{"aaa"},
{"aaaa"},
{"aaaaa"},
{"aaaaaa"},
{"MMMMMM"},
{"QQQQQQ"},
{"qqqqqq"},
{"EEEEEE"},
{"eeeeee"},
{"cc"},
{"cccccc"},
{"ddd"},
{"DDDD"},
{"FF"},
{"FFF"},
{"hhh"},
{"HHH"},
{"kkk"},
{"KKK"},
{"mmm"},
{"sss"},
{"OO"},
{"OOO"},
{"OOOOO"},
{"XXXXXX"},
{"zzzzz"},
{"ZZZZZZ"},
{"RO"},
{"p"},
{"pp"},
{"p:"},
{"f"},
{"ff"},
{"f:"},
{"fy"},
{"fa"},
{"fM"},
{"www"},
{"WW"},
};
}
@Test(dataProvider="invalidPatterns", expectedExceptions=IllegalArgumentException.class)
public void test_appendPattern_invalid(String input) throws Exception {
builder.appendPattern(input); // test is for error here
}
//-----------------------------------------------------------------------
@DataProvider(name="patternPrint")
Object[][] data_patternPrint() {
return new Object[][] {
{"Q", date(2012, 2, 10), "1"},
{"QQ", date(2012, 2, 10), "01"},
{"QQQ", date(2012, 2, 10), "Q1"},
{"QQQQ", date(2012, 2, 10), "1st quarter"},
{"QQQQQ", date(2012, 2, 10), "1"},
};
}
@Test(dataProvider="patternPrint")
public void test_appendPattern_patternPrint(String input, Temporal temporal, String expected) throws Exception {
DateTimeFormatter f = builder.appendPattern(input).toFormatter(Locale.UK);
String test = f.format(temporal);
assertEquals(test, expected);
}
private static Temporal date(int y, int m, int d) {
return LocalDate.of(y, m, d);
}
}