001 /*
002 * Copyright 2001-2011 Stephen Colebourne
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.joda.time.format;
017
018 import java.util.LinkedHashMap;
019 import java.util.Locale;
020 import java.util.Map;
021
022 import junit.framework.TestCase;
023 import junit.framework.TestSuite;
024
025 import org.joda.time.DateTime;
026 import org.joda.time.DateTimeFieldType;
027 import org.joda.time.DateTimeZone;
028 import org.joda.time.LocalDateTime;
029
030 /**
031 * This class is a Junit unit test for DateTimeFormatterBuilder.
032 *
033 * @author Stephen Colebourne
034 * @author Brian S O'Neill
035 */
036 public class TestDateTimeFormatterBuilder extends TestCase {
037
038 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
039 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
040 private static final DateTimeZone TOKYO = DateTimeZone.forID("Asia/Tokyo");
041 private static final DateTimeZone NEW_YORK = DateTimeZone.forID("America/New_York");
042 private static final DateTimeZone LOS_ANGELES = DateTimeZone.forID("America/Los_Angeles");
043
044 public static void main(String[] args) {
045 junit.textui.TestRunner.run(suite());
046 }
047
048 public static TestSuite suite() {
049 return new TestSuite(TestDateTimeFormatterBuilder.class);
050 }
051
052 public TestDateTimeFormatterBuilder(String name) {
053 super(name);
054 }
055
056 protected void setUp() throws Exception {
057 }
058
059 protected void tearDown() throws Exception {
060 }
061
062 //-----------------------------------------------------------------------
063 public void test_toFormatter() {
064 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
065 try {
066 bld.toFormatter();
067 fail();
068 } catch (UnsupportedOperationException ex) {}
069 bld.appendLiteral('X');
070 assertNotNull(bld.toFormatter());
071 }
072
073 public void test_toPrinter() {
074 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
075 try {
076 bld.toPrinter();
077 fail();
078 } catch (UnsupportedOperationException ex) {}
079 bld.appendLiteral('X');
080 assertNotNull(bld.toPrinter());
081 }
082
083 public void test_toParser() {
084 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
085 try {
086 bld.toParser();
087 fail();
088 } catch (UnsupportedOperationException ex) {}
089 bld.appendLiteral('X');
090 assertNotNull(bld.toParser());
091 }
092
093 //-----------------------------------------------------------------------
094 public void test_canBuildFormatter() {
095 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
096 assertEquals(false, bld.canBuildFormatter());
097 bld.appendLiteral('X');
098 assertEquals(true, bld.canBuildFormatter());
099 }
100
101 public void test_canBuildPrinter() {
102 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
103 assertEquals(false, bld.canBuildPrinter());
104 bld.appendLiteral('X');
105 assertEquals(true, bld.canBuildPrinter());
106 }
107
108 public void test_canBuildParser() {
109 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
110 assertEquals(false, bld.canBuildParser());
111 bld.appendLiteral('X');
112 assertEquals(true, bld.canBuildParser());
113 }
114
115 //-----------------------------------------------------------------------
116 public void test_append_Formatter() {
117 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
118 bld.appendLiteral('Y');
119 DateTimeFormatter f = bld.toFormatter();
120
121 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
122 bld2.appendLiteral('X');
123 bld2.append(f);
124 bld2.appendLiteral('Z');
125 assertEquals("XYZ", bld2.toFormatter().print(0L));
126 }
127
128 //-----------------------------------------------------------------------
129 public void test_append_Printer() {
130 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
131 bld.appendLiteral('Y');
132 DateTimePrinter p = bld.toPrinter();
133
134 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
135 bld2.appendLiteral('X');
136 bld2.append(p);
137 bld2.appendLiteral('Z');
138 DateTimeFormatter f = bld2.toFormatter();
139 assertEquals(true, f.isPrinter());
140 assertEquals(false, f.isParser());
141 assertEquals("XYZ", f.print(0L));
142 }
143
144 public void test_append_nullPrinter() {
145 try {
146 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
147 bld2.append((DateTimePrinter) null);
148 fail();
149 } catch (IllegalArgumentException ex) {
150 // expected
151 }
152 }
153
154 //-----------------------------------------------------------------------
155 public void test_append_Parser() {
156 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
157 bld.appendLiteral('Y');
158 DateTimeParser p = bld.toParser();
159
160 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
161 bld2.appendLiteral('X');
162 bld2.append(p);
163 bld2.appendLiteral('Z');
164 DateTimeFormatter f = bld2.toFormatter();
165 assertEquals(false, f.isPrinter());
166 assertEquals(true, f.isParser());
167 assertEquals(0, f.withZoneUTC().parseMillis("XYZ"));
168 }
169
170 public void test_append_nullParser() {
171 try {
172 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
173 bld2.append((DateTimeParser) null);
174 fail();
175 } catch (IllegalArgumentException ex) {
176 // expected
177 }
178 }
179
180 //-----------------------------------------------------------------------
181 public void test_append_Printer_nullParser() {
182 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
183 bld.appendLiteral('Y');
184 DateTimePrinter p = bld.toPrinter();
185
186 try {
187 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
188 bld2.append(p, (DateTimeParser) null);
189 fail();
190 } catch (IllegalArgumentException ex) {
191 // expected
192 }
193 }
194
195 public void test_append_nullPrinter_Parser() {
196 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
197 bld.appendLiteral('Y');
198 DateTimeParser p = bld.toParser();
199
200 try {
201 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
202 bld2.append((DateTimePrinter) null, p);
203 fail();
204 } catch (IllegalArgumentException ex) {
205 // expected
206 }
207 }
208
209 //-----------------------------------------------------------------------
210 public void test_appendOptional_Parser() {
211 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
212 bld.appendLiteral('Y');
213 DateTimeParser p = bld.toParser();
214
215 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
216 bld2.appendLiteral('X');
217 bld2.appendOptional(p);
218 bld2.appendLiteral('Z');
219 DateTimeFormatter f = bld2.toFormatter();
220 assertEquals(false, f.isPrinter());
221 assertEquals(true, f.isParser());
222 assertEquals(0, f.withZoneUTC().parseMillis("XYZ"));
223 }
224
225 public void test_appendOptional_nullParser() {
226 try {
227 DateTimeFormatterBuilder bld2 = new DateTimeFormatterBuilder();
228 bld2.appendOptional((DateTimeParser) null);
229 fail();
230 } catch (IllegalArgumentException ex) {
231 // expected
232 }
233 }
234
235 //-----------------------------------------------------------------------
236 public void test_appendFixedDecimal() {
237 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
238 bld.appendFixedDecimal(DateTimeFieldType.year(), 4);
239 DateTimeFormatter f = bld.toFormatter();
240
241 assertEquals("2007", f.print(new DateTime("2007-01-01")));
242 assertEquals("0123", f.print(new DateTime("123-01-01")));
243 assertEquals("0001", f.print(new DateTime("1-2-3")));
244 assertEquals("99999", f.print(new DateTime("99999-2-3")));
245 assertEquals("-0099", f.print(new DateTime("-99-2-3")));
246 assertEquals("0000", f.print(new DateTime("0-2-3")));
247
248 assertEquals(2001, f.parseDateTime("2001").getYear());
249 try {
250 f.parseDateTime("-2001");
251 fail();
252 } catch (IllegalArgumentException e) {
253 }
254 try {
255 f.parseDateTime("200");
256 fail();
257 } catch (IllegalArgumentException e) {
258 }
259 try {
260 f.parseDateTime("20016");
261 fail();
262 } catch (IllegalArgumentException e) {
263 }
264
265 bld = new DateTimeFormatterBuilder();
266 bld.appendFixedDecimal(DateTimeFieldType.hourOfDay(), 2);
267 bld.appendLiteral(':');
268 bld.appendFixedDecimal(DateTimeFieldType.minuteOfHour(), 2);
269 bld.appendLiteral(':');
270 bld.appendFixedDecimal(DateTimeFieldType.secondOfMinute(), 2);
271 f = bld.toFormatter();
272
273 assertEquals("01:02:34", f.print(new DateTime("T1:2:34")));
274
275 DateTime dt = f.parseDateTime("01:02:34");
276 assertEquals(1, dt.getHourOfDay());
277 assertEquals(2, dt.getMinuteOfHour());
278 assertEquals(34, dt.getSecondOfMinute());
279
280 try {
281 f.parseDateTime("0145:02:34");
282 fail();
283 } catch (IllegalArgumentException e) {
284 }
285 try {
286 f.parseDateTime("01:0:34");
287 fail();
288 } catch (IllegalArgumentException e) {
289 }
290 }
291
292 //-----------------------------------------------------------------------
293 public void test_appendFixedSignedDecimal() {
294 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
295 bld.appendFixedSignedDecimal(DateTimeFieldType.year(), 4);
296 DateTimeFormatter f = bld.toFormatter();
297
298 assertEquals("2007", f.print(new DateTime("2007-01-01")));
299 assertEquals("0123", f.print(new DateTime("123-01-01")));
300 assertEquals("0001", f.print(new DateTime("1-2-3")));
301 assertEquals("99999", f.print(new DateTime("99999-2-3")));
302 assertEquals("-0099", f.print(new DateTime("-99-2-3")));
303 assertEquals("0000", f.print(new DateTime("0-2-3")));
304
305 assertEquals(2001, f.parseDateTime("2001").getYear());
306 assertEquals(-2001, f.parseDateTime("-2001").getYear());
307 assertEquals(2001, f.parseDateTime("+2001").getYear());
308 try {
309 f.parseDateTime("20016");
310 fail();
311 } catch (IllegalArgumentException e) {
312 }
313 }
314
315 //-----------------------------------------------------------------------
316 public void test_appendTimeZoneId() {
317 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
318 bld.appendTimeZoneId();
319 DateTimeFormatter f = bld.toFormatter();
320
321 assertEquals("Asia/Tokyo", f.print(new DateTime(2007, 3, 4, 0, 0, 0, TOKYO)));
322 assertEquals(TOKYO, f.parseDateTime("Asia/Tokyo").getZone());
323 try {
324 f.parseDateTime("Nonsense");
325 fail();
326 } catch (IllegalArgumentException e) {
327 }
328 }
329
330 public void test_printParseZoneTokyo() {
331 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
332 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneId();
333 DateTimeFormatter f = bld.toFormatter();
334
335 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
336 assertEquals("2007-03-04 12:30 Asia/Tokyo", f.print(dt));
337 assertEquals(dt, f.parseDateTime("2007-03-04 12:30 Asia/Tokyo"));
338 }
339
340 public void test_printParseZoneParis() {
341 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
342 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneId();
343 DateTimeFormatter f = bld.toFormatter();
344
345 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, PARIS);
346 assertEquals("2007-03-04 12:30 Europe/Paris", f.print(dt));
347 assertEquals(dt, f.parseDateTime("2007-03-04 12:30 Europe/Paris"));
348 assertEquals(dt, f.withOffsetParsed().parseDateTime("2007-03-04 12:30 Europe/Paris"));
349 }
350
351 public void test_printParseZoneDawsonCreek() { // clashes with shorter Dawson
352 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
353 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneId();
354 DateTimeFormatter f = bld.toFormatter();
355
356 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, DateTimeZone.forID("America/Dawson_Creek"));
357 assertEquals("2007-03-04 12:30 America/Dawson_Creek", f.print(dt));
358 assertEquals(dt, f.parseDateTime("2007-03-04 12:30 America/Dawson_Creek"));
359 }
360
361 public void test_printParseZoneBahiaBanderas() {
362 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
363 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneId();
364 DateTimeFormatter f = bld.toFormatter();
365
366 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, DateTimeZone.forID("America/Bahia_Banderas"));
367 assertEquals("2007-03-04 12:30 America/Bahia_Banderas", f.print(dt));
368 assertEquals(dt, f.parseDateTime("2007-03-04 12:30 America/Bahia_Banderas"));
369 }
370
371 public void test_printParseOffset() {
372 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
373 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2);
374 DateTimeFormatter f = bld.toFormatter();
375
376 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
377 assertEquals("2007-03-04 12:30 +09:00", f.print(dt));
378 assertEquals(dt.withZone(DateTimeZone.getDefault()), f.parseDateTime("2007-03-04 12:30 +09:00"));
379 assertEquals(dt, f.withZone(TOKYO).parseDateTime("2007-03-04 12:30 +09:00"));
380 assertEquals(dt.withZone(DateTimeZone.forOffsetHours(9)), f.withOffsetParsed().parseDateTime("2007-03-04 12:30 +09:00"));
381 }
382
383 public void test_printParseOffsetAndZone() {
384 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
385 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2).appendLiteral(' ').appendTimeZoneId();
386 DateTimeFormatter f = bld.toFormatter();
387
388 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
389 assertEquals("2007-03-04 12:30 +09:00 Asia/Tokyo", f.print(dt));
390 assertEquals(dt, f.withZone(TOKYO).parseDateTime("2007-03-04 12:30 +09:00 Asia/Tokyo"));
391 assertEquals(dt.withZone(PARIS), f.withZone(PARIS).parseDateTime("2007-03-04 12:30 +09:00 Asia/Tokyo"));
392 assertEquals(dt.withZone(DateTimeZone.forOffsetHours(9)), f.withOffsetParsed().parseDateTime("2007-03-04 12:30 +09:00 Asia/Tokyo"));
393 }
394
395 public void test_parseWrongOffset() {
396 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
397 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2);
398 DateTimeFormatter f = bld.toFormatter();
399
400 DateTime expected = new DateTime(2007, 3, 4, 12, 30, 0, DateTimeZone.forOffsetHours(7));
401 // parses offset time then adjusts to requested zone
402 assertEquals(expected.withZone(TOKYO), f.withZone(TOKYO).parseDateTime("2007-03-04 12:30 +07:00"));
403 // parses offset time returning offset zone
404 assertEquals(expected, f.withOffsetParsed().parseDateTime("2007-03-04 12:30 +07:00"));
405 // parses offset time then converts to default zone
406 assertEquals(expected.withZone(DateTimeZone.getDefault()), f.parseDateTime("2007-03-04 12:30 +07:00"));
407 }
408
409 public void test_parseWrongOffsetAndZone() {
410 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
411 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2).appendLiteral(' ').appendTimeZoneId();
412 DateTimeFormatter f = bld.toFormatter();
413
414 DateTime expected = new DateTime(2007, 3, 4, 12, 30, 0, DateTimeZone.forOffsetHours(7));
415 // parses offset time then adjusts to parsed zone
416 assertEquals(expected.withZone(TOKYO), f.parseDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
417 // parses offset time then adjusts to requested zone
418 assertEquals(expected.withZone(TOKYO), f.withZone(TOKYO).parseDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
419 // parses offset time returning offset zone (ignores zone)
420 assertEquals(expected, f.withOffsetParsed().parseDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
421 }
422
423 //-----------------------------------------------------------------------
424 public void test_localPrintParseZoneTokyo() {
425 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
426 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneId();
427 DateTimeFormatter f = bld.toFormatter();
428
429 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
430 assertEquals("2007-03-04 12:30 Asia/Tokyo", f.print(dt));
431
432 LocalDateTime expected = new LocalDateTime(2007, 3, 4, 12, 30);
433 assertEquals(expected, f.parseLocalDateTime("2007-03-04 12:30 Asia/Tokyo"));
434 }
435
436 public void test_localPrintParseOffset() {
437 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
438 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2);
439 DateTimeFormatter f = bld.toFormatter();
440
441 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
442 assertEquals("2007-03-04 12:30 +09:00", f.print(dt));
443
444 LocalDateTime expected = new LocalDateTime(2007, 3, 4, 12, 30);
445 assertEquals(expected, f.parseLocalDateTime("2007-03-04 12:30 +09:00"));
446 assertEquals(expected, f.withZone(TOKYO).parseLocalDateTime("2007-03-04 12:30 +09:00"));
447 assertEquals(expected, f.withOffsetParsed().parseLocalDateTime("2007-03-04 12:30 +09:00"));
448 }
449
450 public void test_localPrintParseOffsetAndZone() {
451 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
452 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2).appendLiteral(' ').appendTimeZoneId();
453 DateTimeFormatter f = bld.toFormatter();
454
455 DateTime dt = new DateTime(2007, 3, 4, 12, 30, 0, TOKYO);
456 assertEquals("2007-03-04 12:30 +09:00 Asia/Tokyo", f.print(dt));
457
458 LocalDateTime expected = new LocalDateTime(2007, 3, 4, 12, 30);
459 assertEquals(expected, f.withZone(TOKYO).parseLocalDateTime("2007-03-04 12:30 +09:00 Asia/Tokyo"));
460 assertEquals(expected, f.withZone(PARIS).parseLocalDateTime("2007-03-04 12:30 +09:00 Asia/Tokyo"));
461 }
462
463 public void test_localParseWrongOffsetAndZone() {
464 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
465 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneOffset("Z", true, 2, 2).appendLiteral(' ').appendTimeZoneId();
466 DateTimeFormatter f = bld.toFormatter();
467
468 LocalDateTime expected = new LocalDateTime(2007, 3, 4, 12, 30);
469 // parses offset time then adjusts to parsed zone
470 assertEquals(expected, f.parseLocalDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
471 // parses offset time then adjusts to requested zone
472 assertEquals(expected, f.withZone(TOKYO).parseLocalDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
473 // parses offset time returning offset zone (ignores zone)
474 assertEquals(expected, f.withOffsetParsed().parseLocalDateTime("2007-03-04 12:30 +07:00 Asia/Tokyo"));
475 }
476
477 //-----------------------------------------------------------------------
478 public void test_printParseShortName() {
479 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
480 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneShortName();
481 DateTimeFormatter f = bld.toFormatter().withLocale(Locale.ENGLISH);
482
483 assertEquals(true, f.isPrinter());
484 assertEquals(false, f.isParser());
485 DateTime dt1 = new DateTime(2011, 1, 4, 12, 30, 0, LONDON);
486 assertEquals("2011-01-04 12:30 GMT", f.print(dt1));
487 DateTime dt2 = new DateTime(2011, 7, 4, 12, 30, 0, LONDON);
488 assertEquals("2011-07-04 12:30 BST", f.print(dt2));
489 try {
490 f.parseDateTime("2007-03-04 12:30 GMT");
491 fail();
492 } catch (UnsupportedOperationException e) {
493 }
494 }
495
496 public void test_printParseShortNameWithLookup() {
497 Map<String, DateTimeZone> lookup = new LinkedHashMap<String, DateTimeZone>();
498 lookup.put("GMT", LONDON);
499 lookup.put("BST", LONDON);
500 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
501 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneShortName(lookup);
502 DateTimeFormatter f = bld.toFormatter().withLocale(Locale.ENGLISH);
503
504 assertEquals(true, f.isPrinter());
505 assertEquals(true, f.isParser());
506 DateTime dt1 = new DateTime(2011, 1, 4, 12, 30, 0, LONDON);
507 assertEquals("2011-01-04 12:30 GMT", f.print(dt1));
508 DateTime dt2 = new DateTime(2011, 7, 4, 12, 30, 0, LONDON);
509 assertEquals("2011-07-04 12:30 BST", f.print(dt2));
510
511 assertEquals(dt1, f.parseDateTime("2011-01-04 12:30 GMT"));
512 assertEquals(dt2, f.parseDateTime("2011-07-04 12:30 BST"));
513 try {
514 f.parseDateTime("2007-03-04 12:30 EST");
515 fail();
516 } catch (IllegalArgumentException e) {
517 }
518 }
519
520 public void test_printParseShortNameWithAutoLookup() {
521 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
522 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneShortName(null);
523 DateTimeFormatter f = bld.toFormatter().withLocale(Locale.ENGLISH);
524
525 assertEquals(true, f.isPrinter());
526 assertEquals(true, f.isParser());
527 DateTime dt1 = new DateTime(2011, 1, 4, 12, 30, 0, NEW_YORK);
528 assertEquals("2011-01-04 12:30 EST", f.print(dt1));
529 DateTime dt2 = new DateTime(2011, 7, 4, 12, 30, 0, NEW_YORK);
530 assertEquals("2011-07-04 12:30 EDT", f.print(dt2));
531 DateTime dt3 = new DateTime(2011, 1, 4, 12, 30, 0, LOS_ANGELES);
532 assertEquals("2011-01-04 12:30 PST", f.print(dt3));
533 DateTime dt4 = new DateTime(2011, 7, 4, 12, 30, 0, LOS_ANGELES);
534 assertEquals("2011-07-04 12:30 PDT", f.print(dt4));
535
536 assertEquals(dt1.getZone() + " " + f.parseDateTime("2011-01-04 12:30 EST").getZone(), dt1, f.parseDateTime("2011-01-04 12:30 EST"));
537 assertEquals(dt2, f.parseDateTime("2011-07-04 12:30 EDT"));
538 assertEquals(dt3, f.parseDateTime("2011-01-04 12:30 PST"));
539 assertEquals(dt4, f.parseDateTime("2011-07-04 12:30 PDT"));
540 try {
541 f.parseDateTime("2007-03-04 12:30 PPP");
542 fail();
543 } catch (IllegalArgumentException e) {
544 }
545 }
546
547 //-----------------------------------------------------------------------
548 public void test_printParseLongName() {
549 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
550 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneName();
551 DateTimeFormatter f = bld.toFormatter().withLocale(Locale.ENGLISH);
552
553 assertEquals(true, f.isPrinter());
554 assertEquals(false, f.isParser());
555 DateTime dt1 = new DateTime(2011, 1, 4, 12, 30, 0, LONDON);
556 assertEquals("2011-01-04 12:30 Greenwich Mean Time", f.print(dt1));
557 DateTime dt2 = new DateTime(2011, 7, 4, 12, 30, 0, LONDON);
558 assertEquals("2011-07-04 12:30 British Summer Time", f.print(dt2));
559 try {
560 f.parseDateTime("2007-03-04 12:30 GMT");
561 fail();
562 } catch (UnsupportedOperationException e) {
563 }
564 }
565
566 public void test_printParseLongNameWithLookup() {
567 Map<String, DateTimeZone> lookup = new LinkedHashMap<String, DateTimeZone>();
568 lookup.put("Greenwich Mean Time", LONDON);
569 lookup.put("British Summer Time", LONDON);
570 DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder()
571 .appendPattern("yyyy-MM-dd HH:mm ").appendTimeZoneName(lookup);
572 DateTimeFormatter f = bld.toFormatter().withLocale(Locale.ENGLISH);
573
574 assertEquals(true, f.isPrinter());
575 assertEquals(true, f.isParser());
576 DateTime dt1 = new DateTime(2011, 1, 4, 12, 30, 0, LONDON);
577 assertEquals("2011-01-04 12:30 Greenwich Mean Time", f.print(dt1));
578 DateTime dt2 = new DateTime(2011, 7, 4, 12, 30, 0, LONDON);
579 assertEquals("2011-07-04 12:30 British Summer Time", f.print(dt2));
580
581 assertEquals(dt1, f.parseDateTime("2011-01-04 12:30 Greenwich Mean Time"));
582 assertEquals(dt2, f.parseDateTime("2011-07-04 12:30 British Summer Time"));
583 try {
584 f.parseDateTime("2007-03-04 12:30 EST");
585 fail();
586 } catch (IllegalArgumentException e) {
587 }
588 }
589
590 }