View Javadoc

1   /*
2    *  Copyright 2001-2011 Stephen Colebourne
3    *
4    *  Licensed under the Apache License, Version 2.0 (the "License");
5    *  you may not use this file except in compliance with the License.
6    *  You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *  Unless required by applicable law or agreed to in writing, software
11   *  distributed under the License is distributed on an "AS IS" BASIS,
12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *  See the License for the specific language governing permissions and
14   *  limitations under the License.
15   */
16  package org.joda.time.format;
17  
18  import java.util.LinkedHashMap;
19  import java.util.Locale;
20  import java.util.Map;
21  
22  import junit.framework.TestCase;
23  import junit.framework.TestSuite;
24  
25  import org.joda.time.DateTime;
26  import org.joda.time.DateTimeFieldType;
27  import org.joda.time.DateTimeZone;
28  import org.joda.time.LocalDateTime;
29  
30  /**
31   * This class is a Junit unit test for DateTimeFormatterBuilder.
32   *
33   * @author Stephen Colebourne
34   * @author Brian S O'Neill
35   */
36  public class TestDateTimeFormatterBuilder extends TestCase {
37  
38      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
39      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
40      private static final DateTimeZone TOKYO = DateTimeZone.forID("Asia/Tokyo");
41      private static final DateTimeZone NEW_YORK = DateTimeZone.forID("America/New_York");
42      private static final DateTimeZone LOS_ANGELES = DateTimeZone.forID("America/Los_Angeles");
43  
44      public static void main(String[] args) {
45          junit.textui.TestRunner.run(suite());
46      }
47  
48      public static TestSuite suite() {
49          return new TestSuite(TestDateTimeFormatterBuilder.class);
50      }
51  
52      public TestDateTimeFormatterBuilder(String name) {
53          super(name);
54      }
55  
56      protected void setUp() throws Exception {
57      }
58  
59      protected void tearDown() throws Exception {
60      }
61  
62      //-----------------------------------------------------------------------
63      public void test_toFormatter() {
64          DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
65          try {
66              bld.toFormatter();
67              fail();
68          } catch (UnsupportedOperationException ex) {}
69          bld.appendLiteral('X');
70          assertNotNull(bld.toFormatter());
71      }
72  
73      public void test_toPrinter() {
74          DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
75          try {
76              bld.toPrinter();
77              fail();
78          } catch (UnsupportedOperationException ex) {}
79          bld.appendLiteral('X');
80          assertNotNull(bld.toPrinter());
81      }
82  
83      public void test_toParser() {
84          DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
85          try {
86              bld.toParser();
87              fail();
88          } catch (UnsupportedOperationException ex) {}
89          bld.appendLiteral('X');
90          assertNotNull(bld.toParser());
91      }
92  
93      //-----------------------------------------------------------------------
94      public void test_canBuildFormatter() {
95          DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
96          assertEquals(false, bld.canBuildFormatter());
97          bld.appendLiteral('X');
98          assertEquals(true, bld.canBuildFormatter());
99      }
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 }