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