390 {"+HHMMSS", 2, 30, 45, "+023045"},
391
392 {"+HH:MM:SS", 2, 0, 0, "+02:00:00"},
393 {"+HH:MM:SS", -2, 0, 0, "-02:00:00"},
394 {"+HH:MM:SS", 2, 30, 0, "+02:30:00"},
395 {"+HH:MM:SS", 2, 0, 45, "+02:00:45"},
396 {"+HH:MM:SS", 2, 30, 45, "+02:30:45"},
397
398 {"+HHmmss", 2, 0, 0, "+02"},
399 {"+HHmmss", -2, 0, 0, "-02"},
400 {"+HHmmss", 2, 30, 0, "+0230"},
401 {"+HHmmss", 2, 0, 45, "+020045"},
402 {"+HHmmss", 2, 30, 45, "+023045"},
403
404 {"+HH:mm:ss", 2, 0, 0, "+02"},
405 {"+HH:mm:ss", -2, 0, 0, "-02"},
406 {"+HH:mm:ss", 2, 30, 0, "+02:30"},
407 {"+HH:mm:ss", 2, 0, 45, "+02:00:45"},
408 {"+HH:mm:ss", 2, 30, 45, "+02:30:45"},
409
410
411 };
412 }
413
414 @Test(dataProvider="offsetPatterns")
415 public void test_appendOffset_format(String pattern, int h, int m, int s, String expected) throws Exception {
416 builder.appendOffset(pattern, "Z");
417 DateTimeFormatter f = builder.toFormatter();
418 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(h, m, s);
419 assertEquals(f.format(offset), expected);
420 }
421
422 @Test(dataProvider="offsetPatterns")
423 public void test_appendOffset_parse(String pattern, int h, int m, int s, String expected) throws Exception {
424 builder.appendOffset(pattern, "Z");
425 DateTimeFormatter f = builder.toFormatter();
426 ZoneOffset parsed = f.parse(expected, ZoneOffset::from);
427 assertEquals(f.format(parsed), expected);
428 }
429
430 @DataProvider(name="badOffsetPatterns")
431 Object[][] data_badOffsetPatterns() {
432 return new Object[][] {
433 {"HH"},
434 {"HHMM"},
435 {"HH:MM"},
436 {"HHMMss"},
437 {"HH:MM:ss"},
438 {"HHMMSS"},
439 {"HH:MM:SS"},
440 {"+H"},
441 {"+HMM"},
442 {"+HHM"},
443 {"+A"},
444 };
445 }
446
447 @Test(dataProvider="badOffsetPatterns", expectedExceptions=IllegalArgumentException.class)
448 public void test_appendOffset_badPattern(String pattern) throws Exception {
449 builder.appendOffset(pattern, "Z");
450 }
451
452 @Test(expectedExceptions=NullPointerException.class)
453 public void test_appendOffset_3arg_nullText() throws Exception {
454 builder.appendOffset("+HH:MM", null);
455 }
456
457 @Test(expectedExceptions=NullPointerException.class)
458 public void test_appendOffset_3arg_nullPattern() throws Exception {
459 builder.appendOffset(null, "Z");
460 }
461
1171 {"+HH:MM", "+01:01", 3660},
1172 {"+HH:MM", "+01:01:01", 3661},
1173 {"+HHMMss", "+01", 3600},
1174 {"+HHMMss", "+0101", 3660},
1175 {"+HHMMss", "+010101", 3661},
1176 {"+HH:MM:ss", "+01", 3600},
1177 {"+HH:MM:ss", "+01:01", 3660},
1178 {"+HH:MM:ss", "+01:01:01", 3661},
1179 {"+HHMMSS", "+01", 3600},
1180 {"+HHMMSS", "+0101", 3660},
1181 {"+HHMMSS", "+010101", 3661},
1182 {"+HH:MM:SS", "+01", 3600},
1183 {"+HH:MM:SS", "+01:01", 3660},
1184 {"+HH:MM:SS", "+01:01:01", 3661},
1185 {"+HHmmss", "+01", 3600},
1186 {"+HHmmss", "+0101", 3660},
1187 {"+HHmmss", "+010101", 3661},
1188 {"+HH:mm:ss", "+01", 3600},
1189 {"+HH:mm:ss", "+01:01", 3660},
1190 {"+HH:mm:ss", "+01:01:01", 3661},
1191 };
1192 }
1193
1194 @Test(dataProvider="lenientOffsetParseData")
1195 public void test_lenient_offset_parse_1(String pattern, String offset, int offsetSeconds) {
1196 assertEquals(new DateTimeFormatterBuilder().parseLenient().appendOffset(pattern, "Z").toFormatter().parse(offset).get(OFFSET_SECONDS),
1197 offsetSeconds);
1198 }
1199
1200 @Test
1201 public void test_lenient_offset_parse_2() {
1202 assertEquals(new DateTimeFormatterBuilder().parseLenient().appendOffsetId().toFormatter().parse("+01").get(OFFSET_SECONDS),
1203 3600);
1204 }
1205
1206 @Test(expectedExceptions=DateTimeParseException.class)
1207 public void test_strict_appendOffsetId() {
1208 assertEquals(new DateTimeFormatterBuilder().appendOffsetId().toFormatter().parse("+01").get(OFFSET_SECONDS),
1209 3600);
1210 }
1211
1212 @Test(expectedExceptions=DateTimeParseException.class)
1213 public void test_strict_appendOffset_1() {
1214 assertEquals(new DateTimeFormatterBuilder().appendOffset("+HH:MM:ss", "Z").toFormatter().parse("+01").get(OFFSET_SECONDS),
1215 3600);
1216 }
1217
1218 @Test(expectedExceptions=DateTimeParseException.class)
1219 public void test_strict_appendOffset_2() {
1220 assertEquals(new DateTimeFormatterBuilder().appendOffset("+HHMMss", "Z").toFormatter().parse("+01").get(OFFSET_SECONDS),
1221 3600);
1222 }
1223
1224 @Test
1225 public void test_basic_iso_date() {
1226 assertEquals(BASIC_ISO_DATE.parse("20021231+01").get(OFFSET_SECONDS), 3600);
1227 assertEquals(BASIC_ISO_DATE.parse("20021231+0101").get(OFFSET_SECONDS), 3660);
1228 }
1229
1230 }
|
390 {"+HHMMSS", 2, 30, 45, "+023045"},
391
392 {"+HH:MM:SS", 2, 0, 0, "+02:00:00"},
393 {"+HH:MM:SS", -2, 0, 0, "-02:00:00"},
394 {"+HH:MM:SS", 2, 30, 0, "+02:30:00"},
395 {"+HH:MM:SS", 2, 0, 45, "+02:00:45"},
396 {"+HH:MM:SS", 2, 30, 45, "+02:30:45"},
397
398 {"+HHmmss", 2, 0, 0, "+02"},
399 {"+HHmmss", -2, 0, 0, "-02"},
400 {"+HHmmss", 2, 30, 0, "+0230"},
401 {"+HHmmss", 2, 0, 45, "+020045"},
402 {"+HHmmss", 2, 30, 45, "+023045"},
403
404 {"+HH:mm:ss", 2, 0, 0, "+02"},
405 {"+HH:mm:ss", -2, 0, 0, "-02"},
406 {"+HH:mm:ss", 2, 30, 0, "+02:30"},
407 {"+HH:mm:ss", 2, 0, 45, "+02:00:45"},
408 {"+HH:mm:ss", 2, 30, 45, "+02:30:45"},
409
410 {"+H", 2, 0, 0, "+2"},
411 {"+H", -2, 0, 0, "-2"},
412 {"+H", 2, 30, 0, "+2"},
413 {"+H", 2, 0, 45, "+2"},
414 {"+H", 2, 30, 45, "+2"},
415 {"+H", 12, 0, 0, "+12"},
416 {"+H", -12, 0, 0, "-12"},
417 {"+H", 12, 30, 0, "+12"},
418 {"+H", 12, 0, 45, "+12"},
419 {"+H", 12, 30, 45, "+12"},
420
421 {"+Hmm", 2, 0, 0, "+2"},
422 {"+Hmm", -2, 0, 0, "-2"},
423 {"+Hmm", 2, 30, 0, "+230"},
424 {"+Hmm", 2, 0, 45, "+2"},
425 {"+Hmm", 2, 30, 45, "+230"},
426 {"+Hmm", 12, 0, 0, "+12"},
427 {"+Hmm", -12, 0, 0, "-12"},
428 {"+Hmm", 12, 30, 0, "+1230"},
429 {"+Hmm", 12, 0, 45, "+12"},
430 {"+Hmm", 12, 30, 45, "+1230"},
431
432 {"+H:mm", 2, 0, 0, "+2"},
433 {"+H:mm", -2, 0, 0, "-2"},
434 {"+H:mm", 2, 30, 0, "+2:30"},
435 {"+H:mm", 2, 0, 45, "+2"},
436 {"+H:mm", 2, 30, 45, "+2:30"},
437 {"+H:mm", 12, 0, 0, "+12"},
438 {"+H:mm", -12, 0, 0, "-12"},
439 {"+H:mm", 12, 30, 0, "+12:30"},
440 {"+H:mm", 12, 0, 45, "+12"},
441 {"+H:mm", 12, 30, 45, "+12:30"},
442
443 {"+HMM", 2, 0, 0, "+200"},
444 {"+HMM", -2, 0, 0, "-200"},
445 {"+HMM", 2, 30, 0, "+230"},
446 {"+HMM", 2, 0, 45, "+200"},
447 {"+HMM", 2, 30, 45, "+230"},
448 {"+HMM", 12, 0, 0, "+1200"},
449 {"+HMM", -12, 0, 0, "-1200"},
450 {"+HMM", 12, 30, 0, "+1230"},
451 {"+HMM", 12, 0, 45, "+1200"},
452 {"+HMM", 12, 30, 45, "+1230"},
453
454 {"+H:MM", 2, 0, 0, "+2:00"},
455 {"+H:MM", -2, 0, 0, "-2:00"},
456 {"+H:MM", 2, 30, 0, "+2:30"},
457 {"+H:MM", 2, 0, 45, "+2:00"},
458 {"+H:MM", 2, 30, 45, "+2:30"},
459 {"+H:MM", 12, 0, 0, "+12:00"},
460 {"+H:MM", -12, 0, 0, "-12:00"},
461 {"+H:MM", 12, 30, 0, "+12:30"},
462 {"+H:MM", 12, 0, 45, "+12:00"},
463 {"+H:MM", 12, 30, 45, "+12:30"},
464
465 {"+HMMss", 2, 0, 0, "+200"},
466 {"+HMMss", -2, 0, 0, "-200"},
467 {"+HMMss", 2, 30, 0, "+230"},
468 {"+HMMss", 2, 0, 45, "+20045"},
469 {"+HMMss", 2, 30, 45, "+23045"},
470 {"+HMMss", 12, 0, 0, "+1200"},
471 {"+HMMss", -12, 0, 0, "-1200"},
472 {"+HMMss", 12, 30, 0, "+1230"},
473 {"+HMMss", 12, 0, 45, "+120045"},
474 {"+HMMss", 12, 30, 45, "+123045"},
475
476 {"+H:MM:ss", 2, 0, 0, "+2:00"},
477 {"+H:MM:ss", -2, 0, 0, "-2:00"},
478 {"+H:MM:ss", 2, 30, 0, "+2:30"},
479 {"+H:MM:ss", 2, 0, 45, "+2:00:45"},
480 {"+H:MM:ss", 2, 30, 45, "+2:30:45"},
481 {"+H:MM:ss", 12, 0, 0, "+12:00"},
482 {"+H:MM:ss", -12, 0, 0, "-12:00"},
483 {"+H:MM:ss", 12, 30, 0, "+12:30"},
484 {"+H:MM:ss", 12, 0, 45, "+12:00:45"},
485 {"+H:MM:ss", 12, 30, 45, "+12:30:45"},
486
487 {"+HMMSS", 2, 0, 0, "+20000"},
488 {"+HMMSS", -2, 0, 0, "-20000"},
489 {"+HMMSS", 2, 30, 0, "+23000"},
490 {"+HMMSS", 2, 0, 45, "+20045"},
491 {"+HMMSS", 2, 30, 45, "+23045"},
492 {"+HMMSS", 12, 0, 0, "+120000"},
493 {"+HMMSS", -12, 0, 0, "-120000"},
494 {"+HMMSS", 12, 30, 0, "+123000"},
495 {"+HMMSS", 12, 0, 45, "+120045"},
496 {"+HMMSS", 12, 30, 45, "+123045"},
497
498 {"+H:MM:SS", 2, 0, 0, "+2:00:00"},
499 {"+H:MM:SS", -2, 0, 0, "-2:00:00"},
500 {"+H:MM:SS", 2, 30, 0, "+2:30:00"},
501 {"+H:MM:SS", 2, 0, 45, "+2:00:45"},
502 {"+H:MM:SS", 2, 30, 45, "+2:30:45"},
503 {"+H:MM:SS", 12, 0, 0, "+12:00:00"},
504 {"+H:MM:SS", -12, 0, 0, "-12:00:00"},
505 {"+H:MM:SS", 12, 30, 0, "+12:30:00"},
506 {"+H:MM:SS", 12, 0, 45, "+12:00:45"},
507 {"+H:MM:SS", 12, 30, 45, "+12:30:45"},
508
509 {"+Hmmss", 2, 0, 0, "+2"},
510 {"+Hmmss", -2, 0, 0, "-2"},
511 {"+Hmmss", 2, 30, 0, "+230"},
512 {"+Hmmss", 2, 0, 45, "+20045"},
513 {"+Hmmss", 2, 30, 45, "+23045"},
514 {"+Hmmss", 12, 0, 0, "+12"},
515 {"+Hmmss", -12, 0, 0, "-12"},
516 {"+Hmmss", 12, 30, 0, "+1230"},
517 {"+Hmmss", 12, 0, 45, "+120045"},
518 {"+Hmmss", 12, 30, 45, "+123045"},
519
520 {"+H:mm:ss", 2, 0, 0, "+2"},
521 {"+H:mm:ss", -2, 0, 0, "-2"},
522 {"+H:mm:ss", 2, 30, 0, "+2:30"},
523 {"+H:mm:ss", 2, 0, 45, "+2:00:45"},
524 {"+H:mm:ss", 2, 30, 45, "+2:30:45"},
525 {"+H:mm:ss", 12, 0, 0, "+12"},
526 {"+H:mm:ss", -12, 0, 0, "-12"},
527 {"+H:mm:ss", 12, 30, 0, "+12:30"},
528 {"+H:mm:ss", 12, 0, 45, "+12:00:45"},
529 {"+H:mm:ss", 12, 30, 45, "+12:30:45"},
530
531
532 };
533 }
534
535 @Test(dataProvider="offsetPatterns")
536 public void test_appendOffset_format(String pattern, int h, int m, int s, String expected) throws Exception {
537 builder.appendOffset(pattern, "Z");
538 DateTimeFormatter f = builder.toFormatter();
539 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(h, m, s);
540 assertEquals(f.format(offset), expected);
541 }
542
543 @Test(dataProvider="offsetPatterns")
544 public void test_appendOffset_parse(String pattern, int h, int m, int s, String expected) throws Exception {
545 builder.appendOffset(pattern, "Z");
546 DateTimeFormatter f = builder.toFormatter();
547 ZoneOffset parsed = f.parse(expected, ZoneOffset::from);
548 assertEquals(f.format(parsed), expected);
549 }
550
551 @DataProvider(name="badOffsetPatterns")
552 Object[][] data_badOffsetPatterns() {
553 return new Object[][] {
554 {"HH"},
555 {"HHMM"},
556 {"HH:MM"},
557 {"HHMMss"},
558 {"HH:MM:ss"},
559 {"HHMMSS"},
560 {"HH:MM:SS"},
561 {"+HHM"},
562 {"+A"},
563 };
564 }
565
566 @Test(dataProvider="badOffsetPatterns", expectedExceptions=IllegalArgumentException.class)
567 public void test_appendOffset_badPattern(String pattern) throws Exception {
568 builder.appendOffset(pattern, "Z");
569 }
570
571 @Test(expectedExceptions=NullPointerException.class)
572 public void test_appendOffset_3arg_nullText() throws Exception {
573 builder.appendOffset("+HH:MM", null);
574 }
575
576 @Test(expectedExceptions=NullPointerException.class)
577 public void test_appendOffset_3arg_nullPattern() throws Exception {
578 builder.appendOffset(null, "Z");
579 }
580
1290 {"+HH:MM", "+01:01", 3660},
1291 {"+HH:MM", "+01:01:01", 3661},
1292 {"+HHMMss", "+01", 3600},
1293 {"+HHMMss", "+0101", 3660},
1294 {"+HHMMss", "+010101", 3661},
1295 {"+HH:MM:ss", "+01", 3600},
1296 {"+HH:MM:ss", "+01:01", 3660},
1297 {"+HH:MM:ss", "+01:01:01", 3661},
1298 {"+HHMMSS", "+01", 3600},
1299 {"+HHMMSS", "+0101", 3660},
1300 {"+HHMMSS", "+010101", 3661},
1301 {"+HH:MM:SS", "+01", 3600},
1302 {"+HH:MM:SS", "+01:01", 3660},
1303 {"+HH:MM:SS", "+01:01:01", 3661},
1304 {"+HHmmss", "+01", 3600},
1305 {"+HHmmss", "+0101", 3660},
1306 {"+HHmmss", "+010101", 3661},
1307 {"+HH:mm:ss", "+01", 3600},
1308 {"+HH:mm:ss", "+01:01", 3660},
1309 {"+HH:mm:ss", "+01:01:01", 3661},
1310
1311 {"+H" , "+1", 3600},
1312 {"+H", "+101", 3660},
1313 {"+H", "+10101", 3661},
1314 {"+H", "+1:01", 3660},
1315 {"+H", "+1:01:01", 3661},
1316 {"+H" , "+01", 3600},
1317 {"+H", "+0101", 3660},
1318 {"+H", "+010101", 3661},
1319 {"+H", "+01:01", 3660},
1320 {"+H", "+01:01:01", 3661},
1321 {"+Hmm", "+1", 3600},
1322 {"+Hmm", "+101", 3660},
1323 {"+Hmm", "+10101", 3661},
1324 {"+Hmm", "+01", 3600},
1325 {"+Hmm", "+0101", 3660},
1326 {"+Hmm", "+010101", 3661},
1327 {"+H:mm", "+1", 3600},
1328 {"+H:mm", "+1:01", 3660},
1329 {"+H:mm", "+1:01:01", 3661},
1330 {"+H:mm", "+01", 3600},
1331 {"+H:mm", "+01:01", 3660},
1332 {"+H:mm", "+01:01:01", 3661},
1333 {"+HMM", "+1", 3600},
1334 {"+HMM", "+101", 3660},
1335 {"+HMM", "+10101", 3661},
1336 {"+HMM", "+01", 3600},
1337 {"+HMM", "+0101", 3660},
1338 {"+HMM", "+010101", 3661},
1339 {"+H:MM", "+1", 3600},
1340 {"+H:MM", "+1:01", 3660},
1341 {"+H:MM", "+1:01:01", 3661},
1342 {"+H:MM", "+01", 3600},
1343 {"+H:MM", "+01:01", 3660},
1344 {"+H:MM", "+01:01:01", 3661},
1345 {"+HMMss", "+1", 3600},
1346 {"+HMMss", "+101", 3660},
1347 {"+HMMss", "+10101", 3661},
1348 {"+HMMss", "+01", 3600},
1349 {"+HMMss", "+0101", 3660},
1350 {"+HMMss", "+010101", 3661},
1351 {"+H:MM:ss", "+1", 3600},
1352 {"+H:MM:ss", "+1:01", 3660},
1353 {"+H:MM:ss", "+1:01:01", 3661},
1354 {"+H:MM:ss", "+01", 3600},
1355 {"+H:MM:ss", "+01:01", 3660},
1356 {"+H:MM:ss", "+01:01:01", 3661},
1357 {"+HMMSS", "+1", 3600},
1358 {"+HMMSS", "+101", 3660},
1359 {"+HMMSS", "+10101", 3661},
1360 {"+HMMSS", "+01", 3600},
1361 {"+HMMSS", "+0101", 3660},
1362 {"+HMMSS", "+010101", 3661},
1363 {"+H:MM:SS", "+1", 3600},
1364 {"+H:MM:SS", "+1:01", 3660},
1365 {"+H:MM:SS", "+1:01:01", 3661},
1366 {"+H:MM:SS", "+01", 3600},
1367 {"+H:MM:SS", "+01:01", 3660},
1368 {"+H:MM:SS", "+01:01:01", 3661},
1369 {"+Hmmss", "+1", 3600},
1370 {"+Hmmss", "+101", 3660},
1371 {"+Hmmss", "+10101", 3661},
1372 {"+Hmmss", "+01", 3600},
1373 {"+Hmmss", "+0101", 3660},
1374 {"+Hmmss", "+010101", 3661},
1375 {"+H:mm:ss", "+1", 3600},
1376 {"+H:mm:ss", "+1:01", 3660},
1377 {"+H:mm:ss", "+1:01:01", 3661},
1378 {"+H:mm:ss", "+01", 3600},
1379 {"+H:mm:ss", "+01:01", 3660},
1380 {"+H:mm:ss", "+01:01:01", 3661},
1381 };
1382 }
1383
1384 @DataProvider(name="strictDoubleDigitHourOffsetParseData")
1385 Object[][] data_strictDoubleDigitHour_offset_parse() {
1386 return new Object[][] {
1387 {"+HH", "+01", 3600},
1388 {"+HHmm", "+01", 3600},
1389 {"+HHmm", "+0101", 3660},
1390 {"+HH:mm", "+01", 3600},
1391 {"+HH:mm", "+01:01", 3660},
1392 {"+HHMM", "+0101", 3660},
1393 {"+HH:MM", "+01:01", 3660},
1394 {"+HHMMss", "+0101", 3660},
1395 {"+HHMMss", "+010101", 3661},
1396 {"+HH:MM:ss", "+01:01", 3660},
1397 {"+HH:MM:ss", "+01:01:01", 3661},
1398 {"+HHMMSS", "+010101", 3661},
1399 {"+HH:MM:SS", "+01:01:01", 3661},
1400 {"+HHmmss", "+01", 3600},
1401 {"+HHmmss", "+0101", 3660},
1402 {"+HHmmss", "+010101", 3661},
1403 {"+HH:mm:ss", "+01", 3600},
1404 {"+HH:mm:ss", "+01:01", 3660},
1405 {"+HH:mm:ss", "+01:01:01", 3661},
1406 };
1407 }
1408
1409 @DataProvider(name="strictSingleDigitHourOffsetParseData")
1410 Object[][] data_strictSingleDigitHour_offset_parse() {
1411 return new Object[][] {
1412 {"+H" , "+01", 3600},
1413 {"+H" , "+1", 3600},
1414 {"+Hmm", "+01", 3600},
1415 {"+Hmm", "+0101", 3660},
1416 {"+Hmm", "+1", 3600},
1417 {"+Hmm", "+101", 3660},
1418 {"+H:mm", "+01", 3600},
1419 {"+H:mm", "+01:01", 3660},
1420 {"+H:mm", "+1", 3600},
1421 {"+H:mm", "+1:01", 3660},
1422 {"+HMM", "+0101", 3660},
1423 {"+HMM", "+101", 3660},
1424 {"+H:MM", "+01:01", 3660},
1425 {"+H:MM", "+1:01", 3660},
1426 {"+HMMss", "+0101", 3660},
1427 {"+HMMss", "+010101", 3661},
1428 {"+HMMss", "+101", 3660},
1429 {"+HMMss", "+10101", 3661},
1430 {"+H:MM:ss", "+01:01", 3660},
1431 {"+H:MM:ss", "+01:01:01", 3661},
1432 {"+H:MM:ss", "+1:01", 3660},
1433 {"+H:MM:ss", "+1:01:01", 3661},
1434 {"+HMMSS", "+010101", 3661},
1435 {"+HMMSS", "+10101", 3661},
1436 {"+H:MM:SS", "+01:01:01", 3661},
1437 {"+H:MM:SS", "+1:01:01", 3661},
1438 {"+Hmmss", "+01", 3600},
1439 {"+Hmmss", "+0101", 3660},
1440 {"+Hmmss", "+010101", 3661},
1441 {"+Hmmss", "+1", 3600},
1442 {"+Hmmss", "+101", 3660},
1443 {"+Hmmss", "+10101", 3661},
1444 {"+H:mm:ss", "+01", 3600},
1445 {"+H:mm:ss", "+01:01", 3660},
1446 {"+H:mm:ss", "+01:01:01", 3661},
1447 {"+H:mm:ss", "+1", 3600},
1448 {"+H:mm:ss", "+1:01", 3660},
1449 {"+H:mm:ss", "+1:01:01", 3661},
1450 };
1451 }
1452
1453 @Test(dataProvider="lenientOffsetParseData")
1454 public void test_lenient_offset_parse_1(String pattern, String offset, int offsetSeconds) {
1455 assertEquals(new DateTimeFormatterBuilder().parseLenient().appendOffset(pattern, "Z").toFormatter().parse(offset).get(OFFSET_SECONDS),
1456 offsetSeconds);
1457 }
1458
1459 @Test
1460 public void test_lenient_offset_parse_2() {
1461 assertEquals(new DateTimeFormatterBuilder().parseLenient().appendOffsetId().toFormatter().parse("+01").get(OFFSET_SECONDS),
1462 3600);
1463 }
1464
1465 @Test(dataProvider="strictDoubleDigitHourOffsetParseData")
1466 public void test_strictDoubleDigitHour_offset_parse_1(String pattern, String offset, int offsetSeconds) {
1467 assertEquals(new DateTimeFormatterBuilder().appendOffset(pattern, "Z").toFormatter()
1468 .parse(offset).get(OFFSET_SECONDS), offsetSeconds);
1469 }
1470
1471 @Test(dataProvider="strictDoubleDigitHourOffsetParseData")
1472 public void test_strictDoubleDigitHour_offset_parse_2(String pattern, String offset, int offsetSeconds) {
1473 assertEquals(new DateTimeFormatterBuilder().appendOffset(pattern, "Z")
1474 .appendLiteral("text").toFormatter().parse(offset + "text").get(OFFSET_SECONDS), offsetSeconds);
1475 }
1476
1477 @Test(dataProvider="strictSingleDigitHourOffsetParseData")
1478 public void test_strictSingleDigitHour_offset_parse_1(String pattern, String offset, int offsetSeconds) {
1479 assertEquals(new DateTimeFormatterBuilder().appendOffset(pattern, "Z").toFormatter()
1480 .parse(offset).get(OFFSET_SECONDS), offsetSeconds);
1481 }
1482
1483 @Test(dataProvider="strictSingleDigitHourOffsetParseData")
1484 public void test_strictSingleDigitHour_offset_parse_2(String pattern, String offset, int offsetSeconds) {
1485 assertEquals(new DateTimeFormatterBuilder().appendOffset(pattern, "Z")
1486 .appendLiteral("text").toFormatter().parse(offset + "text").get(OFFSET_SECONDS), offsetSeconds);
1487 }
1488
1489 @DataProvider(name="strictOffsetAdjacentParseValidPatternData")
1490 Object[][] data_strict_offset_adjacentParse_validPattern() {
1491 return new Object[][] {
1492 {"+HH", "+01", 3600},
1493 {"+HHmm", "+0101", 3660},
1494 {"+HH:mm", "+01", 3600},
1495 {"+HH:mm", "+01:01", 3660},
1496 {"+HHMM", "+0101", 3660},
1497 {"+HH:MM", "+01:01", 3660},
1498 {"+HHMMss", "+010101", 3661},
1499 {"+HH:MM:ss", "+01:01", 3660},
1500 {"+HH:MM:ss", "+01:01:01", 3661},
1501 {"+HHMMSS", "+010101", 3661},
1502 {"+HH:MM:SS", "+01:01:01", 3661},
1503 {"+HHmmss", "+010101", 3661},
1504 {"+HH:mm:ss", "+01", 3600},
1505 {"+HH:mm:ss", "+01:01", 3660},
1506 {"+HH:mm:ss", "+01:01:01", 3661},
1507
1508 {"+H" , "+01", 3600},
1509 {"+Hmm", "+0101", 3660},
1510 {"+H:mm", "+01", 3600},
1511 {"+H:mm", "+01:01", 3660},
1512 {"+H:mm", "+1:01", 3660},
1513 {"+HMM", "+0101", 3660},
1514 {"+H:MM", "+01:01", 3660},
1515 {"+H:MM", "+1:01", 3660},
1516 {"+HMMss", "+010101", 3661},
1517 {"+H:MM:ss", "+01:01", 3660},
1518 {"+H:MM:ss", "+01:01:01", 3661},
1519 {"+H:MM:ss", "+1:01", 3660},
1520 {"+H:MM:ss", "+1:01:01", 3661},
1521 {"+HMMSS", "+010101", 3661},
1522 {"+H:MM:SS", "+01:01:01", 3661},
1523 {"+H:MM:SS", "+1:01:01", 3661},
1524 {"+Hmmss", "+010101", 3661},
1525 {"+H:mm:ss", "+01", 3600},
1526 {"+H:mm:ss", "+01:01", 3660},
1527 {"+H:mm:ss", "+01:01:01", 3661},
1528 {"+H:mm:ss", "+1:01", 3660},
1529 {"+H:mm:ss", "+1:01:01", 3661},
1530 };
1531 }
1532
1533 @Test(dataProvider="strictOffsetAdjacentParseValidPatternData")
1534 public void test_strict_offset_adjacentValidPattern_parse(String pattern, String offset, int offsetSeconds) {
1535 TemporalAccessor tmp = new DateTimeFormatterBuilder().appendOffset(pattern, "Z")
1536 .appendValue(HOUR_OF_DAY, 2).toFormatter().parse(offset + "12");
1537 assertEquals(tmp.get(OFFSET_SECONDS), offsetSeconds);
1538 assertEquals(tmp.get(HOUR_OF_DAY), 12);
1539 }
1540
1541 @DataProvider(name="strictOffsetAdjacentParseInvalidPatternData")
1542 Object[][] data_strict_offset_adjacentParse_invalidPattern() {
1543 return new Object[][] {
1544 {"+HHmm", "+01", 3600},
1545 {"+HHMMss", "+0101", 3660},
1546 {"+HHmmss", "+01", 3600},
1547 {"+HHmmss", "+0101", 3660},
1548 {"+H" , "+1", 3600},
1549 {"+Hmm", "+01", 3600},
1550 {"+H:mm", "+1", 3600},
1551 {"+Hmm", "+1", 3600},
1552 {"+Hmm", "+101", 3660},
1553 {"+HMM", "+101", 3660},
1554 {"+HMMss", "+0101", 3660},
1555 {"+HMMss", "+101", 3660},
1556 {"+HMMss", "+10101", 3661},
1557 {"+HMMSS", "+10101", 3661},
1558 {"+Hmmss", "+01", 3600},
1559 {"+Hmmss", "+0101", 3660},
1560 {"+Hmmss", "+1", 3600},
1561 {"+Hmmss", "+101", 3660},
1562 {"+Hmmss", "+10101", 3661},
1563 {"+H:mm:ss", "+1", 3600},
1564 };
1565 }
1566
1567 @Test(dataProvider="strictOffsetAdjacentParseInvalidPatternData", expectedExceptions=DateTimeParseException.class)
1568 public void test_strict_offset_adjacentInvalidPattern_parse(String pattern, String offset, int offsetSeconds) {
1569 new DateTimeFormatterBuilder().appendOffset(pattern, "Z").appendValue(HOUR_OF_DAY, 2)
1570 .toFormatter().parse(offset + "12").get(OFFSET_SECONDS);
1571 }
1572
1573 @DataProvider(name="lenientOffsetAdjacentParseValidPatternData")
1574 Object[][] data_lenient_offset_adjacentParse_validPattern() {
1575 return new Object[][] {
1576 {"+HH:mm", "+01", 3600},
1577 {"+HH:mm", "+01:01", 3660},
1578 {"+HH:MM", "+01:01", 3660},
1579 {"+HH:MM:ss", "+01:01", 3660},
1580 {"+HH:MM:ss", "+01:01:01", 3661},
1581 {"+HHMMSS", "+010101", 3661},
1582 {"+HH:MM:SS", "+01:01:01", 3661},
1583 {"+HHmmss", "+010101", 3661},
1584 {"+HH:mm:ss", "+01", 3600},
1585 {"+HH:mm:ss", "+01:01", 3660},
1586 {"+HH:mm:ss", "+01:01:01", 3661},
1587 {"+H:mm", "+01", 3600},
1588 {"+H:mm", "+01:01", 3660},
1589 {"+H:mm", "+1:01", 3660},
1590 {"+H:MM", "+01:01", 3660},
1591 {"+H:MM", "+1:01", 3660},
1592 {"+HMMss", "+010101", 3661},
1593 {"+H:MM:ss", "+01:01", 3660},
1594 {"+H:MM:ss", "+01:01:01", 3661},
1595 {"+H:MM:ss", "+1:01", 3660},
1596 {"+H:MM:ss", "+1:01:01", 3661},
1597 {"+HMMSS", "+010101", 3661},
1598 {"+H:MM:SS", "+01:01:01", 3661},
1599 {"+H:MM:SS", "+1:01:01", 3661},
1600 {"+Hmmss", "+010101", 3661},
1601 {"+H:mm:ss", "+01", 3600},
1602 {"+H:mm:ss", "+01:01", 3660},
1603 {"+H:mm:ss", "+01:01:01", 3661},
1604 {"+H:mm:ss", "+1:01", 3660},
1605 {"+H:mm:ss", "+1:01:01", 3661},
1606 };
1607 }
1608
1609 @Test(dataProvider="lenientOffsetAdjacentParseValidPatternData")
1610 public void test_lenient_offset_adjacentValidPattern_parse(String pattern, String offset, int offsetSeconds) {
1611 TemporalAccessor tmp = new DateTimeFormatterBuilder().parseLenient()
1612 .appendOffset(pattern, "Z").appendValue(HOUR_OF_DAY, 2).toFormatter().parse(offset + "12");
1613 assertEquals(tmp.get(OFFSET_SECONDS), offsetSeconds);
1614 assertEquals(tmp.get(HOUR_OF_DAY), 12);
1615 }
1616
1617 @Test
1618 public void test_lenient_offset_adjacentValidPattern_parse1() {
1619 TemporalAccessor tmp = new DateTimeFormatterBuilder().parseLenient()
1620 .appendOffset("+HMMSS", "Z").appendValue(HOUR_OF_DAY, 2).toFormatter().parse("+10101" + "12");
1621 //Equivalent to +101011. InLenienet mode will parse upto 6 digit if possible.
1622 //It will take 1 digit from HOUR_OF_DAY.
1623 assertEquals(tmp.get(OFFSET_SECONDS), 36611);
1624 assertEquals(tmp.get(HOUR_OF_DAY), 2);
1625 }
1626
1627 @DataProvider(name="lenientOffsetAdjacentParseInvalidPatternData")
1628 Object[][] data_lenient_offset_adjacentParse_invalidPattern() {
1629 return new Object[][] {
1630 {"+HH", "+01", 3600},
1631 {"+HHmm", "+0101", 3660},
1632 {"+HHMM", "+0101", 3660},
1633 {"+H" , "+01", 3600},
1634 {"+Hmm", "+0101", 3660},
1635 {"+HMM", "+0101", 3660},
1636 };
1637 }
1638
1639 @Test(dataProvider="lenientOffsetAdjacentParseInvalidPatternData", expectedExceptions=DateTimeParseException.class)
1640 public void test_lenient_offset_adjacentInvalidPattern_parse(String pattern, String offset, int offsetSeconds) {
1641 new DateTimeFormatterBuilder().parseLenient().appendOffset(pattern, "Z")
1642 .appendValue(HOUR_OF_DAY, 2).toFormatter().parse(offset + "12").get(OFFSET_SECONDS);
1643 }
1644
1645 @DataProvider(name="badValues")
1646 Object[][] data_badOffsetValues() {
1647 return new Object[][] {
1648 {"+HH", "+24"},
1649 {"+HHMM", "-1361"},
1650 {"+HH:MM:ss", "+13:12:66"},
1651 {"+HH:MM:SS", "+24:60:60"},
1652 {"+HHMMSS", "369999"},
1653 {"+H:MM", "+28:12"},
1654 };
1655 }
1656
1657 @Test(dataProvider="badValues", expectedExceptions=DateTimeParseException.class)
1658 public void test_badOffset_parse(String pattern, String offset) {
1659 new DateTimeFormatterBuilder().appendOffset(pattern, "Z").toFormatter().parse(offset);
1660 }
1661
1662 @Test(expectedExceptions=DateTimeParseException.class)
1663 public void test_strict_appendOffsetId() {
1664 assertEquals(new DateTimeFormatterBuilder().appendOffsetId().toFormatter()
1665 .parse("+01").get(OFFSET_SECONDS), 3600);
1666 }
1667
1668 @Test(expectedExceptions=DateTimeParseException.class)
1669 public void test_strict_appendOffset_1() {
1670 assertEquals(new DateTimeFormatterBuilder().appendOffset("+HH:MM:ss", "Z")
1671 .toFormatter().parse("+01").get(OFFSET_SECONDS), 3600);
1672 }
1673
1674 @Test(expectedExceptions=DateTimeParseException.class)
1675 public void test_strict_appendOffset_2() {
1676 assertEquals(new DateTimeFormatterBuilder().appendOffset("+HHMMss", "Z")
1677 .toFormatter().parse("+01").get(OFFSET_SECONDS), 3600);
1678 }
1679
1680 @Test(expectedExceptions=DateTimeParseException.class)
1681 public void test_strict_appendOffset_3() {
1682 assertEquals(new DateTimeFormatterBuilder().appendOffset("+H:MM:ss", "Z")
1683 .toFormatter().parse("+1").get(OFFSET_SECONDS), 3600);
1684 }
1685
1686 @Test(expectedExceptions=DateTimeParseException.class)
1687 public void test_strict_appendOffset_4() {
1688 assertEquals(new DateTimeFormatterBuilder().appendOffset("+HMMss", "Z")
1689 .toFormatter().parse("+1").get(OFFSET_SECONDS), 3600);
1690 }
1691
1692 @Test
1693 public void test_basic_iso_date() {
1694 assertEquals(BASIC_ISO_DATE.parse("20021231+01").get(OFFSET_SECONDS), 3600);
1695 assertEquals(BASIC_ISO_DATE.parse("20021231+0101").get(OFFSET_SECONDS), 3660);
1696 }
1697
1698 }
|