1 /*
   2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * This file is available under and governed by the GNU General Public
  26  * License version 2 only, as published by the Free Software Foundation.
  27  * However, the following notice accompanied the original version of this
  28  * file:
  29  *
  30  * Copyright (c) 2009-2012, Stephen Colebourne & Michael Nascimento Santos
  31  *
  32  * All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions are met:
  36  *
  37  *  * Redistributions of source code must retain the above copyright notice,
  38  *    this list of conditions and the following disclaimer.
  39  *
  40  *  * Redistributions in binary form must reproduce the above copyright notice,
  41  *    this list of conditions and the following disclaimer in the documentation
  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.DAY_OF_MONTH;
  63 import static java.time.temporal.ChronoField.HOUR_OF_DAY;
  64 import static java.time.temporal.ChronoField.MINUTE_OF_HOUR;
  65 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
  66 import static java.time.temporal.ChronoField.NANO_OF_SECOND;
  67 import static java.time.temporal.ChronoField.YEAR;
  68 import static org.testng.Assert.assertEquals;
  69 
  70 import java.text.ParsePosition;
  71 import java.time.LocalDate;
  72 import java.time.YearMonth;
  73 import java.time.ZoneOffset;
  74 import java.time.format.DateTimeFormatter;
  75 import java.time.format.DateTimeFormatterBuilder;
  76 import java.time.format.SignStyle;
  77 import java.time.format.TextStyle;
  78 import java.time.temporal.Temporal;
  79 import java.time.temporal.TemporalAccessor;
  80 import java.util.HashMap;
  81 import java.util.Locale;
  82 import java.util.Map;
  83 
  84 import org.testng.annotations.BeforeMethod;
  85 import org.testng.annotations.DataProvider;
  86 import org.testng.annotations.Test;
  87 
  88 /**
  89  * Test DateTimeFormatterBuilder.
  90  */
  91 @Test
  92 public class TCKDateTimeFormatterBuilder {
  93 
  94     private DateTimeFormatterBuilder builder;
  95 
  96     @BeforeMethod
  97     public void setUp() {
  98         builder = new DateTimeFormatterBuilder();
  99     }
 100 
 101     //-----------------------------------------------------------------------
 102     @Test
 103     public void test_toFormatter_empty() throws Exception {
 104         DateTimeFormatter f = builder.toFormatter();
 105         assertEquals(f.format(LocalDate.of(2012, 6, 30)), "");
 106     }
 107 
 108     //-----------------------------------------------------------------------
 109     @Test
 110     public void test_parseDefaulting_entireDate() {
 111         DateTimeFormatter f = builder
 112             .parseDefaulting(YEAR, 2012).parseDefaulting(MONTH_OF_YEAR, 6)
 113             .parseDefaulting(DAY_OF_MONTH, 30).toFormatter();
 114         LocalDate parsed = f.parse("", LocalDate::from);  // blank string can be parsed
 115         assertEquals(parsed, LocalDate.of(2012, 6, 30));
 116     }
 117 
 118     @Test
 119     public void test_parseDefaulting_yearOptionalMonthOptionalDay() {
 120         DateTimeFormatter f = builder
 121                 .appendValue(YEAR)
 122                 .optionalStart().appendLiteral('-').appendValue(MONTH_OF_YEAR)
 123                 .optionalStart().appendLiteral('-').appendValue(DAY_OF_MONTH)
 124                 .optionalEnd().optionalEnd()
 125                 .parseDefaulting(MONTH_OF_YEAR, 1)
 126                 .parseDefaulting(DAY_OF_MONTH, 1).toFormatter();
 127         assertEquals(f.parse("2012", LocalDate::from), LocalDate.of(2012, 1, 1));
 128         assertEquals(f.parse("2012-6", LocalDate::from), LocalDate.of(2012, 6, 1));
 129         assertEquals(f.parse("2012-6-30", LocalDate::from), LocalDate.of(2012, 6, 30));
 130     }
 131 
 132     @Test(expectedExceptions = NullPointerException.class)
 133     public void test_parseDefaulting_null() {
 134         builder.parseDefaulting(null, 1);
 135     }
 136 
 137     //-----------------------------------------------------------------------
 138     @Test(expectedExceptions=NullPointerException.class)
 139     public void test_appendValue_1arg_null() throws Exception {
 140         builder.appendValue(null);
 141     }
 142 
 143     //-----------------------------------------------------------------------
 144     @Test(expectedExceptions=NullPointerException.class)
 145     public void test_appendValue_2arg_null() throws Exception {
 146         builder.appendValue(null, 3);
 147     }
 148 
 149     @Test(expectedExceptions=IllegalArgumentException.class)
 150     public void test_appendValue_2arg_widthTooSmall() throws Exception {
 151         builder.appendValue(DAY_OF_MONTH, 0);
 152     }
 153 
 154     @Test(expectedExceptions=IllegalArgumentException.class)
 155     public void test_appendValue_2arg_widthTooBig() throws Exception {
 156         builder.appendValue(DAY_OF_MONTH, 20);
 157     }
 158 
 159     //-----------------------------------------------------------------------
 160     @Test(expectedExceptions=NullPointerException.class)
 161     public void test_appendValue_3arg_nullField() throws Exception {
 162         builder.appendValue(null, 2, 3, SignStyle.NORMAL);
 163     }
 164 
 165     @Test(expectedExceptions=IllegalArgumentException.class)
 166     public void test_appendValue_3arg_minWidthTooSmall() throws Exception {
 167         builder.appendValue(DAY_OF_MONTH, 0, 2, SignStyle.NORMAL);
 168     }
 169 
 170     @Test(expectedExceptions=IllegalArgumentException.class)
 171     public void test_appendValue_3arg_minWidthTooBig() throws Exception {
 172         builder.appendValue(DAY_OF_MONTH, 20, 2, SignStyle.NORMAL);
 173     }
 174 
 175     @Test(expectedExceptions=IllegalArgumentException.class)
 176     public void test_appendValue_3arg_maxWidthTooSmall() throws Exception {
 177         builder.appendValue(DAY_OF_MONTH, 2, 0, SignStyle.NORMAL);
 178     }
 179 
 180     @Test(expectedExceptions=IllegalArgumentException.class)
 181     public void test_appendValue_3arg_maxWidthTooBig() throws Exception {
 182         builder.appendValue(DAY_OF_MONTH, 2, 20, SignStyle.NORMAL);
 183     }
 184 
 185     @Test(expectedExceptions=IllegalArgumentException.class)
 186     public void test_appendValue_3arg_maxWidthMinWidth() throws Exception {
 187         builder.appendValue(DAY_OF_MONTH, 4, 2, SignStyle.NORMAL);
 188     }
 189 
 190     @Test(expectedExceptions=NullPointerException.class)
 191     public void test_appendValue_3arg_nullSignStyle() throws Exception {
 192         builder.appendValue(DAY_OF_MONTH, 2, 3, null);
 193     }
 194 
 195     //-----------------------------------------------------------------------
 196     @Test(expectedExceptions=NullPointerException.class)
 197     public void test_appendValueReduced_int_nullField() throws Exception {
 198         builder.appendValueReduced(null, 2, 2, 2000);
 199     }
 200 
 201     @Test(expectedExceptions=IllegalArgumentException.class)
 202     public void test_appendValueReduced_int_minWidthTooSmall() throws Exception {
 203         builder.appendValueReduced(YEAR, 0, 2, 2000);
 204     }
 205 
 206     @Test(expectedExceptions=IllegalArgumentException.class)
 207     public void test_appendValueReduced_int_minWidthTooBig() throws Exception {
 208         builder.appendValueReduced(YEAR, 11, 2, 2000);
 209     }
 210 
 211     @Test(expectedExceptions=IllegalArgumentException.class)
 212     public void test_appendValueReduced_int_maxWidthTooSmall() throws Exception {
 213         builder.appendValueReduced(YEAR, 2, 0, 2000);
 214     }
 215 
 216     @Test(expectedExceptions=IllegalArgumentException.class)
 217     public void test_appendValueReduced_int_maxWidthTooBig() throws Exception {
 218         builder.appendValueReduced(YEAR, 2, 11, 2000);
 219     }
 220 
 221     @Test(expectedExceptions=IllegalArgumentException.class)
 222     public void test_appendValueReduced_int_maxWidthLessThanMin() throws Exception {
 223         builder.appendValueReduced(YEAR, 2, 1, 2000);
 224     }
 225 
 226     //-----------------------------------------------------------------------
 227     @Test(expectedExceptions=NullPointerException.class)
 228     public void test_appendValueReduced_date_nullField() throws Exception {
 229         builder.appendValueReduced(null, 2, 2, LocalDate.of(2000, 1, 1));
 230     }
 231 
 232     @Test(expectedExceptions=NullPointerException.class)
 233     public void test_appendValueReduced_date_nullDate() throws Exception {
 234         builder.appendValueReduced(YEAR, 2, 2, null);
 235     }
 236 
 237     @Test(expectedExceptions=IllegalArgumentException.class)
 238     public void test_appendValueReduced_date_minWidthTooSmall() throws Exception {
 239         builder.appendValueReduced(YEAR, 0, 2, LocalDate.of(2000, 1, 1));
 240     }
 241 
 242     @Test(expectedExceptions=IllegalArgumentException.class)
 243     public void test_appendValueReduced_date_minWidthTooBig() throws Exception {
 244         builder.appendValueReduced(YEAR, 11, 2, LocalDate.of(2000, 1, 1));
 245     }
 246 
 247     @Test(expectedExceptions=IllegalArgumentException.class)
 248     public void test_appendValueReduced_date_maxWidthTooSmall() throws Exception {
 249         builder.appendValueReduced(YEAR, 2, 0, LocalDate.of(2000, 1, 1));
 250     }
 251 
 252     @Test(expectedExceptions=IllegalArgumentException.class)
 253     public void test_appendValueReduced_date_maxWidthTooBig() throws Exception {
 254         builder.appendValueReduced(YEAR, 2, 11, LocalDate.of(2000, 1, 1));
 255     }
 256 
 257     @Test(expectedExceptions=IllegalArgumentException.class)
 258     public void test_appendValueReduced_date_maxWidthLessThanMin() throws Exception {
 259         builder.appendValueReduced(YEAR, 2, 1, LocalDate.of(2000, 1, 1));
 260     }
 261 
 262     //-----------------------------------------------------------------------
 263     //-----------------------------------------------------------------------
 264     //-----------------------------------------------------------------------
 265     @Test(expectedExceptions=NullPointerException.class)
 266     public void test_appendFraction_4arg_nullRule() throws Exception {
 267         builder.appendFraction(null, 1, 9, false);
 268     }
 269 
 270     @Test(expectedExceptions=IllegalArgumentException.class)
 271     public void test_appendFraction_4arg_invalidRuleNotFixedSet() throws Exception {
 272         builder.appendFraction(DAY_OF_MONTH, 1, 9, false);
 273     }
 274 
 275     @Test(expectedExceptions=IllegalArgumentException.class)
 276     public void test_appendFraction_4arg_minTooSmall() throws Exception {
 277         builder.appendFraction(MINUTE_OF_HOUR, -1, 9, false);
 278     }
 279 
 280     @Test(expectedExceptions=IllegalArgumentException.class)
 281     public void test_appendFraction_4arg_minTooBig() throws Exception {
 282         builder.appendFraction(MINUTE_OF_HOUR, 10, 9, false);
 283     }
 284 
 285     @Test(expectedExceptions=IllegalArgumentException.class)
 286     public void test_appendFraction_4arg_maxTooSmall() throws Exception {
 287         builder.appendFraction(MINUTE_OF_HOUR, 0, -1, false);
 288     }
 289 
 290     @Test(expectedExceptions=IllegalArgumentException.class)
 291     public void test_appendFraction_4arg_maxTooBig() throws Exception {
 292         builder.appendFraction(MINUTE_OF_HOUR, 1, 10, false);
 293     }
 294 
 295     @Test(expectedExceptions=IllegalArgumentException.class)
 296     public void test_appendFraction_4arg_maxWidthMinWidth() throws Exception {
 297         builder.appendFraction(MINUTE_OF_HOUR, 9, 3, false);
 298     }
 299 
 300     //-----------------------------------------------------------------------
 301     //-----------------------------------------------------------------------
 302     //-----------------------------------------------------------------------
 303     @Test(expectedExceptions=NullPointerException.class)
 304     public void test_appendText_1arg_null() throws Exception {
 305         builder.appendText(null);
 306     }
 307 
 308     //-----------------------------------------------------------------------
 309     @Test(expectedExceptions=NullPointerException.class)
 310     public void test_appendText_2arg_nullRule() throws Exception {
 311         builder.appendText(null, TextStyle.SHORT);
 312     }
 313 
 314     @Test(expectedExceptions=NullPointerException.class)
 315     public void test_appendText_2arg_nullStyle() throws Exception {
 316         builder.appendText(MONTH_OF_YEAR, (TextStyle) null);
 317     }
 318 
 319     //-----------------------------------------------------------------------
 320     @Test(expectedExceptions=NullPointerException.class)
 321     public void test_appendTextMap_nullRule() throws Exception {
 322         builder.appendText(null, new HashMap<>());
 323     }
 324 
 325     @Test(expectedExceptions=NullPointerException.class)
 326     public void test_appendTextMap_nullStyle() throws Exception {
 327         builder.appendText(MONTH_OF_YEAR, (Map<Long, String>) null);
 328     }
 329 
 330     //-----------------------------------------------------------------------
 331     //-----------------------------------------------------------------------
 332     //-----------------------------------------------------------------------
 333     @DataProvider(name="offsetPatterns")
 334     Object[][] data_offsetPatterns() {
 335         return new Object[][] {
 336                 {"+HH", 2, 0, 0, "+02"},
 337                 {"+HH", -2, 0, 0, "-02"},
 338                 {"+HH", 2, 30, 0, "+02"},
 339                 {"+HH", 2, 0, 45, "+02"},
 340                 {"+HH", 2, 30, 45, "+02"},
 341 
 342                 {"+HHMM", 2, 0, 0, "+0200"},
 343                 {"+HHMM", -2, 0, 0, "-0200"},
 344                 {"+HHMM", 2, 30, 0, "+0230"},
 345                 {"+HHMM", 2, 0, 45, "+0200"},
 346                 {"+HHMM", 2, 30, 45, "+0230"},
 347 
 348                 {"+HH:MM", 2, 0, 0, "+02:00"},
 349                 {"+HH:MM", -2, 0, 0, "-02:00"},
 350                 {"+HH:MM", 2, 30, 0, "+02:30"},
 351                 {"+HH:MM", 2, 0, 45, "+02:00"},
 352                 {"+HH:MM", 2, 30, 45, "+02:30"},
 353 
 354                 {"+HHMMss", 2, 0, 0, "+0200"},
 355                 {"+HHMMss", -2, 0, 0, "-0200"},
 356                 {"+HHMMss", 2, 30, 0, "+0230"},
 357                 {"+HHMMss", 2, 0, 45, "+020045"},
 358                 {"+HHMMss", 2, 30, 45, "+023045"},
 359 
 360                 {"+HH:MM:ss", 2, 0, 0, "+02:00"},
 361                 {"+HH:MM:ss", -2, 0, 0, "-02:00"},
 362                 {"+HH:MM:ss", 2, 30, 0, "+02:30"},
 363                 {"+HH:MM:ss", 2, 0, 45, "+02:00:45"},
 364                 {"+HH:MM:ss", 2, 30, 45, "+02:30:45"},
 365 
 366                 {"+HHMMSS", 2, 0, 0, "+020000"},
 367                 {"+HHMMSS", -2, 0, 0, "-020000"},
 368                 {"+HHMMSS", 2, 30, 0, "+023000"},
 369                 {"+HHMMSS", 2, 0, 45, "+020045"},
 370                 {"+HHMMSS", 2, 30, 45, "+023045"},
 371 
 372                 {"+HH:MM:SS", 2, 0, 0, "+02:00:00"},
 373                 {"+HH:MM:SS", -2, 0, 0, "-02:00:00"},
 374                 {"+HH:MM:SS", 2, 30, 0, "+02:30:00"},
 375                 {"+HH:MM:SS", 2, 0, 45, "+02:00:45"},
 376                 {"+HH:MM:SS", 2, 30, 45, "+02:30:45"},
 377         };
 378     }
 379 
 380     @Test(dataProvider="offsetPatterns")
 381     public void test_appendOffset_format(String pattern, int h, int m, int s, String expected) throws Exception {
 382         builder.appendOffset(pattern, "Z");
 383         DateTimeFormatter f = builder.toFormatter();
 384         ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(h, m, s);
 385         assertEquals(f.format(offset), expected);
 386     }
 387 
 388     @Test(dataProvider="offsetPatterns")
 389     public void test_appendOffset_parse(String pattern, int h, int m, int s, String expected) throws Exception {
 390         builder.appendOffset(pattern, "Z");
 391         DateTimeFormatter f = builder.toFormatter();
 392         ZoneOffset parsed = f.parse(expected, ZoneOffset::from);
 393         assertEquals(f.format(parsed), expected);
 394     }
 395 
 396     @DataProvider(name="badOffsetPatterns")
 397     Object[][] data_badOffsetPatterns() {
 398         return new Object[][] {
 399             {"HH"},
 400             {"HHMM"},
 401             {"HH:MM"},
 402             {"HHMMss"},
 403             {"HH:MM:ss"},
 404             {"HHMMSS"},
 405             {"HH:MM:SS"},
 406             {"+H"},
 407             {"+HMM"},
 408             {"+HHM"},
 409             {"+A"},
 410         };
 411     }
 412 
 413     @Test(dataProvider="badOffsetPatterns", expectedExceptions=IllegalArgumentException.class)
 414     public void test_appendOffset_badPattern(String pattern) throws Exception {
 415         builder.appendOffset(pattern, "Z");
 416     }
 417 
 418     @Test(expectedExceptions=NullPointerException.class)
 419     public void test_appendOffset_3arg_nullText() throws Exception {
 420         builder.appendOffset("+HH:MM", null);
 421     }
 422 
 423     @Test(expectedExceptions=NullPointerException.class)
 424     public void test_appendOffset_3arg_nullPattern() throws Exception {
 425         builder.appendOffset(null, "Z");
 426     }
 427 
 428     //-----------------------------------------------------------------------
 429     //-----------------------------------------------------------------------
 430     //-----------------------------------------------------------------------
 431     @Test(expectedExceptions=NullPointerException.class)
 432     public void test_appendZoneText_1arg_nullText() throws Exception {
 433         builder.appendZoneText(null);
 434     }
 435 
 436     //-----------------------------------------------------------------------
 437     //-----------------------------------------------------------------------
 438     //-----------------------------------------------------------------------
 439     @Test
 440     public void test_padNext_1arg() {
 441         builder.appendValue(MONTH_OF_YEAR).appendLiteral(':').padNext(2).appendValue(DAY_OF_MONTH);
 442         assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2: 1");
 443     }
 444 
 445     @Test(expectedExceptions=IllegalArgumentException.class)
 446     public void test_padNext_1arg_invalidWidth() throws Exception {
 447         builder.padNext(0);
 448     }
 449 
 450     //-----------------------------------------------------------------------
 451     @Test
 452     public void test_padNext_2arg_dash() throws Exception {
 453         builder.appendValue(MONTH_OF_YEAR).appendLiteral(':').padNext(2, '-').appendValue(DAY_OF_MONTH);
 454         assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2:-1");
 455     }
 456 
 457     @Test(expectedExceptions=IllegalArgumentException.class)
 458     public void test_padNext_2arg_invalidWidth() throws Exception {
 459         builder.padNext(0, '-');
 460     }
 461 
 462     //-----------------------------------------------------------------------
 463     @Test
 464     public void test_padOptional() throws Exception {
 465         builder.appendValue(MONTH_OF_YEAR).appendLiteral(':')
 466                 .padNext(5).optionalStart().appendValue(DAY_OF_MONTH).optionalEnd()
 467                 .appendLiteral(':').appendValue(YEAR);
 468         assertEquals(builder.toFormatter().format(LocalDate.of(2013, 2, 1)), "2:    1:2013");
 469         assertEquals(builder.toFormatter().format(YearMonth.of(2013, 2)), "2:     :2013");
 470     }
 471 
 472     //-----------------------------------------------------------------------
 473     //-----------------------------------------------------------------------
 474     //-----------------------------------------------------------------------
 475     @Test(expectedExceptions=IllegalStateException.class)
 476     public void test_optionalEnd_noStart() throws Exception {
 477         builder.optionalEnd();
 478     }
 479 
 480     //-----------------------------------------------------------------------
 481     //-----------------------------------------------------------------------
 482     //-----------------------------------------------------------------------
 483     @DataProvider(name="validPatterns")
 484     Object[][] dataValid() {
 485         return new Object[][] {
 486             {"'a'"},
 487             {"''"},
 488             {"'!'"},
 489             {"!"},
 490             {"'#'"},
 491 
 492             {"'hello_people,][)('"},
 493             {"'hi'"},
 494             {"'yyyy'"},
 495             {"''''"},
 496             {"'o''clock'"},
 497 
 498             {"G"},
 499             {"GG"},
 500             {"GGG"},
 501             {"GGGG"},
 502             {"GGGGG"},
 503 
 504             {"y"},
 505             {"yy"},
 506             {"yyy"},
 507             {"yyyy"},
 508             {"yyyyy"},
 509 
 510             {"M"},
 511             {"MM"},
 512             {"MMM"},
 513             {"MMMM"},
 514             {"MMMMM"},
 515 
 516             {"L"},
 517             {"LL"},
 518             {"LLL"},
 519             {"LLLL"},
 520             {"LLLLL"},
 521 
 522             {"D"},
 523             {"DD"},
 524             {"DDD"},
 525 
 526             {"d"},
 527             {"dd"},
 528 
 529             {"F"},
 530 
 531             {"Q"},
 532             {"QQ"},
 533             {"QQQ"},
 534             {"QQQQ"},
 535             {"QQQQQ"},
 536 
 537             {"q"},
 538             {"qq"},
 539             {"qqq"},
 540             {"qqqq"},
 541             {"qqqqq"},
 542 
 543             {"E"},
 544             {"EE"},
 545             {"EEE"},
 546             {"EEEE"},
 547             {"EEEEE"},
 548 
 549             {"e"},
 550             {"ee"},
 551             {"eee"},
 552             {"eeee"},
 553             {"eeeee"},
 554 
 555             {"c"},
 556             {"ccc"},
 557             {"cccc"},
 558             {"ccccc"},
 559 
 560             {"a"},
 561 
 562             {"H"},
 563             {"HH"},
 564 
 565             {"K"},
 566             {"KK"},
 567 
 568             {"k"},
 569             {"kk"},
 570 
 571             {"h"},
 572             {"hh"},
 573 
 574             {"m"},
 575             {"mm"},
 576 
 577             {"s"},
 578             {"ss"},
 579 
 580             {"S"},
 581             {"SS"},
 582             {"SSS"},
 583             {"SSSSSSSSS"},
 584 
 585             {"A"},
 586             {"AA"},
 587             {"AAA"},
 588 
 589             {"n"},
 590             {"nn"},
 591             {"nnn"},
 592 
 593             {"N"},
 594             {"NN"},
 595             {"NNN"},
 596 
 597             {"z"},
 598             {"zz"},
 599             {"zzz"},
 600             {"zzzz"},
 601 
 602             {"VV"},
 603 
 604             {"Z"},
 605             {"ZZ"},
 606             {"ZZZ"},
 607 
 608             {"X"},
 609             {"XX"},
 610             {"XXX"},
 611             {"XXXX"},
 612             {"XXXXX"},
 613 
 614             {"x"},
 615             {"xx"},
 616             {"xxx"},
 617             {"xxxx"},
 618             {"xxxxx"},
 619 
 620             {"ppH"},
 621             {"pppDD"},
 622 
 623             {"yyyy[-MM[-dd"},
 624             {"yyyy[-MM[-dd]]"},
 625             {"yyyy[-MM[]-dd]"},
 626 
 627             {"yyyy-MM-dd'T'HH:mm:ss.SSS"},
 628 
 629             {"e"},
 630             {"w"},
 631             {"ww"},
 632             {"W"},
 633             {"W"},
 634 


 635         };
 636     }
 637 
 638     @Test(dataProvider="validPatterns")
 639     public void test_appendPattern_valid(String input) throws Exception {
 640         builder.appendPattern(input);  // test is for no error here
 641     }
 642 
 643     //-----------------------------------------------------------------------
 644     @DataProvider(name="invalidPatterns")
 645     Object[][] dataInvalid() {
 646         return new Object[][] {
 647             {"'"},
 648             {"'hello"},
 649             {"'hel''lo"},
 650             {"'hello''"},
 651             {"{"},
 652             {"}"},
 653             {"{}"},
 654             {"#"},
 655             {"]"},
 656             {"yyyy]"},
 657             {"yyyy]MM"},
 658             {"yyyy[MM]]"},
 659 
 660             {"aa"},
 661             {"aaa"},
 662             {"aaaa"},
 663             {"aaaaa"},
 664             {"aaaaaa"},
 665             {"MMMMMM"},
 666             {"QQQQQQ"},
 667             {"qqqqqq"},
 668             {"EEEEEE"},
 669             {"eeeeee"},
 670             {"cc"},
 671             {"cccccc"},
 672             {"ddd"},
 673             {"DDDD"},
 674             {"FF"},
 675             {"FFF"},
 676             {"hhh"},
 677             {"HHH"},
 678             {"kkk"},
 679             {"KKK"},
 680             {"mmm"},
 681             {"sss"},
 682             {"OO"},
 683             {"OOO"},
 684             {"OOOOO"},
 685             {"XXXXXX"},
 686             {"zzzzz"},
 687             {"ZZZZZZ"},
 688 
 689             {"RO"},
 690 
 691             {"p"},
 692             {"pp"},
 693             {"p:"},
 694 
 695             {"f"},
 696             {"ff"},
 697             {"f:"},
 698             {"fy"},
 699             {"fa"},
 700             {"fM"},
 701 
 702             {"www"},
 703             {"WW"},
 704         };
 705     }
 706 
 707     @Test(dataProvider="invalidPatterns", expectedExceptions=IllegalArgumentException.class)
 708     public void test_appendPattern_invalid(String input) throws Exception {
 709         builder.appendPattern(input);  // test is for error here
 710     }
 711 
 712     //-----------------------------------------------------------------------
 713     @DataProvider(name="patternPrint")
 714     Object[][] data_patternPrint() {
 715         return new Object[][] {
 716             {"Q", date(2012, 2, 10), "1"},
 717             {"QQ", date(2012, 2, 10), "01"},
 718             {"QQQ", date(2012, 2, 10), "Q1"},
 719             {"QQQQ", date(2012, 2, 10), "1st quarter"},
 720             {"QQQQQ", date(2012, 2, 10), "1"},
 721         };
 722     }
 723 
 724     @Test(dataProvider="patternPrint")
 725     public void test_appendPattern_patternPrint(String input, Temporal temporal, String expected) throws Exception {
 726         DateTimeFormatter f = builder.appendPattern(input).toFormatter(Locale.UK);
 727         String test = f.format(temporal);
 728         assertEquals(test, expected);
 729     }
 730 
 731     private static Temporal date(int y, int m, int d) {
 732         return LocalDate.of(y, m, d);
 733     }
 734 
 735     //-----------------------------------------------------------------------































 736     @Test
 737     public void test_adjacent_strict_firstFixedWidth() throws Exception {
 738         // succeeds because both number elements are fixed width
 739         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('9').toFormatter(Locale.UK);
 740         ParsePosition pp = new ParsePosition(0);
 741         TemporalAccessor parsed = f.parseUnresolved("12309", pp);
 742         assertEquals(pp.getErrorIndex(), -1);
 743         assertEquals(pp.getIndex(), 5);
 744         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 745         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 746     }
 747 
 748     @Test
 749     public void test_adjacent_strict_firstVariableWidth_success() throws Exception {
 750         // succeeds greedily parsing variable width, then fixed width, to non-numeric Z
 751         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('Z').toFormatter(Locale.UK);
 752         ParsePosition pp = new ParsePosition(0);
 753         TemporalAccessor parsed = f.parseUnresolved("12309Z", pp);
 754         assertEquals(pp.getErrorIndex(), -1);
 755         assertEquals(pp.getIndex(), 6);
 756         assertEquals(parsed.getLong(HOUR_OF_DAY), 123L);
 757         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 9L);
 758     }
 759 
 760     @Test
 761     public void test_adjacent_strict_firstVariableWidth_fails() throws Exception {
 762         // fails because literal is a number and variable width parse greedily absorbs it
 763         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('9').toFormatter(Locale.UK);
 764         ParsePosition pp = new ParsePosition(0);
 765         TemporalAccessor parsed = f.parseUnresolved("12309", pp);
 766         assertEquals(pp.getErrorIndex(), 5);
 767         assertEquals(parsed, null);
 768     }
 769 
 770     @Test
 771     public void test_adjacent_lenient() throws Exception {
 772         // succeeds because both number elements are fixed width even in lenient mode
 773         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('9').toFormatter(Locale.UK);
 774         ParsePosition pp = new ParsePosition(0);
 775         TemporalAccessor parsed = f.parseUnresolved("12309", pp);
 776         assertEquals(pp.getErrorIndex(), -1);
 777         assertEquals(pp.getIndex(), 5);
 778         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 779         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 780     }
 781 
 782     @Test
 783     public void test_adjacent_lenient_firstVariableWidth_success() throws Exception {
 784         // succeeds greedily parsing variable width, then fixed width, to non-numeric Z
 785         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('Z').toFormatter(Locale.UK);
 786         ParsePosition pp = new ParsePosition(0);
 787         TemporalAccessor parsed = f.parseUnresolved("12309Z", pp);
 788         assertEquals(pp.getErrorIndex(), -1);
 789         assertEquals(pp.getIndex(), 6);
 790         assertEquals(parsed.getLong(HOUR_OF_DAY), 123L);
 791         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 9L);
 792     }
 793 
 794     @Test
 795     public void test_adjacent_lenient_firstVariableWidth_fails() throws Exception {
 796         // fails because literal is a number and variable width parse greedily absorbs it
 797         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY).appendValue(MINUTE_OF_HOUR, 2).appendLiteral('9').toFormatter(Locale.UK);
 798         ParsePosition pp = new ParsePosition(0);
 799         TemporalAccessor parsed = f.parseUnresolved("12309", pp);
 800         assertEquals(pp.getErrorIndex(), 5);
 801         assertEquals(parsed, null);
 802     }
 803 
 804     //-----------------------------------------------------------------------
 805     @Test
 806     public void test_adjacent_strict_fractionFollows() throws Exception {
 807         // succeeds because hour/min are fixed width
 808         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 0, 3, false).toFormatter(Locale.UK);
 809         ParsePosition pp = new ParsePosition(0);
 810         TemporalAccessor parsed = f.parseUnresolved("1230567", pp);
 811         assertEquals(pp.getErrorIndex(), -1);
 812         assertEquals(pp.getIndex(), 7);
 813         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 814         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 815         assertEquals(parsed.getLong(NANO_OF_SECOND), 567_000_000L);
 816     }
 817 
 818     @Test
 819     public void test_adjacent_strict_fractionFollows_2digit() throws Exception {
 820         // succeeds because hour/min are fixed width
 821         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 0, 3, false).toFormatter(Locale.UK);
 822         ParsePosition pp = new ParsePosition(0);
 823         TemporalAccessor parsed = f.parseUnresolved("123056", pp);
 824         assertEquals(pp.getErrorIndex(), -1);
 825         assertEquals(pp.getIndex(), 6);
 826         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 827         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 828         assertEquals(parsed.getLong(NANO_OF_SECOND), 560_000_000L);
 829     }
 830 
 831     @Test
 832     public void test_adjacent_strict_fractionFollows_0digit() throws Exception {
 833         // succeeds because hour/min are fixed width
 834         DateTimeFormatter f = builder.appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 0, 3, false).toFormatter(Locale.UK);
 835         ParsePosition pp = new ParsePosition(0);
 836         TemporalAccessor parsed = f.parseUnresolved("1230", pp);
 837         assertEquals(pp.getErrorIndex(), -1);
 838         assertEquals(pp.getIndex(), 4);
 839         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 840         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 841     }
 842 
 843     @Test
 844     public void test_adjacent_lenient_fractionFollows() throws Exception {
 845         // succeeds because hour/min are fixed width
 846         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 3, 3, false).toFormatter(Locale.UK);
 847         ParsePosition pp = new ParsePosition(0);
 848         TemporalAccessor parsed = f.parseUnresolved("1230567", pp);
 849         assertEquals(pp.getErrorIndex(), -1);
 850         assertEquals(pp.getIndex(), 7);
 851         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 852         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 853         assertEquals(parsed.getLong(NANO_OF_SECOND), 567_000_000L);
 854     }
 855 
 856     @Test
 857     public void test_adjacent_lenient_fractionFollows_2digit() throws Exception {
 858         // succeeds because hour/min are fixed width
 859         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 3, 3, false).toFormatter(Locale.UK);
 860         ParsePosition pp = new ParsePosition(0);
 861         TemporalAccessor parsed = f.parseUnresolved("123056", pp);
 862         assertEquals(pp.getErrorIndex(), -1);
 863         assertEquals(pp.getIndex(), 6);
 864         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 865         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 866         assertEquals(parsed.getLong(NANO_OF_SECOND), 560_000_000L);
 867     }
 868 
 869     @Test
 870     public void test_adjacent_lenient_fractionFollows_0digit() throws Exception {
 871         // succeeds because hour/min are fixed width
 872         DateTimeFormatter f = builder.parseLenient().appendValue(HOUR_OF_DAY, 2).appendValue(MINUTE_OF_HOUR, 2).appendFraction(NANO_OF_SECOND, 3, 3, false).toFormatter(Locale.UK);
 873         ParsePosition pp = new ParsePosition(0);
 874         TemporalAccessor parsed = f.parseUnresolved("1230", pp);
 875         assertEquals(pp.getErrorIndex(), -1);
 876         assertEquals(pp.getIndex(), 4);
 877         assertEquals(parsed.getLong(HOUR_OF_DAY), 12L);
 878         assertEquals(parsed.getLong(MINUTE_OF_HOUR), 30L);
 879     }
 880 
 881 }
--- EOF ---