/apache-log4j-1.2.17/tests/src/java/org/apache/log4j/pattern/CachedDateFormatTest.java
Java | 393 lines | 232 code | 54 blank | 107 comment | 0 complexity | ddb5ced234fa89b3d6d4828a89b1f2ff MD5 | raw file
Possible License(s): Apache-2.0
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package org.apache.log4j.pattern;
19
20import junit.framework.Test;
21import junit.framework.TestCase;
22import junit.framework.TestSuite;
23
24import org.apache.log4j.pattern.CachedDateFormat;
25
26import java.text.DateFormat;
27import java.util.TimeZone;
28import java.util.Date;
29import java.text.SimpleDateFormat;
30import java.util.Locale;
31import java.util.Calendar;
32
33/**
34 Unit test {@link AbsoluteTimeDateFormat}.
35 @author Curt Arnold
36 */
37public final class CachedDateFormatTest
38 extends TestCase {
39
40 /**
41 * Test constructor
42 * @param name String test name
43 */
44 public CachedDateFormatTest(String name) {
45 super(name);
46 }
47
48 private static DateFormat createAbsoluteTimeDateFormat(TimeZone timeZone) {
49 DateFormat df = new SimpleDateFormat("HH:mm:ss,SSS");
50 df.setTimeZone(timeZone);
51 return df;
52 }
53
54
55 /**
56 * Timezone representing GMT.
57 */
58 private static final TimeZone GMT = TimeZone.getTimeZone("GMT");
59
60 /**
61 * Timezone for Chicago, Ill. USA.
62 */
63 private static final TimeZone CHICAGO = TimeZone.getTimeZone(
64 "America/Chicago");
65
66 /**
67 * Test multiple calls in close intervals.
68 */
69 public void test1() {
70 // subsequent calls within one minute
71 // are optimized to reuse previous formatted value
72 // make a couple of nearly spaced calls
73 DateFormat gmtFormat = new CachedDateFormat(createAbsoluteTimeDateFormat(GMT), 1000);
74 long ticks = 12601L * 86400000L;
75 Date jul1 = new Date(ticks);
76 assertEquals("00:00:00,000", gmtFormat.format(jul1));
77 Date plus8ms = new Date(ticks + 8);
78 assertEquals("00:00:00,008", gmtFormat.format(plus8ms));
79 Date plus17ms = new Date(ticks + 17);
80 assertEquals("00:00:00,017", gmtFormat.format(plus17ms));
81 Date plus237ms = new Date(ticks + 237);
82 assertEquals("00:00:00,237", gmtFormat.format(plus237ms));
83 Date plus1415ms = new Date(ticks + 1415);
84 assertEquals("00:00:01,415", gmtFormat.format(plus1415ms));
85 }
86
87 /**
88 * Check for interaction between caches.
89 */
90 public void test2() {
91 Date jul2 = new Date(12602L * 86400000L);
92 DateFormat gmtFormat = new CachedDateFormat(createAbsoluteTimeDateFormat(GMT), 1000);
93 DateFormat chicagoFormat = new CachedDateFormat(createAbsoluteTimeDateFormat(CHICAGO), 1000);
94 assertEquals("00:00:00,000", gmtFormat.format(jul2));
95 assertEquals("19:00:00,000", chicagoFormat.format(jul2));
96 assertEquals("00:00:00,000", gmtFormat.format(jul2));
97 }
98
99 /**
100 * Test multiple calls in close intervals prior to 1 Jan 1970.
101 */
102 public void test3() {
103 // subsequent calls within one minute
104 // are optimized to reuse previous formatted value
105 // make a couple of nearly spaced calls
106 DateFormat gmtFormat = new CachedDateFormat(
107 createAbsoluteTimeDateFormat(GMT), 1000);
108 //
109 // if the first call was exactly on an integral
110 // second, it would not test the round toward zero compensation
111 long ticks = -7L * 86400000L;
112 Date jul1 = new Date(ticks + 8);
113 assertEquals("00:00:00,008", gmtFormat.format(jul1));
114 Date plus8ms = new Date(ticks + 16);
115 assertEquals("00:00:00,016", gmtFormat.format(plus8ms));
116 Date plus17ms = new Date(ticks + 23);
117 assertEquals("00:00:00,023", gmtFormat.format(plus17ms));
118 Date plus237ms = new Date(ticks + 245);
119 assertEquals("00:00:00,245", gmtFormat.format(plus237ms));
120 Date plus1415ms = new Date(ticks + 1423);
121 assertEquals("00:00:01,423", gmtFormat.format(plus1415ms));
122 }
123
124 public void test4() {
125 // subsequent calls within one minute are optimized to reuse previous
126 // formatted value. make a couple of nearly spaced calls
127 // (Note: 'Z' is JDK 1.4, using 'z' instead.)
128 SimpleDateFormat baseFormat =
129 new SimpleDateFormat("EEE, MMM dd, HH:mm:ss.SSS z", Locale.ENGLISH);
130 DateFormat cachedFormat = new CachedDateFormat(baseFormat, 1000);
131 //
132 // use a date in 2000 to attempt to confuse the millisecond locator
133 long ticks = 11141L * 86400000L;
134 Date jul1 = new Date(ticks);
135 assertEquals(baseFormat.format(jul1), cachedFormat.format(jul1));
136 Date plus8ms = new Date(ticks + 8);
137 baseFormat.format(plus8ms);
138 cachedFormat.format(plus8ms);
139 assertEquals(baseFormat.format(plus8ms), cachedFormat.format(plus8ms));
140 Date plus17ms = new Date(ticks + 17);
141 assertEquals(baseFormat.format(plus17ms), cachedFormat.format(plus17ms));
142 Date plus237ms = new Date(ticks + 237);
143 assertEquals(baseFormat.format(plus237ms), cachedFormat.format(plus237ms));
144 Date plus1415ms = new Date(ticks + 1415);
145 assertEquals(baseFormat.format(plus1415ms), cachedFormat.format(plus1415ms));
146 }
147
148 public void test5() {
149 // subsequent calls within one minute
150 // are optimized to reuse previous formatted value
151 // make a couple of nearly spaced calls
152 // (Note: 'Z' is JDK 1.4, using 'z' instead.)
153 Locale thai = new Locale("th", "TH");
154 SimpleDateFormat baseFormat =
155 new SimpleDateFormat("EEE, MMM dd, HH:mm:ss.SSS z", thai);
156 DateFormat cachedFormat = new CachedDateFormat(baseFormat, 1000);
157 //
158 // use a date in the year 2000 CE to attempt to confuse the millisecond locator
159 long ticks = 11141L * 86400000L;
160
161 String sx;
162 Date jul1 = new Date(ticks);
163 sx = cachedFormat.format(jul1);
164 System.out.println(baseFormat.format(jul1));
165 System.out.println(sx);
166 assertEquals(baseFormat.format(jul1), sx);
167
168 sx = cachedFormat.format(jul1);
169 System.out.println(baseFormat.format(jul1));
170 System.out.println(sx);
171 assertEquals(baseFormat.format(jul1), sx);
172
173
174 Date plus8ms = new Date(ticks + 8);
175 sx = cachedFormat.format(plus8ms);
176 System.out.println(baseFormat.format(plus8ms));
177 System.out.println(sx);
178
179 assertEquals(baseFormat.format(plus8ms), sx);
180
181 Date plus17ms = new Date(ticks + 17);
182 assertEquals(baseFormat.format(plus17ms), cachedFormat.format(plus17ms));
183
184 Date plus237ms = new Date(ticks + 237);
185 assertEquals(baseFormat.format(plus237ms), cachedFormat.format(plus237ms));
186
187 Date plus1415ms = new Date(ticks + 1415);
188 assertEquals(baseFormat.format(plus1415ms), cachedFormat.format(plus1415ms));
189 }
190
191 /**
192 * Checks that getNumberFormat does not return null.
193 */
194 public void test6() {
195 assertNotNull(new CachedDateFormat(new SimpleDateFormat(), 1000).getNumberFormat());
196 }
197
198 /**
199 * Set time zone on cached and check that it is effective.
200 */
201 public void test8() {
202 DateFormat baseFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");
203 baseFormat.setTimeZone(GMT);
204 DateFormat cachedFormat = new CachedDateFormat(baseFormat, 1000);
205 Date jul4 = new Date(12603L * 86400000L);
206 assertEquals("2004-07-04 00:00:00,000", cachedFormat.format(jul4));
207 cachedFormat.setTimeZone(TimeZone.getTimeZone("GMT-6"));
208 assertEquals("2004-07-03 18:00:00,000", cachedFormat.format(jul4));
209 }
210
211
212 /**
213 * Test of caching when less than three millisecond digits are specified.
214 */
215 public void test9() {
216 // (Note: 'Z' is JDK 1.4, using 'z' instead.)
217 DateFormat baseFormat = new SimpleDateFormat("yyyy-MMMM-dd HH:mm:ss,SS z", Locale.US);
218 DateFormat cachedFormat = new CachedDateFormat(baseFormat, 1000);
219 TimeZone cet = TimeZone.getTimeZone("GMT+1");
220 cachedFormat.setTimeZone(cet);
221
222 Calendar c = Calendar.getInstance();
223 c.set(2004, Calendar.DECEMBER, 12, 20, 0);
224 c.set(Calendar.SECOND, 37);
225 c.set(Calendar.MILLISECOND, 23);
226 c.setTimeZone(cet);
227
228 String expected = baseFormat.format(c.getTime());
229 String s = cachedFormat.format(c.getTime());
230 assertEquals(expected, s);
231
232 c.set(2005, Calendar.JANUARY, 1, 0, 0);
233 c.set(Calendar.SECOND, 13);
234 c.set(Calendar.MILLISECOND, 905);
235
236 expected = baseFormat.format(c.getTime());
237 s = cachedFormat.format(c.getTime());
238 assertEquals(expected, s);
239 }
240
241
242 /**
243 * Test when millisecond position moves but length remains constant.
244 */
245 public void test10() {
246 DateFormat baseFormat = new SimpleDateFormat("MMMM SSS EEEEEE", Locale.US);
247 DateFormat cachedFormat = new CachedDateFormat(baseFormat, 1000);
248 TimeZone cet = TimeZone.getTimeZone("GMT+1");
249 cachedFormat.setTimeZone(cet);
250
251 Calendar c = Calendar.getInstance();
252 c.set(2004, Calendar.OCTOBER, 5, 20, 0);
253 c.set(Calendar.SECOND, 37);
254 c.set(Calendar.MILLISECOND, 23);
255 c.setTimeZone(cet);
256
257 String expected = baseFormat.format(c.getTime());
258 String s = cachedFormat.format(c.getTime());
259 assertEquals(expected, s);
260
261 c.set(2004, Calendar.NOVEMBER, 1, 0, 0);
262 c.set(Calendar.MILLISECOND, 23);
263 expected = baseFormat.format(c.getTime());
264 s = cachedFormat.format(c.getTime());
265 assertEquals(expected, s);
266
267
268 c.set(Calendar.MILLISECOND, 984);
269 expected = baseFormat.format(c.getTime());
270 s = cachedFormat.format(c.getTime());
271 assertEquals(expected, s);
272 }
273
274 /**
275 * Test that tests if caching is skipped if only "SS"
276 * is specified.
277 */
278 public void test11() {
279 //
280 // Earlier versions could be tricked by "SS0" patterns.
281 //
282 String badPattern = "ss,SS0";
283 SimpleDateFormat simpleFormat = new SimpleDateFormat(badPattern);
284 SimpleDateFormat baseFormat = new SimpleDateFormat(badPattern);
285 DateFormat gmtFormat = new CachedDateFormat(simpleFormat, 1000);
286 gmtFormat.setTimeZone(GMT);
287 baseFormat.setTimeZone(GMT);
288
289 //
290 // The first request has to 100 ms after an ordinal second
291 // to push the literal zero out of the pattern check
292 long ticks = 11142L * 86400000L;
293 Date jul2 = new Date(ticks + 120);
294 String expected = baseFormat.format(jul2);
295 assertEquals(expected, gmtFormat.format(jul2));
296 jul2.setTime(ticks + 87);
297
298
299 //
300 // Cache gives 00,087
301 expected = baseFormat.format(jul2);
302 assertEquals(expected, gmtFormat.format(jul2));
303
304 }
305
306 /**
307 * Check pattern location for ISO8601
308 */
309 public void test12() {
310 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");
311 long ticks = 11142L * 86400000L;
312 String formatted = df.format(new Date(ticks));
313 int millisecondStart = CachedDateFormat.findMillisecondStart(ticks, formatted, df);
314 assertEquals(20, millisecondStart);
315 }
316
317 /**
318 * Check pattern location for DATE
319 */
320 public void test13() {
321 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
322 long ticks = 11142L * 86400000L;
323 String formatted = df.format(new Date(ticks));
324 int millisecondStart = CachedDateFormat.findMillisecondStart(ticks, formatted, df);
325 assertEquals(CachedDateFormat.NO_MILLISECONDS, millisecondStart);
326 }
327
328 /**
329 * Check pattern location for ABSOLUTE
330 */
331 public void test14() {
332 SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss,SSS");
333 long ticks = 11142L * 86400000L;
334 String formatted = df.format(new Date(ticks));
335 int millisecondStart = CachedDateFormat.findMillisecondStart(ticks, formatted, df);
336 assertEquals(9, millisecondStart);
337 }
338
339 /**
340 * Check pattern location for single S
341 */
342 public void test15() {
343 SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss,S");
344 long ticks = 11142L * 86400000L;
345 String formatted = df.format(new Date(ticks));
346 int millisecondStart = CachedDateFormat.findMillisecondStart(ticks, formatted, df);
347 assertEquals(CachedDateFormat.UNRECOGNIZED_MILLISECONDS, millisecondStart);
348 }
349
350 /**
351 * Check pattern location for single SS
352 */
353 public void test16() {
354 SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss,SS");
355 long ticks = 11142L * 86400000L;
356 String formatted = df.format(new Date(ticks));
357 int millisecondStart = CachedDateFormat.findMillisecondStart(ticks, formatted, df);
358 assertEquals(CachedDateFormat.UNRECOGNIZED_MILLISECONDS, millisecondStart);
359 }
360
361
362 /**
363 * Check caching when multiple SSS appear in pattern
364 */
365 public void test17() {
366 Date jul2 = new Date(12602L * 86400000L);
367 String badPattern = "HH:mm:ss,SSS HH:mm:ss,SSS";
368 SimpleDateFormat simpleFormat = new SimpleDateFormat(badPattern);
369 simpleFormat.setTimeZone(GMT);
370 DateFormat cachedFormat = new CachedDateFormat(simpleFormat, 1000);
371 String s = cachedFormat.format(jul2);
372 assertEquals("00:00:00,000 00:00:00,000", s);
373 jul2.setTime(jul2.getTime() + 120);
374 assertEquals("00:00:00,120 00:00:00,120", simpleFormat.format(jul2));
375 s = cachedFormat.format(jul2);
376 //
377 // TODO: why is this returning ,120 ... , 120
378 //
379 //assertEquals("00:00:00,120 00:00:00,000", s) ;
380
381 int maxValid = CachedDateFormat.getMaximumCacheValidity(badPattern);
382 assertEquals(1, maxValid);
383 }
384
385
386 public static Test xsuite() {
387 TestSuite suite = new TestSuite();
388 suite.addTest(new CachedDateFormatTest("test5"));
389 //suite.addTest(new CachedDateFormatTest("testS2"));
390 return suite;
391 }
392
393}