1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.validator;
18
19 import org.apache.commons.validator.util.ValidatorUtils;
20
21 /***
22 * Contains validation methods for different unit tests.
23 *
24 * @version $Revision: 478334 $ $Date: 2006-11-22 21:31:54 +0000 (Wed, 22 Nov 2006) $
25 */
26 public class TestValidator {
27
28 /***
29 * Throws a runtime exception if the value of the argument is "RUNTIME",
30 * an exception if the value of the argument is "CHECKED", and a
31 * ValidatorException otherwise.
32 *
33 * @throws RuntimeException with "RUNTIME-EXCEPTION as message"
34 * if value is "RUNTIME"
35 * @throws Exception with "CHECKED-EXCEPTION" as message
36 * if value is "CHECKED"
37 * @throws ValidatorException with "VALIDATOR-EXCEPTION" as message
38 * otherwise
39 */
40 public static boolean validateRaiseException(
41 final Object bean,
42 final Field field)
43 throws Exception {
44
45 final String value =
46 ValidatorUtils.getValueAsString(bean, field.getProperty());
47
48 if ("RUNTIME".equals(value)) {
49 throw new RuntimeException("RUNTIME-EXCEPTION");
50
51 } else if ("CHECKED".equals(value)) {
52 throw new Exception("CHECKED-EXCEPTION");
53
54 } else {
55 throw new ValidatorException("VALIDATOR-EXCEPTION");
56 }
57 }
58
59 /***
60 * Checks if the field is required.
61 *
62 * @return boolean If the field isn't <code>null</code> and
63 * has a length greater than zero, <code>true</code> is returned.
64 * Otherwise <code>false</code>.
65 */
66 public static boolean validateRequired(Object bean, Field field) {
67 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
68
69 return !GenericValidator.isBlankOrNull(value);
70 }
71
72 /***
73 * Checks if the field can be successfully converted to a <code>byte</code>.
74 *
75 * @param value The value validation is being performed on.
76 * @return boolean If the field can be successfully converted
77 * to a <code>byte</code> <code>true</code> is returned.
78 * Otherwise <code>false</code>.
79 */
80 public static boolean validateByte(Object bean, Field field) {
81 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
82
83 return GenericValidator.isByte(value);
84 }
85
86 /***
87 * Checks if the field can be successfully converted to a <code>short</code>.
88 *
89 * @param value The value validation is being performed on.
90 * @return boolean If the field can be successfully converted
91 * to a <code>short</code> <code>true</code> is returned.
92 * Otherwise <code>false</code>.
93 */
94 public static boolean validateShort(Object bean, Field field) {
95 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
96
97 return GenericValidator.isShort(value);
98 }
99
100 /***
101 * Checks if the field can be successfully converted to a <code>int</code>.
102 *
103 * @param value The value validation is being performed on.
104 * @return boolean If the field can be successfully converted
105 * to a <code>int</code> <code>true</code> is returned.
106 * Otherwise <code>false</code>.
107 */
108 public static boolean validateInt(Object bean, Field field) {
109 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
110
111 return GenericValidator.isInt(value);
112 }
113
114 /***
115 * Checks if field is positive assuming it is an integer
116 *
117 * @param value The value validation is being performed on.
118 * @param field Description of the field to be evaluated
119 * @return boolean If the integer field is greater than zero, returns
120 * true, otherwise returns false.
121 */
122 public static boolean validatePositive(Object bean , Field field) {
123 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
124
125 return GenericTypeValidator.formatInt(value).intValue() > 0;
126 }
127
128 /***
129 * Checks if the field can be successfully converted to a <code>long</code>.
130 *
131 * @param value The value validation is being performed on.
132 * @return boolean If the field can be successfully converted
133 * to a <code>long</code> <code>true</code> is returned.
134 * Otherwise <code>false</code>.
135 */
136 public static boolean validateLong(Object bean, Field field) {
137 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
138
139 return GenericValidator.isLong(value);
140 }
141
142 /***
143 * Checks if the field can be successfully converted to a <code>float</code>.
144 *
145 * @param value The value validation is being performed on.
146 * @return boolean If the field can be successfully converted
147 * to a <code>float</code> <code>true</code> is returned.
148 * Otherwise <code>false</code>.
149 */
150 public static boolean validateFloat(Object bean, Field field) {
151 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
152
153 return GenericValidator.isFloat(value);
154 }
155
156 /***
157 * Checks if the field can be successfully converted to a <code>double</code>.
158 *
159 * @param value The value validation is being performed on.
160 * @return boolean If the field can be successfully converted
161 * to a <code>double</code> <code>true</code> is returned.
162 * Otherwise <code>false</code>.
163 */
164 public static boolean validateDouble(Object bean, Field field) {
165 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
166
167 return GenericValidator.isDouble(value);
168 }
169
170 /***
171 * Checks if the field is an e-mail address.
172 *
173 * @param value The value validation is being performed on.
174 * @return boolean If the field is an e-mail address
175 * <code>true</code> is returned.
176 * Otherwise <code>false</code>.
177 */
178 public static boolean validateEmail(Object bean, Field field) {
179 String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
180
181 return GenericValidator.isEmail(value);
182 }
183
184 public final static String FIELD_TEST_NULL = "NULL";
185 public final static String FIELD_TEST_NOTNULL = "NOTNULL";
186 public final static String FIELD_TEST_EQUAL = "EQUAL";
187
188 public static boolean validateRequiredIf(
189 Object bean,
190 Field field,
191 Validator validator) {
192
193 Object form = validator.getParameterValue(Validator.BEAN_PARAM);
194 String value = null;
195 boolean required = false;
196 if (isString(bean)) {
197 value = (String) bean;
198 } else {
199 value = ValidatorUtils.getValueAsString(bean, field.getProperty());
200 }
201 int i = 0;
202 String fieldJoin = "AND";
203 if (!GenericValidator.isBlankOrNull(field.getVarValue("fieldJoin"))) {
204 fieldJoin = field.getVarValue("fieldJoin");
205 }
206 if (fieldJoin.equalsIgnoreCase("AND")) {
207 required = true;
208 }
209 while (!GenericValidator.isBlankOrNull(field.getVarValue("field[" + i + "]"))) {
210 String dependProp = field.getVarValue("field[" + i + "]");
211 String dependTest = field.getVarValue("fieldTest[" + i + "]");
212 String dependTestValue = field.getVarValue("fieldValue[" + i + "]");
213 String dependIndexed = field.getVarValue("fieldIndexed[" + i + "]");
214 if (dependIndexed == null)
215 dependIndexed = "false";
216 String dependVal = null;
217 boolean this_required = false;
218 if (field.isIndexed() && dependIndexed.equalsIgnoreCase("true")) {
219 String key = field.getKey();
220 if ((key.indexOf("[") > -1) && (key.indexOf("]") > -1)) {
221 String ind = key.substring(0, key.indexOf(".") + 1);
222 dependProp = ind + dependProp;
223 }
224 }
225 dependVal = ValidatorUtils.getValueAsString(form, dependProp);
226 if (dependTest.equals(FIELD_TEST_NULL)) {
227 if ((dependVal != null) && (dependVal.length() > 0)) {
228 this_required = false;
229 } else {
230 this_required = true;
231 }
232 }
233 if (dependTest.equals(FIELD_TEST_NOTNULL)) {
234 if ((dependVal != null) && (dependVal.length() > 0)) {
235 this_required = true;
236 } else {
237 this_required = false;
238 }
239 }
240 if (dependTest.equals(FIELD_TEST_EQUAL)) {
241 this_required = dependTestValue.equalsIgnoreCase(dependVal);
242 }
243 if (fieldJoin.equalsIgnoreCase("AND")) {
244 required = required && this_required;
245 } else {
246 required = required || this_required;
247 }
248 i++;
249 }
250 if (required) {
251 if ((value != null) && (value.length() > 0)) {
252 return true;
253 } else {
254 return false;
255 }
256 }
257 return true;
258 }
259
260 private static Class stringClass = new String().getClass();
261
262 private static boolean isString(Object o) {
263 if (o == null) return true;
264 return (stringClass.isInstance(o));
265 }
266
267 }