001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.commons.validator.routines;
018:
019: import java.text.Format;
020: import java.text.DateFormat;
021: import java.util.Calendar;
022: import java.util.Date;
023: import java.util.Locale;
024: import java.util.TimeZone;
025:
026: /**
027: * Test Case for CalendarValidator.
028: *
029: * @version $Revision: 478334 $ $Date: 2006-11-22 21:31:54 +0000 (Wed, 22 Nov 2006) $
030: */
031: public class CalendarValidatorTest extends BaseCalendarValidatorTest {
032:
033: private static final int DATE_2005_11_23 = 20051123;
034: private static final int TIME_12_03_45 = 120345;
035:
036: private CalendarValidator calValidator;
037:
038: /**
039: * Main
040: * @param args arguments
041: */
042: public static void main(String[] args) {
043: junit.textui.TestRunner.run(CalendarValidatorTest.class);
044: }
045:
046: /**
047: * Constructor
048: * @param name test name
049: */
050: public CalendarValidatorTest(String name) {
051: super (name);
052: }
053:
054: protected void setUp() throws Exception {
055: super .setUp();
056: calValidator = new CalendarValidator();
057: validator = calValidator;
058: }
059:
060: /**
061: * Test CalendarValidator validate Methods
062: */
063: public void testCalendarValidatorMethods() {
064: Locale.setDefault(Locale.US);
065: Locale locale = Locale.GERMAN;
066: String pattern = "yyyy-MM-dd";
067: String patternVal = "2005-12-31";
068: String germanVal = "31 Dez 2005";
069: String germanPattern = "dd MMM yyyy";
070: String localeVal = "31.12.2005";
071: String defaultVal = "12/31/05";
072: String XXXX = "XXXX";
073: Date expected = createCalendar(null, 20051231, 0).getTime();
074: assertEquals("validate(A) default", expected, CalendarValidator
075: .getInstance().validate(defaultVal).getTime());
076: assertEquals("validate(A) locale ", expected, CalendarValidator
077: .getInstance().validate(localeVal, locale).getTime());
078: assertEquals("validate(A) pattern", expected, CalendarValidator
079: .getInstance().validate(patternVal, pattern).getTime());
080: assertEquals("validate(A) both", expected, CalendarValidator
081: .getInstance().validate(germanVal, germanPattern,
082: Locale.GERMAN).getTime());
083:
084: assertTrue("isValid(A) default", CalendarValidator
085: .getInstance().isValid(defaultVal));
086: assertTrue("isValid(A) locale ", CalendarValidator
087: .getInstance().isValid(localeVal, locale));
088: assertTrue("isValid(A) pattern", CalendarValidator
089: .getInstance().isValid(patternVal, pattern));
090: assertTrue("isValid(A) both", CalendarValidator.getInstance()
091: .isValid(germanVal, germanPattern, Locale.GERMAN));
092:
093: assertNull("validate(B) default", CalendarValidator
094: .getInstance().validate(XXXX));
095: assertNull("validate(B) locale ", CalendarValidator
096: .getInstance().validate(XXXX, locale));
097: assertNull("validate(B) pattern", CalendarValidator
098: .getInstance().validate(XXXX, pattern));
099: assertNull("validate(B) both", CalendarValidator.getInstance()
100: .validate("31 Dec 2005", germanPattern, Locale.GERMAN));
101:
102: assertFalse("isValid(B) default", CalendarValidator
103: .getInstance().isValid(XXXX));
104: assertFalse("isValid(B) locale ", CalendarValidator
105: .getInstance().isValid(XXXX, locale));
106: assertFalse("isValid(B) pattern", CalendarValidator
107: .getInstance().isValid(XXXX, pattern));
108: assertFalse("isValid(B) both", CalendarValidator.getInstance()
109: .isValid("31 Dec 2005", germanPattern, Locale.GERMAN));
110:
111: // Test Time Zone
112: TimeZone zone = (TimeZone.getDefault().getRawOffset() == EET
113: .getRawOffset() ? EST : EET);
114: Date expectedZone = createCalendar(zone, 20051231, 0).getTime();
115: assertFalse("default/EET same ",
116: expected.getTime() == expectedZone.getTime());
117:
118: assertEquals("validate(C) default", expectedZone,
119: CalendarValidator.getInstance().validate(defaultVal,
120: zone).getTime());
121: assertEquals("validate(C) locale ", expectedZone,
122: CalendarValidator.getInstance().validate(localeVal,
123: locale, zone).getTime());
124: assertEquals("validate(C) pattern", expectedZone,
125: CalendarValidator.getInstance().validate(patternVal,
126: pattern, zone).getTime());
127: assertEquals("validate(C) both", expectedZone,
128: CalendarValidator.getInstance().validate(germanVal,
129: germanPattern, Locale.GERMAN, zone).getTime());
130: }
131:
132: /**
133: * Test compare date methods
134: */
135: public void testCompare() {
136: int sameTime = 124522;
137: int testDate = 20050823;
138: Calendar diffHour = createCalendar(GMT, testDate, 115922); // same date, different time
139: Calendar diffMin = createCalendar(GMT, testDate, 124422); // same date, different time
140: Calendar diffSec = createCalendar(GMT, testDate, 124521); // same date, different time
141:
142: Calendar value = createCalendar(GMT, testDate, sameTime); // test value
143: Calendar cal20050824 = createCalendar(GMT, 20050824, sameTime); // +1 day
144: Calendar cal20050822 = createCalendar(GMT, 20050822, sameTime); // -1 day
145:
146: Calendar cal20050830 = createCalendar(GMT, 20050830, sameTime); // +1 week
147: Calendar cal20050816 = createCalendar(GMT, 20050816, sameTime); // -1 week
148:
149: Calendar cal20050901 = createCalendar(GMT, 20050901, sameTime); // +1 month
150: Calendar cal20050801 = createCalendar(GMT, 20050801, sameTime); // same month
151: Calendar cal20050731 = createCalendar(GMT, 20050731, sameTime); // -1 month
152:
153: Calendar cal20051101 = createCalendar(GMT, 20051101, sameTime); // +1 quarter (Feb Start)
154: Calendar cal20051001 = createCalendar(GMT, 20051001, sameTime); // +1 quarter
155: Calendar cal20050701 = createCalendar(GMT, 20050701, sameTime); // same quarter
156: Calendar cal20050630 = createCalendar(GMT, 20050630, sameTime); // -1 quarter
157:
158: Calendar cal20060101 = createCalendar(GMT, 20060101, sameTime); // +1 year
159: Calendar cal20050101 = createCalendar(GMT, 20050101, sameTime); // same year
160: Calendar cal20041231 = createCalendar(GMT, 20041231, sameTime); // -1 year
161:
162: assertEquals("hour GT", 1, calValidator.compare(value,
163: diffHour, Calendar.HOUR_OF_DAY));
164: assertEquals("hour EQ", 0, calValidator.compare(value, diffMin,
165: Calendar.HOUR_OF_DAY));
166: assertEquals("mins GT", 1, calValidator.compare(value, diffMin,
167: Calendar.MINUTE));
168: assertEquals("mins EQ", 0, calValidator.compare(value, diffSec,
169: Calendar.MINUTE));
170: assertEquals("secs GT", 1, calValidator.compare(value, diffSec,
171: Calendar.SECOND));
172:
173: assertEquals("date LT", -1, calValidator.compareDates(value,
174: cal20050824)); // +1 day
175: assertEquals("date EQ", 0, calValidator.compareDates(value,
176: diffHour)); // same day, diff hour
177: assertEquals("date(B)", 0, calValidator.compare(value,
178: diffHour, Calendar.DAY_OF_YEAR)); // same day, diff hour
179: assertEquals("date GT", 1, calValidator.compareDates(value,
180: cal20050822)); // -1 day
181:
182: assertEquals("week LT", -1, calValidator.compareWeeks(value,
183: cal20050830)); // +1 week
184: assertEquals("week =1", 0, calValidator.compareWeeks(value,
185: cal20050824)); // +1 day
186: assertEquals("week =2", 0, calValidator.compareWeeks(value,
187: cal20050822)); // same week
188: assertEquals("week =3", 0, calValidator.compare(value,
189: cal20050822, Calendar.WEEK_OF_MONTH)); // same week
190: assertEquals("week =4", 0, calValidator.compareWeeks(value,
191: cal20050822)); // -1 day
192: assertEquals("week GT", 1, calValidator.compareWeeks(value,
193: cal20050816)); // -1 week
194:
195: assertEquals("mnth LT", -1, calValidator.compareMonths(value,
196: cal20050901)); // +1 month
197: assertEquals("mnth =1", 0, calValidator.compareMonths(value,
198: cal20050830)); // +1 week
199: assertEquals("mnth =2", 0, calValidator.compareMonths(value,
200: cal20050801)); // same month
201: assertEquals("mnth =3", 0, calValidator.compareMonths(value,
202: cal20050816)); // -1 week
203: assertEquals("mnth GT", 1, calValidator.compareMonths(value,
204: cal20050731)); // -1 month
205:
206: assertEquals("qtrA <1", -1, calValidator.compareQuarters(value,
207: cal20051101)); // +1 quarter (Feb)
208: assertEquals("qtrA <2", -1, calValidator.compareQuarters(value,
209: cal20051001)); // +1 quarter
210: assertEquals("qtrA =1", 0, calValidator.compareQuarters(value,
211: cal20050901)); // +1 month
212: assertEquals("qtrA =2", 0, calValidator.compareQuarters(value,
213: cal20050701)); // same quarter
214: assertEquals("qtrA =3", 0, calValidator.compareQuarters(value,
215: cal20050731)); // -1 month
216: assertEquals("qtrA GT", 1, calValidator.compareQuarters(value,
217: cal20050630)); // -1 quarter
218:
219: // Change quarter 1 to start in Feb
220: assertEquals("qtrB LT", -1, calValidator.compareQuarters(value,
221: cal20051101, 2)); // +1 quarter (Feb)
222: assertEquals("qtrB =1", 0, calValidator.compareQuarters(value,
223: cal20051001, 2)); // same quarter
224: assertEquals("qtrB =2", 0, calValidator.compareQuarters(value,
225: cal20050901, 2)); // +1 month
226: assertEquals("qtrB =3", 1, calValidator.compareQuarters(value,
227: cal20050701, 2)); // same quarter
228: assertEquals("qtrB =4", 1, calValidator.compareQuarters(value,
229: cal20050731, 2)); // -1 month
230: assertEquals("qtrB GT", 1, calValidator.compareQuarters(value,
231: cal20050630, 2)); // -1 quarter
232:
233: assertEquals("year LT", -1, calValidator.compareYears(value,
234: cal20060101)); // +1 year
235: assertEquals("year EQ", 0, calValidator.compareYears(value,
236: cal20050101)); // same year
237: assertEquals("year GT", 1, calValidator.compareYears(value,
238: cal20041231)); // -1 year
239:
240: // invalid compare
241: try {
242: calValidator.compare(value, value, -1);
243: fail("Invalid Compare field - expected IllegalArgumentException to be thrown");
244: } catch (IllegalArgumentException e) {
245: assertEquals("check message", "Invalid field: -1", e
246: .getMessage());
247: }
248: }
249:
250: /**
251: * Test Date/Time style Validator (there isn't an implementation for this)
252: */
253: public void testDateTimeStyle() {
254: // Set the default Locale
255: Locale origDefault = Locale.getDefault();
256: Locale.setDefault(Locale.UK);
257:
258: AbstractCalendarValidator dateTimeValidator = new AbstractCalendarValidator(
259: true, DateFormat.SHORT, DateFormat.SHORT) {
260: protected Object processParsedValue(Object value,
261: Format formatter) {
262: return value;
263: }
264: };
265: assertTrue("validate(A) default", dateTimeValidator
266: .isValid("31/12/05 14:23"));
267: assertTrue("validate(A) locale ", dateTimeValidator.isValid(
268: "12/31/05 2:23 PM", Locale.US));
269:
270: // Restore the original default
271: Locale.setDefault(origDefault);
272: }
273:
274: /**
275: * Test format methods
276: */
277: public void testFormat() {
278: // Set the default Locale
279: Locale origDefault = Locale.getDefault();
280: Locale.setDefault(Locale.UK);
281:
282: Calendar cal20050101 = createCalendar(GMT, 20051231, 11500);
283: assertNull("null", calValidator.format(null));
284: assertEquals("default", "31/12/05", calValidator
285: .format(cal20050101));
286: assertEquals("locale", "12/31/05", calValidator.format(
287: cal20050101, Locale.US));
288: assertEquals("patternA", "2005-12-31 01:15", calValidator
289: .format(cal20050101, "yyyy-MM-dd HH:mm"));
290: assertEquals("patternB", "2005-12-31 GMT", calValidator.format(
291: cal20050101, "yyyy-MM-dd z"));
292: assertEquals("both", "31 Dez 2005", calValidator.format(
293: cal20050101, "dd MMM yyyy", Locale.GERMAN));
294:
295: // EST Time Zone
296: assertEquals("EST default", "30/12/05", calValidator.format(
297: cal20050101, EST));
298: assertEquals("EST locale", "12/30/05", calValidator.format(
299: cal20050101, Locale.US, EST));
300: assertEquals("EST patternA", "2005-12-30 20:15", calValidator
301: .format(cal20050101, "yyyy-MM-dd HH:mm", EST));
302: assertEquals("EST patternB", "2005-12-30 EST", calValidator
303: .format(cal20050101, "yyyy-MM-dd z", EST));
304: assertEquals("EST both", "30 Dez 2005", calValidator.format(
305: cal20050101, "dd MMM yyyy", Locale.GERMAN, EST));
306:
307: // Restore the original default
308: Locale.setDefault(origDefault);
309: }
310:
311: /**
312: * Test adjustToTimeZone() method
313: */
314: public void testAdjustToTimeZone() {
315:
316: Calendar calEST = createCalendar(EST, DATE_2005_11_23,
317: TIME_12_03_45);
318: Date dateEST = calEST.getTime();
319:
320: Calendar calGMT = createCalendar(GMT, DATE_2005_11_23,
321: TIME_12_03_45);
322: Date dateGMT = calGMT.getTime();
323:
324: Calendar calCET = createCalendar(EET, DATE_2005_11_23,
325: TIME_12_03_45);
326: Date dateCET = calCET.getTime();
327:
328: // Check the dates don't match
329: assertFalse("Check GMT != CET", dateGMT.getTime() == dateCET
330: .getTime());
331: assertFalse("Check GMT != EST", dateGMT.getTime() == dateEST
332: .getTime());
333: assertFalse("Check CET != EST", dateCET.getTime() == dateEST
334: .getTime());
335:
336: // EST to GMT and back
337: CalendarValidator.adjustToTimeZone(calEST, GMT);
338: assertEquals("EST to GMT", dateGMT, calEST.getTime());
339: assertFalse("Check EST = GMT", dateEST == calEST.getTime());
340: CalendarValidator.adjustToTimeZone(calEST, EST);
341: assertEquals("back to EST", dateEST, calEST.getTime());
342: assertFalse("Check EST != GMT", dateGMT == calEST.getTime());
343:
344: // CET to GMT and back
345: CalendarValidator.adjustToTimeZone(calCET, GMT);
346: assertEquals("CET to GMT", dateGMT, calCET.getTime());
347: assertFalse("Check CET = GMT", dateCET == calCET.getTime());
348: CalendarValidator.adjustToTimeZone(calCET, EET);
349: assertEquals("back to CET", dateCET, calCET.getTime());
350: assertFalse("Check CET != GMT", dateGMT == calCET.getTime());
351:
352: // Adjust to TimeZone with Same rules
353: Calendar calUTC = createCalendar(UTC, DATE_2005_11_23,
354: TIME_12_03_45);
355: assertTrue("SAME: UTC = GMT", UTC.hasSameRules(GMT));
356: assertEquals("SAME: Check time (A)", calUTC.getTime(), calGMT
357: .getTime());
358: assertFalse("SAME: Check GMT(A)", GMT.equals(calUTC
359: .getTimeZone()));
360: assertTrue("SAME: Check UTC(A)", UTC.equals(calUTC
361: .getTimeZone()));
362: CalendarValidator.adjustToTimeZone(calUTC, GMT);
363: assertEquals("SAME: Check time (B)", calUTC.getTime(), calGMT
364: .getTime());
365: assertTrue("SAME: Check GMT(B)", GMT.equals(calUTC
366: .getTimeZone()));
367: assertFalse("SAME: Check UTC(B)", UTC.equals(calUTC
368: .getTimeZone()));
369: }
370:
371: }
|