test/java/time/tck/java/time/format/TCKLocalizedFieldParser.java

Print this page




  42  *    and/or other materials provided with the distribution.
  43  *
  44  *  * Neither the name of JSR-310 nor the names of its contributors
  45  *    may be used to endorse or promote products derived from this software
  46  *    without specific prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  49  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  50  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  51  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  52  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  53  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  54  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  55  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  56  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  57  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  58  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  59  */
  60 package tck.java.time.format;
  61 
  62 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
  63 import static java.time.temporal.ChronoField.YEAR;
  64 import static org.testng.Assert.assertEquals;
  65 
  66 import java.text.ParsePosition;
  67 import java.time.LocalDate;
  68 import java.time.format.DateTimeFormatter;
  69 import java.time.format.DateTimeFormatterBuilder;
  70 import java.time.temporal.TemporalAccessor;
  71 import java.time.temporal.TemporalField;
  72 import java.time.temporal.WeekFields;
  73 
  74 import org.testng.annotations.DataProvider;
  75 import org.testng.annotations.Test;
  76 import test.java.time.format.AbstractTestPrinterParser;
  77 
  78 /**
  79  * Test TCKLocalizedFieldParser.
  80  */
  81 @Test(groups={"tck"})
  82 public class TCKLocalizedFieldParser extends AbstractTestPrinterParser {
  83 
  84     //-----------------------------------------------------------------------
  85     @DataProvider(name="FieldPatterns")
  86     Object[][] provider_fieldPatterns() {
  87         return new Object[][] {
  88             {"e",  "6", 0, 1, 6},
  89             {"w",  "3", 0, 1, 3},
  90             {"W",  "29", 0, 2, 29},
  91             {"WW", "29", 0, 2, 29},



  92         };
  93     }
  94 
  95     @Test(dataProvider="FieldPatterns",groups={"tck"})
  96     public void test_parse_textField(String pattern, String text, int pos, int expectedPos, long expectedValue) {
  97         WeekFields weekDef = WeekFields.of(locale);
  98         TemporalField field = null;
  99         switch(pattern.charAt(0)) {
 100             case 'e' :
 101                 field = weekDef.dayOfWeek();
 102                 break;
 103             case 'w':
 104                 field = weekDef.weekOfMonth();
 105                 break;
 106             case 'W':
 107                 field = weekDef.weekOfYear();



 108                 break;
 109             default:
 110                 throw new IllegalStateException("bad format letter from pattern");
 111         }
 112         ParsePosition ppos = new ParsePosition(pos);
 113         DateTimeFormatterBuilder b
 114                 = new DateTimeFormatterBuilder().appendPattern(pattern);
 115         DateTimeFormatter dtf = b.toFormatter(locale);
 116         TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
 117         if (ppos.getErrorIndex() != -1) {
 118             assertEquals(ppos.getErrorIndex(), expectedPos);
 119         } else {
 120             assertEquals(ppos.getIndex(), expectedPos, "Incorrect ending parse position");
 121             long value = parsed.getLong(field);
 122             assertEquals(value, expectedValue, "Value incorrect for " + field);
 123         }
 124     }
 125 
 126    //-----------------------------------------------------------------------
 127     @DataProvider(name="LocalDatePatterns")
 128     Object[][] provider_patternLocalDate() {
 129         return new Object[][] {
 130             {"e w M y",  "1 1 1 2012", 0, 10, LocalDate.of(2012, 1, 1)},
 131             {"e w M y",  "1 2 1 2012", 0, 10, LocalDate.of(2012, 1, 8)},
 132             {"e w M y",  "2 2 1 2012", 0, 10, LocalDate.of(2012, 1, 9)},
 133             {"e w M y",  "3 2 1 2012", 0, 10, LocalDate.of(2012, 1, 10)},
 134             {"e w M y",  "1 3 1 2012", 0, 10, LocalDate.of(2012, 1, 15)},
 135             {"e w M y",  "2 3 1 2012", 0, 10, LocalDate.of(2012, 1, 16)},
 136             {"e w M y",  "6 2 1 2012", 0, 10, LocalDate.of(2012, 1, 13)},
 137             {"e w M y",  "6 2 7 2012", 0, 10, LocalDate.of(2012, 7, 13)},
 138             {"e W y",  "6 29 2012", 0, 9, LocalDate.of(2012, 7, 20)},
 139             {"'Date: 'y-MM', day-of-week: 'e', week-of-month: 'w",
 140                 "Date: 2012-07, day-of-week: 6, week-of-month: 3", 0, 47, LocalDate.of(2012, 7, 20)},
 141             {"'Date: 'y', day-of-week: 'e', week-of-year: 'W",
 142                 "Date: 2012, day-of-week: 6, week-of-year: 29", 0, 44, LocalDate.of(2012, 7, 20)},
 143         };
 144     }
 145 
 146    @Test(dataProvider="LocalDatePatterns",groups={"tck"})
 147     public void test_parse_textLocalDate(String pattern, String text, int pos, int expectedPos, LocalDate expectedValue) {
 148         ParsePosition ppos = new ParsePosition(pos);
 149         DateTimeFormatterBuilder b = new DateTimeFormatterBuilder().appendPattern(pattern);
 150         DateTimeFormatter dtf = b.toFormatter(locale);
 151         TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
 152         if (ppos.getErrorIndex() != -1) {
 153             assertEquals(ppos.getErrorIndex(), expectedPos);
 154         } else {
 155             assertEquals(ppos.getIndex(), expectedPos, "Incorrect ending parse position");
 156             assertEquals(parsed.isSupported(YEAR), true);
 157             assertEquals(parsed.isSupported(WeekFields.of(locale).dayOfWeek()), true);
 158             assertEquals(parsed.isSupported(WeekFields.of(locale).weekOfMonth()) ||
 159                     parsed.isSupported(WeekFields.of(locale).weekOfYear()), true);
 160             // ensure combination resolves into a date
 161             LocalDate result = LocalDate.parse(text, dtf);
 162             assertEquals(result, expectedValue, "LocalDate incorrect for " + pattern);
 163         }
 164     }
 165 





































 166 }


  42  *    and/or other materials provided with the distribution.
  43  *
  44  *  * Neither the name of JSR-310 nor the names of its contributors
  45  *    may be used to endorse or promote products derived from this software
  46  *    without specific prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  49  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  50  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  51  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  52  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  53  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  54  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  55  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  56  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  57  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  58  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  59  */
  60 package tck.java.time.format;
  61 
  62 import static java.time.temporal.ChronoField.YEAR_OF_ERA;

  63 import static org.testng.Assert.assertEquals;
  64 
  65 import java.text.ParsePosition;
  66 import java.time.LocalDate;
  67 import java.time.format.DateTimeFormatter;
  68 import java.time.format.DateTimeFormatterBuilder;
  69 import java.time.temporal.TemporalAccessor;
  70 import java.time.temporal.TemporalField;
  71 import java.time.temporal.WeekFields;
  72 
  73 import org.testng.annotations.DataProvider;
  74 import org.testng.annotations.Test;
  75 import test.java.time.format.AbstractTestPrinterParser;
  76 
  77 /**
  78  * Test TCKLocalizedFieldParser.
  79  */
  80 @Test
  81 public class TCKLocalizedFieldParser extends AbstractTestPrinterParser {
  82 
  83     //-----------------------------------------------------------------------
  84     @DataProvider(name="FieldPatterns")
  85     Object[][] provider_fieldPatterns() {
  86         return new Object[][] {
  87             {"e",  "6", 0, 1, 6},
  88             {"W",  "3", 0, 1, 3},
  89             {"w",  "29", 0, 2, 29},
  90             {"ww", "29", 0, 2, 29},
  91             {"Y", "2013", 0, 4, 2013},
  92             {"YY", "13", 0, 2, 2013},
  93             {"YYYY", "2013", 0, 4, 2013},
  94         };
  95     }
  96 
  97     @Test(dataProvider="FieldPatterns")
  98     public void test_parse_textField(String pattern, String text, int pos, int expectedPos, long expectedValue) {
  99         WeekFields weekDef = WeekFields.of(locale);
 100         TemporalField field = null;
 101         switch(pattern.charAt(0)) {
 102             case 'e' :
 103                 field = weekDef.dayOfWeek();
 104                 break;
 105             case 'w':
 106                 field = weekDef.weekOfWeekBasedYear();
 107                 break;
 108             case 'W':
 109                 field = weekDef.weekOfMonth();
 110                 break;
 111             case 'Y':
 112                 field = weekDef.weekBasedYear();
 113                 break;
 114             default:
 115                 throw new IllegalStateException("bad format letter from pattern");
 116         }
 117         ParsePosition ppos = new ParsePosition(pos);
 118         DateTimeFormatterBuilder b
 119                 = new DateTimeFormatterBuilder().appendPattern(pattern);
 120         DateTimeFormatter dtf = b.toFormatter(locale);
 121         TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
 122         if (ppos.getErrorIndex() != -1) {
 123             assertEquals(ppos.getErrorIndex(), expectedPos);
 124         } else {
 125             assertEquals(ppos.getIndex(), expectedPos, "Incorrect ending parse position");
 126             long value = parsed.getLong(field);
 127             assertEquals(value, expectedValue, "Value incorrect for " + field);
 128         }
 129     }
 130 
 131     //-----------------------------------------------------------------------
 132     @DataProvider(name="LocalWeekMonthYearPatterns")
 133     Object[][] provider_patternLocalDate() {
 134         return new Object[][] {
 135             {"e W M y",  "1 1 1 2012", 0, 10, LocalDate.of(2012, 1, 1)},
 136             {"e W M y",  "1 2 1 2012", 0, 10, LocalDate.of(2012, 1, 8)},
 137             {"e W M y",  "2 2 1 2012", 0, 10, LocalDate.of(2012, 1, 9)},
 138             {"e W M y",  "3 2 1 2012", 0, 10, LocalDate.of(2012, 1, 10)},
 139             {"e W M y",  "1 3 1 2012", 0, 10, LocalDate.of(2012, 1, 15)},
 140             {"e W M y",  "2 3 1 2012", 0, 10, LocalDate.of(2012, 1, 16)},
 141             {"e W M y",  "6 2 1 2012", 0, 10, LocalDate.of(2012, 1, 13)},
 142             {"e W M y",  "6 2 7 2012", 0, 10, LocalDate.of(2012, 7, 13)},
 143             {"'Date: 'y-MM', day-of-week: 'e', week-of-month: 'W",

 144                 "Date: 2012-07, day-of-week: 6, week-of-month: 3", 0, 47, LocalDate.of(2012, 7, 20)},


 145         };
 146     }
 147 
 148    @Test(dataProvider="LocalWeekMonthYearPatterns")
 149     public void test_parse_textLocalDate(String pattern, String text, int pos, int expectedPos, LocalDate expectedValue) {
 150         ParsePosition ppos = new ParsePosition(pos);
 151         DateTimeFormatterBuilder b = new DateTimeFormatterBuilder().appendPattern(pattern);
 152         DateTimeFormatter dtf = b.toFormatter(locale);
 153         TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
 154         if (ppos.getErrorIndex() != -1) {
 155             assertEquals(ppos.getErrorIndex(), expectedPos);
 156         } else {
 157             assertEquals(ppos.getIndex(), expectedPos, "Incorrect ending parse position");
 158             assertEquals(parsed.isSupported(YEAR_OF_ERA), true);
 159             assertEquals(parsed.isSupported(WeekFields.of(locale).dayOfWeek()), true);
 160             assertEquals(parsed.isSupported(WeekFields.of(locale).weekOfMonth()) ||
 161                     parsed.isSupported(WeekFields.of(locale).weekOfYear()), true);
 162             // ensure combination resolves into a date
 163             LocalDate result = LocalDate.parse(text, dtf);
 164             assertEquals(result, expectedValue, "LocalDate incorrect for " + pattern);
 165         }
 166     }
 167 
 168     //-----------------------------------------------------------------------
 169     @DataProvider(name="LocalWeekBasedYearPatterns")
 170     Object[][] provider_patternLocalWeekBasedYearDate() {
 171         return new Object[][] {
 172             //{"w Y",  "29 2012", 0, 7, LocalDate.of(2012, 7, 20)},  // Default lenient dayOfWeek not supported
 173             {"e w Y",  "6 29 2012", 0, 9, LocalDate.of(2012, 7, 20)},
 174             {"'Date: 'Y', day-of-week: 'e', week-of-year: 'w",
 175                 "Date: 2012, day-of-week: 6, week-of-year: 29", 0, 44, LocalDate.of(2012, 7, 20)},
 176             {"Y-w-e",  "2008-01-1", 0, 9, LocalDate.of(2007, 12, 30)},
 177             {"Y-w-e",  "2008-52-1", 0, 9, LocalDate.of(2008, 12, 21)},
 178             {"Y-w-e",  "2008-52-7", 0, 9, LocalDate.of(2008, 12, 27)},
 179             {"Y-w-e",  "2009-01-01", 0, 10, LocalDate.of(2008, 12, 28)},
 180             {"Y-w-e",  "2009-01-04", 0, 10, LocalDate.of(2008, 12, 31)},
 181             {"Y-w-e",  "2009-01-05", 0, 10, LocalDate.of(2009, 1, 1)},
 182        };
 183     }
 184 
 185    @Test(dataProvider="LocalWeekBasedYearPatterns")
 186     public void test_parse_WeekBasedYear(String pattern, String text, int pos, int expectedPos, LocalDate expectedValue) {
 187         ParsePosition ppos = new ParsePosition(pos);
 188         DateTimeFormatterBuilder b = new DateTimeFormatterBuilder().appendPattern(pattern);
 189         DateTimeFormatter dtf = b.toFormatter(locale);
 190         TemporalAccessor parsed = dtf.parseUnresolved(text, ppos);
 191         if (ppos.getErrorIndex() != -1) {
 192             assertEquals(ppos.getErrorIndex(), expectedPos);
 193         } else {
 194             WeekFields weekDef = WeekFields.of(locale);
 195             assertEquals(ppos.getIndex(), expectedPos, "Incorrect ending parse position");
 196             assertEquals(parsed.isSupported(weekDef.dayOfWeek()), pattern.indexOf('e') >= 0);
 197             assertEquals(parsed.isSupported(weekDef.weekOfWeekBasedYear()), pattern.indexOf('w') >= 0);
 198             assertEquals(parsed.isSupported(weekDef.weekBasedYear()), pattern.indexOf('Y') >= 0);
 199             // ensure combination resolves into a date
 200             LocalDate result = LocalDate.parse(text, dtf);
 201             assertEquals(result, expectedValue, "LocalDate incorrect for " + pattern + ", weekDef: " + weekDef);
 202         }
 203     }
 204 
 205 }