001: // Copyright (c) 2003-2007, Jodd Team (jodd.sf.net). All Rights Reserved.
002:
003: package jodd.datetime;
004:
005: import java.util.Calendar;
006: import java.util.Date;
007: import java.util.GregorianCalendar;
008: import java.util.TimeZone;
009:
010: import junit.framework.TestCase;
011:
012: public class JDateTimeTest extends TestCase {
013:
014: public void testSetGetMillis() {
015: JDateTime jdt = new JDateTime(2003, 2, 28, 23, 59, 59.000);
016:
017: for (int i = 0; i < 1000; i++) {
018: jdt.setMillisecond(i);
019: assertEquals(i, jdt.getMillisecond());
020: }
021: }
022:
023: public void testSet999Millis() {
024:
025: JDateTime jdt = new JDateTime();
026:
027: jdt.set(2003, 2, 28, 23, 59, 59.999);
028: assertEquals("2003-02-28 23:59:59.999", jdt.toString());
029:
030: jdt.set(2003, 2, 28, 23, 59, 60.0);
031: assertEquals("2003-03-01 00:00:00.000", jdt.toString());
032:
033: // this used to be a problem
034: jdt.set(2003, 2, 28, 23, 59, 59.999999); // 6 fraction digits
035: assertEquals("2003-02-28 23:59:59.999", jdt.toString());
036:
037: // this used to be a problem
038: jdt.set(2003, 2, 28, 23, 59, 59.999999999999); // 12 fraction digits - last working
039: assertEquals("2003-02-28 23:59:59.999", jdt.toString());
040:
041: jdt.set(2003, 2, 28, 23, 59, 59.9999999999999); // 13 fraction digits
042: assertEquals("2003-02-28 23:59:59.999", jdt.toString());
043:
044: jdt.set(2003, 2, 28, 23, 59, 59.99999999999999); // 14 fraction digits (max)
045: assertEquals("2003-02-28 23:59:59.999", jdt.toString());
046:
047: jdt.set(2003, 2, 28, 23, 59, 59.999999999999999); // 15 decimals -> 59.9....9 = 60.0
048: assertEquals("2003-03-01 00:00:00.000", jdt.toString());
049: }
050:
051: public void testDaysInMonth() {
052: JDateTime jdt = new JDateTime(2003, 1, 1);
053: assertEquals(31, jdt.getMonthLength());
054: assertEquals(28, jdt.getMonthLength(2));
055:
056: jdt = new JDateTime(2000, 1, 1);
057: assertEquals(31, jdt.getMonthLength());
058: assertEquals(29, jdt.getMonthLength(2));
059: }
060:
061: public void testToString() {
062:
063: JDateTime jdt = new JDateTime(2003, 1, 1, 1, 1, 01.001);
064: assertEquals("2003-01-01 01:01:01.001", jdt.toString());
065:
066: jdt.set(200, 10, 10, 10, 10, 10.012);
067: assertEquals("0200-10-10 10:10:10.012", jdt.toString());
068:
069: jdt.set(2003, 10, 10, 10, 10, 10.123);
070: assertEquals("2003-10-10 10:10:10.123", jdt.toString());
071: }
072:
073: public void testAddMonths() {
074: JDateTime gt = new JDateTime(2003, 1, 31);
075: gt.setMonthFix(Boolean.FALSE);
076: gt.addMonth(1);
077: assertEquals("2003-03-03 00:00:00.000", gt.toString());
078:
079: gt.setDate(2003, 1, 31);
080: gt.addMonth(1, true);
081: assertEquals("2003-02-28 00:00:00.000", gt.toString());
082:
083: gt.setDate(2004, 1, 31);
084: gt.addMonth(1);
085: assertEquals("2004-03-02 00:00:00.000", gt.toString());
086:
087: gt.setDate(2004, 1, 31);
088: gt.addMonth(1, true);
089: assertEquals("2004-02-29 00:00:00.000", gt.toString());
090:
091: gt.setDate(2003, 1, 25);
092: gt.add(0, 1, 6, true);
093: assertEquals("2003-02-28 00:00:00.000", gt.toString());
094:
095: gt.setDate(2003, 1, 20);
096: gt.add(0, 10, 11, true);
097: assertEquals("2003-11-30 00:00:00.000", gt.toString());
098:
099: gt.setDate(2004, 2, 29);
100: gt.addYear(1, true);
101: assertEquals("2005-02-28 00:00:00.000", gt.toString());
102:
103: gt.setDate(2004, 2, 29);
104: gt.addYear(-1, true);
105: assertEquals("2003-02-28 00:00:00.000", gt.toString());
106:
107: gt.setDate(2003, 11, 31); // == 2003-12-01
108: gt.add(0, -8, -31, true);
109: assertEquals("2003-02-28 00:00:00.000", gt.toString());
110: gt.setDate(2003, 11, 31);
111: gt.add(0, -8, -31, false);
112: assertEquals("2003-03-01 00:00:00.000", gt.toString());
113:
114: gt.setDate(2004, 5, 31);
115: gt.addMonth(-3, true);
116: assertEquals("2004-02-29 00:00:00.000", gt.toString());
117: gt.setDate(2003, 11, 31);
118: gt.addMonth(-10, true);
119: assertEquals("2003-02-01 00:00:00.000", gt.toString());
120:
121: }
122:
123: public void testMiscSetsGets() {
124: JDateTime gt = new JDateTime(2003, 11, 26, 21, 8, 25.173);
125:
126: gt.setYear(2002);
127: assertEquals(2002, gt.getYear());
128:
129: gt.setMonth(10);
130: assertEquals(10, gt.getMonth());
131:
132: gt.setDay(27);
133: assertEquals(27, gt.getDay());
134:
135: gt.setHour(22);
136: assertEquals(22, gt.getHour());
137:
138: gt.setMinute(8);
139: assertEquals(8, gt.getMinute());
140:
141: gt.setSecond(24);
142: assertEquals(24, (int) gt.getSecond());
143: assertEquals(24.173, gt.getSecond(), 0.0005);
144:
145: gt.setSecond(25.371);
146: assertEquals(25.371, gt.getSecond(), 0.0005);
147:
148: gt.setMillisecond(173);
149: assertEquals(173, gt.getMillisecond());
150:
151: assertEquals("2002-10-27 22:08:25.173", gt.toString());
152:
153: }
154:
155: public void testLeapYears() {
156:
157: JDateTime gt = new JDateTime(1984, 2, 29);
158: assertTrue(gt.isLeapYear());
159: assertEquals("1984-02-29 00:00:00.000", gt.toString());
160:
161: gt.set(1985, 2, 29);
162: assertFalse(gt.isLeapYear());
163: assertEquals("1985-03-01 00:00:00.000", gt.toString());
164:
165: gt.set(2004, 2, 29);
166: assertTrue(gt.isLeapYear());
167: assertEquals("2004-02-29 00:00:00.000", gt.toString());
168:
169: gt.set(1900, 2, 29);
170: assertFalse(gt.isLeapYear()); // not a leap year
171: assertEquals("1900-03-01 00:00:00.000", gt.toString());
172:
173: gt.set(2000, 2, 29);
174: assertTrue(gt.isLeapYear()); // a leap year
175: assertEquals("2000-02-29 00:00:00.000", gt.toString());
176:
177: gt.set(1600, 2, 29);
178: assertTrue(gt.isLeapYear()); // a leap year
179: assertEquals("1600-02-29 00:00:00.000", gt.toString());
180:
181: for (int y = -4700; y < 5000; y++) {
182: gt.set(y, 2, 29);
183: assertEquals(31 + 29, gt.getDayOfYear());
184: if (gt.isLeapYear()) {
185: assertEquals(29, gt.getDay());
186: } else {
187: assertEquals(1, gt.getDay());
188: }
189: }
190: }
191:
192: public void testFormatTemplates() {
193: JDateTime jdt = new JDateTime(1975, 1, 1);
194: assertEquals("2442413.5", jdt.getJulianDate().toString());
195: assertEquals("1975-01-01 00:00:00.000", jdt.toString());
196:
197: jdt.setFormat("YYYY.MM.DD");
198: assertEquals("1975.01.01", jdt.toString());
199:
200: String defaultTemplate = JDateTime.DEFAULT_FORMAT;
201: JDateTime.DEFAULT_FORMAT = "YYYY/MM/DD hh:mm";
202: assertEquals("1975.01.01", jdt.toString());
203:
204: jdt.setFormat(null);
205: assertEquals("1975/01/01 00:00", jdt.toString());
206:
207: assertEquals("01: January (Jan)", jdt.toString("MM: MML (MMS)"));
208: assertEquals("01 is 3: Wednesday (Wed)", jdt
209: .toString("DD is D: DL (DS)"));
210:
211: jdt.addDay(27);
212: assertEquals("028 / 05 / W05", jdt.toString("DDD / WW / WWW"));
213:
214: JDateTime.DEFAULT_FORMAT = defaultTemplate;
215: }
216:
217: public void testQuotes() {
218: JDateTime jdt = new JDateTime(1968, 9, 30);
219: assertEquals(
220: "SHE WAS Bsample'O'R'N ON 30 September 1968",
221: jdt
222: .toString("SHE 'WAS' 'Bsample''O''R''N' ON DD MML YYYY"));
223: assertEquals("5 is a week number and W is a letter", jdt
224: .toString("W is a week number and 'W is a letter"));
225: assertEquals("1968YYYYY.", jdt.toString("YYYY'YYYYY'."));
226: assertEquals("19681968Y.", jdt.toString("YYYYYYYYY'."));
227: assertEquals("YY1968YYY", jdt.toString("'YY'YYYY'YY'Y"));
228: assertEquals("30 o'day DD30", jdt.toString("DD 'o''day DD'DD"));
229:
230: }
231:
232: public void testSetFromString() {
233: JDateTime jdt = new JDateTime();
234: jdt.fromString("2003-11-24 23:18:38.173");
235: assertEquals("2003-11-24 23:18:38.173", jdt.toString());
236:
237: jdt.fromString("2003-11-23");
238: assertEquals("2003-11-23 00:00:00.000", jdt.toString());
239:
240: jdt.fromString("2003-14-23");
241: assertEquals("2004-02-23 00:00:00.000", jdt.toString());
242:
243: jdt.fromString("2003-4-3");
244: assertEquals("2003-04-03 00:00:00.000", jdt.toString());
245:
246: jdt.fromString("2003-4-x");
247: assertEquals("2003-04-03 00:00:00.000", jdt.toString()); // because of error, date is not changed
248:
249: jdt.fromString("2003-11-23 13:67");
250: assertEquals("2003-11-23 14:07:00.000", jdt.toString());
251:
252: jdt.fromString("2003-11-23 13:07:55");
253: assertEquals("2003-11-23 13:07:55.000", jdt.toString());
254:
255: jdt.fromString("2003-11-23 13:07:5");
256: assertEquals("2003-11-23 13:07:05.000", jdt.toString());
257:
258: jdt.fromString("123456-7-8");
259: assertEquals("123456-07-08 00:00:00.000", jdt.toString());
260:
261: jdt.fromString("2003-11-23");
262: assertEquals("2003-11-23 00:00:00.000", jdt.toString());
263: }
264:
265: public void testLoadFromStoreTo() {
266: Calendar c = Calendar.getInstance();
267: c.set(2001, 0, 1, 2, 3, 4);
268: c.set(Calendar.MILLISECOND, 500);
269: JDateTime jdt = new JDateTime();
270: jdt.loadFrom(c);
271: assertEquals("2001-01-01 02:03:04.500", jdt.toString());
272: Calendar c1 = jdt.convertToCalendar();
273: assertEquals(2001, c1.get(Calendar.YEAR));
274: assertEquals(0, c1.get(Calendar.MONTH));
275: assertEquals(1, c1.get(Calendar.DAY_OF_MONTH));
276: assertEquals(2, c1.get(Calendar.HOUR_OF_DAY));
277: assertEquals(3, c1.get(Calendar.MINUTE));
278: assertEquals(4, c1.get(Calendar.SECOND));
279: assertEquals(500, c1.get(Calendar.MILLISECOND));
280:
281: GregorianCalendar gc = new GregorianCalendar(2002, 5, 2, 3, 4,
282: 5);
283: gc.set(GregorianCalendar.MILLISECOND, 600);
284: jdt.loadFrom(gc);
285: assertEquals("2002-06-02 03:04:05.600", jdt.toString());
286: GregorianCalendar gc1 = new GregorianCalendar();
287: jdt.storeTo(gc1);
288: assertEquals(2002, gc1.get(GregorianCalendar.YEAR));
289: assertEquals(5, gc1.get(GregorianCalendar.MONTH));
290: assertEquals(2, gc1.get(GregorianCalendar.DAY_OF_MONTH));
291: assertEquals(3, gc1.get(GregorianCalendar.HOUR_OF_DAY));
292: assertEquals(4, gc1.get(GregorianCalendar.MINUTE));
293: assertEquals(5, gc1.get(GregorianCalendar.SECOND));
294: assertEquals(600, gc1.get(GregorianCalendar.MILLISECOND));
295:
296: Date d = new Date(101, 2, 3, 4, 5, 6);
297: jdt.loadFrom(d);
298: assertEquals("2001-03-03 04:05:06.000", jdt.toString());
299: Date d2 = jdt.convertToDate();
300: assertEquals(101, d2.getYear());
301: assertEquals(2, d2.getMonth());
302: assertEquals(3, d2.getDate());
303: assertEquals(4, d2.getHours());
304: assertEquals(5, d2.getMinutes());
305: assertEquals(6, d2.getSeconds());
306:
307: JDateTime gt_new = new JDateTime(2003, 6, 5, 4, 3, 2.1);
308: jdt.setJulianDate(gt_new.getJulianDate());
309: assertEquals("2003-06-05 04:03:02.100", jdt.toString());
310: JDateTime gt2 = (JDateTime) jdt.clone();
311: assertEquals(2003, gt2.getYear());
312: assertEquals(6, gt2.getMonth());
313: assertEquals(5, gt2.getDay());
314: assertEquals(4, gt2.getHour());
315: assertEquals(3, gt2.getMinute());
316: assertEquals(2, (int) gt2.getSecond());
317: assertEquals(100, gt2.getMillisecond());
318:
319: java.sql.Date sd = new java.sql.Date(123, 4, 5);
320: jdt.loadFrom(sd);
321: assertEquals("2023-05-05 00:00:00.000", jdt.toString());
322: java.sql.Date sd2 = new java.sql.Date(1, 2, 3);
323: jdt.storeTo(sd2);
324: assertEquals(123, sd2.getYear());
325: assertEquals(4, sd2.getMonth());
326: assertEquals(5, sd2.getDate());
327:
328: java.sql.Timestamp st = new java.sql.Timestamp(123, 4, 5, 6, 7,
329: 8, 500000000);
330: jdt.loadFrom(st);
331: assertEquals("2023-05-05 06:07:08.500", jdt.toString());
332: java.sql.Timestamp st2 = jdt.convertToSqlTimestamp();
333: assertEquals(123, st2.getYear());
334: assertEquals(4, st2.getMonth());
335: assertEquals(5, st2.getDate());
336: assertEquals(6, st2.getHours());
337: assertEquals(7, st2.getMinutes());
338: assertEquals(8, st2.getSeconds());
339: assertEquals(500, st2.getNanos() / 1000000);
340: }
341:
342: public void testMillis() {
343: GregorianCalendar gc = new GregorianCalendar();
344: JDateTime jdt = new JDateTime();
345:
346: long now = System.currentTimeMillis();
347: gc.setTimeInMillis(now);
348: jdt.setTimeInMillis(now);
349: assertEquals(now, jdt.getTimeInMillis());
350: assertEquals(gc.getTimeInMillis(), jdt.getTimeInMillis());
351:
352: JDateTime jdt2 = new JDateTime();
353: jdt2.setTimeInMillis(jdt.getTimeInMillis());
354: assertEquals(jdt.toString(), jdt2.toString());
355: assertEquals(gc.getTimeInMillis(), jdt2.getTimeInMillis());
356:
357: for (int year = 1000; year < 3000; year++) {
358: if (year == 1582) {
359: continue;
360: }
361: jdt.setYear(year);
362: jdt.setMillisecond(0);
363: gc.set(Calendar.YEAR, year);
364: gc.set(Calendar.MILLISECOND, 0);
365: for (int month = 1; month <= 12; month++) {
366: jdt.setMonth(month);
367: gc.set(Calendar.MONTH, month - 1);
368: for (int sec = 0; sec < 60; sec++) {
369: jdt.setSecond(sec);
370: gc.set(Calendar.SECOND, sec);
371: assertEquals(gc.getTimeInMillis(), jdt
372: .getTimeInMillis());
373:
374: jdt.setTimeInMillis(gc.getTimeInMillis());
375: gc.setTimeInMillis(gc.getTimeInMillis());
376: assertEquals(gc.getTimeInMillis(), jdt
377: .getTimeInMillis());
378: }
379: }
380: }
381: }
382:
383: public void testTimeZones() {
384: GregorianCalendar gc = new GregorianCalendar();
385: JDateTime jdt1 = new JDateTime();
386: gc.setTimeInMillis(jdt1.getTimeInMillis());
387:
388: TimeZone tz = TimeZone.getTimeZone("GMT+01:00");
389: jdt1.setTimeZone(tz);
390: gc.setTimeZone(tz);
391: assertEquals(gc.getTimeInMillis(), jdt1.getTimeInMillis());
392:
393: JDateTime jdt2 = (JDateTime) jdt1.clone();
394: assertEquals(jdt1, jdt2);
395:
396: tz = TimeZone.getTimeZone("GMT+02:00");
397: jdt2.setTimeZone(tz);
398: gc.setTimeZone(tz);
399: assertEquals(gc.getTimeInMillis(), jdt1.getTimeInMillis());
400:
401: if (jdt2.getHour() != 0) {
402: assertEquals(jdt1.getHour() + 1, jdt2.getHour());
403: assertEquals(jdt1.getMinute(), jdt2.getMinute());
404: assertEquals((int) jdt1.getSecond(), (int) jdt2.getSecond());
405: }
406:
407: tz = TimeZone.getTimeZone("GMT-12:00");
408: jdt1.setTimeZone(tz);
409: gc.setTimeZone(tz);
410: assertEquals(gc.getTimeInMillis(), jdt1.getTimeInMillis());
411:
412: tz = TimeZone.getTimeZone("GMT+10:00");
413: jdt2.setTimeZone(tz);
414: gc.setTimeZone(tz);
415: assertEquals(gc.getTimeInMillis(), jdt2.getTimeInMillis());
416: assertEquals(jdt1.getTimeInMillis(), jdt2.getTimeInMillis());
417:
418: java.util.Date date = jdt1.convertToDate();
419: assertEquals(date.getTime(), jdt1.getTimeInMillis());
420:
421: GregorianCalendar cal = jdt1.convertToGregorianCalendar();
422: assertEquals(cal.getTimeInMillis(), jdt1.getTimeInMillis());
423: assertEquals(cal.getTimeZone(), jdt1.getTimeZone());
424:
425: java.sql.Date sqlDate = jdt1.convertToSqlDate();
426: assertEquals(sqlDate.getTime(), jdt1.getTimeInMillis());
427:
428: java.sql.Timestamp sqlTimestamp = jdt1.convertToSqlTimestamp();
429: assertEquals(sqlTimestamp.getTime(), jdt1.getTimeInMillis());
430: }
431:
432: }
|