Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.validator.routines.AbstractCalendarValidator |
99% |
97% |

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 |  |
     package org.apache.commons.validator.routines;
18 |  |
19 |  |
     import java.text.DateFormatSymbols;
20 |  |
     import java.text.Format;
21 |  |
     import java.text.DateFormat;
22 |  |
     import java.text.SimpleDateFormat;
23 |  |
     import java.util.Calendar;
24 |  |
     import java.util.Locale;
25 |  |
     import java.util.TimeZone;
26 |  |
27 |  |
     /**
28 |  |
      * <p>Abstract class for Date/Time/Calendar validation.</p>
29 |  |
      *
30 |  |
      * <p>This is a <i>base</i> class for building Date / Time
31 |  |
      *    Validators using format parsing.</p>
32 |  |
      *
33 |  |
      * @version $Revision: 478334 $ $Date: 2006-11-22 21:31:54 +0000 (Wed, 22 Nov 2006) $
34 |  |
      * @since Validator 1.3.0
35 |  |
      */
36 |  |
     public abstract class AbstractCalendarValidator extends AbstractFormatValidator {
37 |  |
38 | 27 |
         private int dateStyle = -1;
39 |  |
40 | 27 |
         private int timeStyle = -1;
41 |  |
42 |  |
         /**
43 |  |
          * Construct an instance with the specified <i>strict</i>,
44 |  |
          * <i>time</i> and <i>date</i> style parameters.
45 |  |
          *
46 |  |
          * @param strict <code>true</code> if strict
47 |  |
          *        <code>Format</code> parsing should be used.
48 |  |
          * @param dateStyle the date style to use for Locale validation.
49 |  |
          * @param timeStyle the time style to use for Locale validation.
50 |  |
          */
51 |  |
         public AbstractCalendarValidator(boolean strict, int dateStyle, class="keyword">int timeStyle) {
52 | 27 |
             super(strict);
53 | 27 |
             this.dateStyle = dateStyle;
54 | 27 |
             this.timeStyle = timeStyle;
55 | 27 |
         }
56 |  |
57 |  |
         /**
58 |  |
          * <p>Validate using the specified <code>Locale</code>.
59 |  |
          *
60 |  |
          * @param value The value validation is being performed on.
61 |  |
          * @param pattern The pattern used to format the value.
62 |  |
          * @param locale The locale to use for the Format, defaults to the default
63 |  |
          * @return <code>true</code> if the value is valid.
64 |  |
          */
65 |  |
         public boolean isValid(String value, String pattern, Locale locale) {
66 | 134 |
             Object parsedValue = parse(value, pattern, locale, (TimeZone)null);
67 | 134 |
             return (parsedValue == null ? false : true);
68 |  |
         }
69 |  |
70 |  |
         /**
71 |  |
          * <p>Format an object into a <code>String</code> using
72 |  |
          * the default Locale.</p>
73 |  |
          *
74 |  |
          * @param value The value validation is being performed on.
75 |  |
          * @param timeZone The Time Zone used to format the date,
76 |  |
          *  system default if null (unless value is a <code>Calendar</code>.
77 |  |
          * @return The value formatted as a <code>String</code>.
78 |  |
          */
79 |  |
         public String format(Object value, TimeZone timeZone) {
80 | 1 |
             return format(value, (String)null, (Locale)class="keyword">null, timeZone);
81 |  |
         }
82 |  |
83 |  |
         /**
84 |  |
          * <p>Format an object into a <code>String</code> using
85 |  |
          * the specified pattern.</p>
86 |  |
          *
87 |  |
          * @param value The value validation is being performed on.
88 |  |
          * @param pattern The pattern used to format the value.
89 |  |
          * @param timeZone The Time Zone used to format the date,
90 |  |
          *  system default if null (unless value is a <code>Calendar</code>.
91 |  |
          * @return The value formatted as a <code>String</code>.
92 |  |
          */
93 |  |
         public String format(Object value, String pattern, TimeZone timeZone) {
94 | 2 |
             return format(value, pattern, (Locale)null, timeZone);
95 |  |
         }
96 |  |
97 |  |
         /**
98 |  |
          * <p>Format an object into a <code>String</code> using
99 |  |
          * the specified Locale.</p>
100 |  |
          *
101 |  |
          * @param value The value validation is being performed on.
102 |  |
          * @param locale The locale to use for the Format.
103 |  |
          * @param timeZone The Time Zone used to format the date,
104 |  |
          *  system default if null (unless value is a <code>Calendar</code>.
105 |  |
          * @return The value formatted as a <code>String</code>.
106 |  |
          */
107 |  |
         public String format(Object value, Locale locale, TimeZone timeZone) {
108 | 1 |
             return format(value, (String)null, locale, timeZone);
109 |  |
         }
110 |  |
111 |  |
         /**
112 |  |
          * <p>Format an object using the specified pattern and/or
113 |  |
          *    <code>Locale</code>.
114 |  |
          *
115 |  |
          * @param value The value validation is being performed on.
116 |  |
          * @param pattern The pattern used to format the value.
117 |  |
          * @param locale The locale to use for the Format.
118 |  |
          * @return The value formatted as a <code>String</code>.
119 |  |
          */
120 |  |
         public String format(Object value, String pattern, Locale locale) {
121 | 11 |
             return format(value, pattern, locale, (TimeZone)null);
122 |  |
         }
123 |  |
124 |  |
         /**
125 |  |
          * <p>Format an object using the specified pattern and/or
126 |  |
          *    <code>Locale</code>.
127 |  |
          *
128 |  |
          * @param value The value validation is being performed on.
129 |  |
          * @param pattern The pattern used to format the value.
130 |  |
          * @param locale The locale to use for the Format.
131 |  |
          * @param timeZone The Time Zone used to format the date,
132 |  |
          *  system default if null (unless value is a <code>Calendar</code>.
133 |  |
          * @return The value formatted as a <code>String</code>.
134 |  |
          */
135 |  |
         public String format(Object value, String pattern, Locale locale, TimeZone timeZone) {
136 | 16 |
             DateFormat formatter = (DateFormat)getFormat(pattern, locale);
137 | 16 |
             if (timeZone != null) {
138 | 5 |
                 formatter.setTimeZone(timeZone);
139 | 11 |
             } else if (value instanceof Calendar) {
140 | 8 |
                 formatter.setTimeZone(((Calendar)value).getTimeZone());
141 |  |
             }
142 | 16 |
             return format(value, formatter);
143 |  |
         }
144 |  |
145 |  |
         /**
146 |  |
          * <p>Format a value with the specified <code>DateFormat</code>.</p>
147 |  |
          *
148 |  |
          * @param value The value to be formatted.
149 |  |
          * @param formatter The Format to use.
150 |  |
          * @return The formatted value.
151 |  |
          */
152 |  |
         protected String format(Object value, Format formatter) {
153 | 16 |
             if (value == null) {
154 | 1 |
                 return null;
155 | 15 |
             } else if (value instanceof Calendar) {
156 | 13 |
                 value = ((Calendar)value).getTime();
157 |  |
             }
158 | 15 |
             return formatter.format(value);
159 |  |
         }
160 |  |
161 |  |
         /**
162 |  |
          * <p>Checks if the value is valid against a specified pattern.</p>
163 |  |
          *
164 |  |
          * @param value The value validation is being performed on.
165 |  |
          * @param pattern The pattern used to validate the value against, or the
166 |  |
          *        default for the <code>Locale</code> if <code>null</code>.
167 |  |
          * @param locale The locale to use for the date format, system default if null.
168 |  |
          * @param timeZone The Time Zone used to parse the date, system default if null.
169 |  |
          * @return The parsed value if valid or <code>null</code> if invalid.
170 |  |
          */
171 |  |
         protected Object parse(String value, String pattern, Locale locale, TimeZone timeZone) {
172 |  |
173 | 282 |
             value = (value == null ? class="keyword">null : value.trim());
174 | 282 |
             if (value == null || value.length() == 0) {
175 | 0 |
                 return null;
176 |  |
             }
177 | 282 |
             DateFormat formatter = (DateFormat)getFormat(pattern, locale);
178 | 282 |
             if (timeZone != null) {
179 | 12 |
                 formatter.setTimeZone(timeZone);
180 |  |
             }
181 | 282 |
             return parse(value, formatter);
182 |  |
183 |  |
         }
184 |  |
185 |  |
         /**
186 |  |
          * <p>Process the parsed value, performing any further validation
187 |  |
          *    and type conversion required.</p>
188 |  |
          *
189 |  |
          * @param value The parsed object created.
190 |  |
          * @param formatter The Format used to parse the value with.
191 |  |
          * @return The parsed value converted to the appropriate type
192 |  |
          *         if valid or <code>null</code> if invalid.
193 |  |
          */
194 |  |
         protected abstract Object processParsedValue(Object value, Format formatter);
195 |  |
196 |  |
         /**
197 |  |
          * <p>Returns a <code>DateFormat</code> for the specified <i>pattern</i>
198 |  |
          *    and/or <code>Locale</code>.</p>
199 |  |
          *
200 |  |
          * @param pattern The pattern used to validate the value against or
201 |  |
          *        <code>null</code> to use the default for the <code>Locale</code>.
202 |  |
          * @param locale The locale to use for the currency format, system default if null.
203 |  |
          * @return The <code>DateFormat</code> to created.
204 |  |
          */
205 |  |
         protected Format getFormat(String pattern, Locale locale) {
206 | 298 |
             DateFormat formatter = null;
207 | 298 |
             boolean usePattern = (pattern != null && pattern.length() > 0);
208 | 298 |
             if (!usePattern) {
209 | 145 |
                 formatter = (DateFormat)getFormat(locale);
210 | 153 |
             } else if (locale == null) {
211 | 139 |
                 formatter = new SimpleDateFormat(pattern);
212 |  |
             } else {
213 | 14 |
                 DateFormatSymbols symbols = new DateFormatSymbols(locale);
214 | 14 |
                 formatter = new SimpleDateFormat(pattern, symbols);
215 |  |
             }
216 | 298 |
             formatter.setLenient(false);
217 | 298 |
             return formatter;
218 |  |
         }
219 |  |
220 |  |
         /**
221 |  |
          * <p>Returns a <code>DateFormat</code> for the specified Locale.</p>
222 |  |
          *
223 |  |
          * @param locale The locale a <code>DateFormat</code> is required for,
224 |  |
          *        system default if null.
225 |  |
          * @return The <code>DateFormat</code> to created.
226 |  |
          */
227 |  |
         protected Format getFormat(Locale locale) {
228 |  |
229 | 145 |
             DateFormat formatter = null;
230 | 145 |
             if (dateStyle >= 0 && timeStyle >= 0) {
231 | 2 |
                 if (locale == null) {
232 | 1 |
                     formatter = DateFormat.getDateTimeInstance(dateStyle, timeStyle);
233 |  |
                 } else {
234 | 1 |
                     formatter = DateFormat.getDateTimeInstance(dateStyle, timeStyle, locale);
235 |  |
                 }
236 | 143 |
             } else if (timeStyle >= 0) {
237 | 41 |
                 if (locale == null) {
238 | 3 |
                     formatter = DateFormat.getTimeInstance(timeStyle);
239 |  |
                 } else {
240 | 38 |
                     formatter = DateFormat.getTimeInstance(timeStyle, locale);
241 |  |
                 }
242 |  |
             } else {
243 | 102 |
                 int useDateStyle = dateStyle >= 0 ? dateStyle : DateFormat.SHORT;
244 | 102 |
                 if (locale == null) {
245 | 13 |
                     formatter = DateFormat.getDateInstance(useDateStyle);
246 |  |
                 } else {
247 | 89 |
                     formatter = DateFormat.getDateInstance(useDateStyle, locale);
248 |  |
                 }
249 |  |
             }
250 | 145 |
             formatter.setLenient(false);
251 | 145 |
             return formatter;
252 |  |
253 |  |
         }
254 |  |
255 |  |
         /**
256 |  |
          * <p>Compares a calendar value to another, indicating whether it is
257 |  |
          *    equal, less then or more than at a specified level.</p>
258 |  |
          *
259 |  |
          * @param value The Calendar value.
260 |  |
          * @param compare The <code>Calendar</code> to check the value against.
261 |  |
          * @param field The field <i>level</i> to compare to - e.g. specifying
262 |  |
          *        <code>Calendar.MONTH</code> will compare the year and month
263 |  |
          *        portions of the calendar.
264 |  |
          * @return Zero if the first value is equal to the second, -1
265 |  |
          *         if it is less than the second or +1 if it is greater than the second.
266 |  |
          */
267 |  |
         protected int compare(Calendar value, Calendar compare, class="keyword">int field) {
268 |  |
269 | 44 |
             int result = 0;
270 |  |
271 |  |
             // Compare Year
272 | 44 |
             result = calculateCompareResult(value, compare, Calendar.YEAR);
273 | 44 |
             if (result != 0 || field == Calendar.YEAR) {
274 | 6 |
                 return result;
275 |  |
             }
276 |  |
277 |  |
             // Compare Week of Year
278 | 38 |
             if (field == Calendar.WEEK_OF_YEAR) {
279 | 10 |
                 return calculateCompareResult(value, compare, Calendar.WEEK_OF_YEAR);
280 |  |
             }
281 |  |
282 |  |
             // Compare Day of the Year
283 | 28 |
             if (field == Calendar.DAY_OF_YEAR) {
284 | 1 |
                 return calculateCompareResult(value, compare, Calendar.DAY_OF_YEAR);
285 |  |
             }
286 |  |
287 |  |
             // Compare Month
288 | 27 |
             result = calculateCompareResult(value, compare, Calendar.MONTH);
289 | 27 |
             if (result != 0 || field == Calendar.MONTH) {
290 | 10 |
                 return result;
291 |  |
             }
292 |  |
293 |  |
             // Compare Week of Month
294 | 17 |
             if (field == Calendar.WEEK_OF_MONTH) {
295 | 1 |
                 return calculateCompareResult(value, compare, Calendar.WEEK_OF_MONTH);
296 |  |
             }
297 |  |
298 |  |
             // Compare Date
299 | 16 |
             result = calculateCompareResult(value, compare, Calendar.DATE);
300 | 16 |
             if (result != 0 || (field == Calendar.DATE ||
301 |  |
                               field == Calendar.DAY_OF_MONTH ||
302 |  |
                               field == Calendar.DAY_OF_WEEK ||
303 |  |
                               field == Calendar.DAY_OF_WEEK_IN_MONTH)) {
304 | 10 |
                 return result;
305 |  |
             }
306 |  |
307 |  |
             // Compare Time fields
308 | 6 |
             return compareTime(value, compare, field);
309 |  |
310 |  |
         }
311 |  |
312 |  |
         /**
313 |  |
          * <p>Compares a calendar time value to another, indicating whether it is
314 |  |
          *    equal, less then or more than at a specified level.</p>
315 |  |
          *
316 |  |
          * @param value The Calendar value.
317 |  |
          * @param compare The <code>Calendar</code> to check the value against.
318 |  |
          * @param field The field <i>level</i> to compare to - e.g. specifying
319 |  |
          *        <code>Calendar.MINUTE</code> will compare the hours and minutes
320 |  |
          *        portions of the calendar.
321 |  |
          * @return Zero if the first value is equal to the second, -1
322 |  |
          *         if it is less than the second or +1 if it is greater than the second.
323 |  |
          */
324 |  |
         protected int compareTime(Calendar value, Calendar compare, class="keyword">int field) {
325 |  |
326 | 24 |
             int result = 0;
327 |  |
328 |  |
             // Compare Hour
329 | 24 |
             result = calculateCompareResult(value, compare, Calendar.HOUR_OF_DAY);
330 | 24 |
             if (result != 0 || (field == Calendar.HOUR || field == Calendar.HOUR_OF_DAY)) {
331 | 7 |
                 return result;
332 |  |
             }
333 |  |
334 |  |
             // Compare Minute
335 | 17 |
             result = calculateCompareResult(value, compare, Calendar.MINUTE);
336 | 17 |
             if (result != 0 || field == Calendar.MINUTE) {
337 | 7 |
                 return result;
338 |  |
             }
339 |  |
340 |  |
             // Compare Second
341 | 10 |
             result = calculateCompareResult(value, compare, Calendar.SECOND);
342 | 10 |
             if (result != 0 || field == Calendar.SECOND) {
343 | 6 |
                 return result;
344 |  |
             }
345 |  |
346 |  |
             // Compare Milliseconds
347 | 4 |
             if (field == Calendar.MILLISECOND) {
348 | 3 |
                 return calculateCompareResult(value, compare, Calendar.MILLISECOND);
349 |  |
             }
350 |  |
351 | 1 |
             throw new IllegalArgumentException("Invalid field: " + field);
352 |  |
353 |  |
         }
354 |  |
355 |  |
         /**
356 |  |
          * <p>Compares a calendar's quarter value to another, indicating whether it is
357 |  |
          *    equal, less then or more than the specified quarter.</p>
358 |  |
          *
359 |  |
          * @param value The Calendar value.
360 |  |
          * @param compare The <code>Calendar</code> to check the value against.
361 |  |
          * @param monthOfFirstQuarter The  month that the first quarter starts.
362 |  |
          * @return Zero if the first quarter is equal to the second, -1
363 |  |
          *         if it is less than the second or +1 if it is greater than the second.
364 |  |
          */
365 |  |
         protected int compareQuarters(Calendar value, Calendar compare, class="keyword">int monthOfFirstQuarter) {
366 | 25 |
             int valueQuarter   = calculateQuarter(value, monthOfFirstQuarter);
367 | 25 |
             int compareQuarter = calculateQuarter(compare, monthOfFirstQuarter);
368 | 25 |
             if (valueQuarter < compareQuarter) {
369 | 6 |
                 return -1;
370 | 19 |
             } else if (valueQuarter > compareQuarter) {
371 | 9 |
                 return 1;
372 |  |
             } else {
373 | 10 |
                 return 0;
374 |  |
             }
375 |  |
         }
376 |  |
377 |  |
         /**
378 |  |
          * <p>Calculate the quarter for the specified Calendar.</p>
379 |  |
          *
380 |  |
          * @param calendar The Calendar value.
381 |  |
          * @param monthOfFirstQuarter The  month that the first quarter starts.
382 |  |
          * @return The calculated quarter.
383 |  |
          */
384 |  |
         private int calculateQuarter(Calendar calendar, class="keyword">int monthOfFirstQuarter) {
385 |  |
             // Add Year
386 | 50 |
             int year = calendar.get(Calendar.YEAR);
387 |  |
388 | 50 |
             int month = (calendar.get(Calendar.MONTH) + 1);
389 | 50 |
             int relativeMonth = (month >= monthOfFirstQuarter)
390 |  |
                               ? (month - monthOfFirstQuarter)
391 |  |
                               : (month + (12 - monthOfFirstQuarter));
392 | 50 |
             int quarter = ((relativeMonth / 3) + 1);
393 |  |
             // adjust the year if the quarter doesn't start in January
394 | 50 |
             if (month < monthOfFirstQuarter) {
395 | 1 |
                 --year;
396 |  |
             }
397 | 50 |
             return (year * 10) + quarter;
398 |  |
         }
399 |  |
400 |  |
         /**
401 |  |
          * <p>Compares the field from two calendars indicating whether the field for the
402 |  |
          *    first calendar is equal to, less than or greater than the field from the
403 |  |
          *    second calendar.
404 |  |
          *
405 |  |
          * @param value The Calendar value.
406 |  |
          * @param compare The <code>Calendar</code> to check the value against.
407 |  |
          * @param field The field to compare for the calendars.
408 |  |
          * @return Zero if the first calendar's field is equal to the seconds, -1
409 |  |
          *         if it is less than the seconds or +1 if it is greater than the seconds.
410 |  |
          */
411 |  |
         private int calculateCompareResult(Calendar value, Calendar compare, class="keyword">int field) {
412 | 153 |
             int difference = value.get(field) - compare.get(field);
413 | 153 |
             if (dclass="keyword">ifference < 0) {
414 | 13 |
                 return -1;
415 | 140 |
             } else if (dclass="keyword">ifference > 0) {
416 | 17 |
                 return 1;
417 |  |
             } else {
418 | 123 |
                 return 0;
419 |  |
             }
420 |  |
         }
421 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.