Coverage Report - javax.faces.validator.DoubleRangeValidator
 
Classes in this File Line Coverage Branch Coverage Complexity
DoubleRangeValidator
92%
60/65
83%
20/24
1.789
 
 1   
 /*
 2   
  * Copyright 2004-2011 the Seasar Foundation and the Others.
 3   
  *
 4   
  * Licensed under the Apache License, Version 2.0 (the "License");
 5   
  * you may not use this file except in compliance with the License.
 6   
  * You may obtain a copy of the License at
 7   
  *
 8   
  *     http://www.apache.org/licenses/LICENSE-2.0
 9   
  *
 10   
  * Unless required by applicable law or agreed to in writing, software
 11   
  * distributed under the License is distributed on an "AS IS" BASIS,
 12   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 13   
  * either express or implied. See the License for the specific language
 14   
  * governing permissions and limitations under the License.
 15   
  */
 16   
 package javax.faces.validator;
 17   
 
 18   
 import javax.faces.application.FacesMessage;
 19   
 import javax.faces.component.StateHolder;
 20   
 import javax.faces.component.UIComponent;
 21   
 import javax.faces.context.FacesContext;
 22   
 import javax.faces.internal.FacesMessageUtil;
 23   
 import javax.faces.internal.UIComponentUtil;
 24   
 import javax.faces.internal.UIInputUtil;
 25   
 
 26   
 import org.seasar.framework.util.AssertionUtil;
 27   
 import org.seasar.framework.util.DoubleConversionUtil;
 28   
 
 29   
 /**
 30   
  * @author shot
 31   
  */
 32   
 public class DoubleRangeValidator implements Validator, StateHolder {
 33   
 
 34   
     public static final String VALIDATOR_ID = "javax.faces.DoubleRange";
 35   
 
 36   
     public static final String MAXIMUM_MESSAGE_ID = "javax.faces.validator.DoubleRangeValidator.MAXIMUM";
 37   
 
 38   
     public static final String MINIMUM_MESSAGE_ID = "javax.faces.validator.DoubleRangeValidator.MINIMUM";
 39   
 
 40   
     public static final String TYPE_MESSAGE_ID = "javax.faces.validator.DoubleRangeValidator.TYPE";
 41   
 
 42  85 
     private double maximum = Double.MAX_VALUE;
 43   
 
 44  85 
     private double minimum = Double.MIN_VALUE;
 45   
 
 46  85 
     private boolean transientValue = false;
 47   
 
 48  62 
     public DoubleRangeValidator() {
 49  62 
     }
 50   
 
 51  14 
     public DoubleRangeValidator(double maximum) {
 52  14 
         this.maximum = maximum;
 53  14 
     }
 54   
 
 55  9 
     public DoubleRangeValidator(double maximum, double minimum) {
 56  9 
         this.maximum = maximum;
 57  9 
         this.minimum = minimum;
 58  9 
     }
 59   
 
 60   
     public boolean equals(Object obj) {
 61  11 
         if (!(obj instanceof DoubleRangeValidator)) {
 62  1 
             return false;
 63   
         }
 64  10 
         DoubleRangeValidator v = (DoubleRangeValidator) obj;
 65  10 
         return maximum == v.maximum && minimum == v.minimum;
 66   
     }
 67   
 
 68   
     public int hashCode() {
 69  0 
         return (int) maximum * (int) minimum * 17;
 70   
     }
 71   
 
 72   
     public double getMaximum() {
 73  26 
         return maximum;
 74   
     }
 75   
 
 76   
     public double getMinimum() {
 77  23 
         return minimum;
 78   
     }
 79   
 
 80   
     public boolean isTransient() {
 81  16 
         return transientValue;
 82   
     }
 83   
 
 84   
     public void restoreState(FacesContext context, Object state) {
 85  16 
         Object[] obj = (Object[]) state;
 86  16 
         maximum = ((Double) obj[0]).doubleValue();
 87  16 
         minimum = ((Double) obj[1]).doubleValue();
 88  16 
     }
 89   
 
 90   
     public Object saveState(FacesContext context) {
 91  16 
         Object[] obj = new Object[2];
 92  16 
         obj[0] = new Double(maximum);
 93  16 
         obj[1] = new Double(minimum);
 94  16 
         return obj;
 95   
     }
 96   
 
 97   
     public void setMaximum(double maximum) {
 98  24 
         this.maximum = maximum;
 99  24 
     }
 100   
 
 101   
     public void setMinimum(double minimum) {
 102  31 
         this.minimum = minimum;
 103  31 
     }
 104   
 
 105   
     public void setTransient(boolean transientValue) {
 106  0 
         this.transientValue = transientValue;
 107  0 
     }
 108   
 
 109   
     public void validate(FacesContext context, UIComponent component,
 110   
             Object value) throws ValidatorException {
 111  14 
         AssertionUtil.assertNotNull("context", context);
 112  13 
         AssertionUtil.assertNotNull("component", component);
 113  12 
         if (UIInputUtil.isEmpty(value)) {
 114  2 
             return;
 115   
         }
 116   
         double doubleValue;
 117   
         try {
 118  10 
             doubleValue = DoubleConversionUtil.toDouble(value).doubleValue();
 119  8 
             if (maximum != Double.MAX_VALUE && minimum != Double.MIN_VALUE) {
 120  4 
                 if (doubleValue < minimum || doubleValue > maximum) {
 121  4 
                     Object[] args = { new Double(minimum), new Double(maximum),
 122   
                             UIComponentUtil.getLabel(component) };
 123  4 
                     FacesMessage message = FacesMessageUtil.getMessage(context,
 124   
                             getNotInRangeMessageId(), convertArgs(args));
 125  4 
                     throw new ValidatorException(message,
 126   
                             getNotInRangeMessageId(), args);
 127   
                 }
 128  4 
             } else if (minimum != Double.MIN_VALUE) {
 129  2 
                 if (doubleValue < minimum) {
 130  2 
                     Object[] args = { new Double(minimum),
 131   
                             UIComponentUtil.getLabel(component) };
 132  2 
                     FacesMessage message = FacesMessageUtil.getMessage(context,
 133   
                             getMinimumMessageId(), convertArgs(args));
 134  2 
                     throw new ValidatorException(message,
 135   
                             getMinimumMessageId(), args);
 136   
                 }
 137  2 
             } else if (maximum != Double.MAX_VALUE) {
 138  2 
                 if (doubleValue > maximum) {
 139  2 
                     Object[] args = { new Double(maximum),
 140   
                             UIComponentUtil.getLabel(component) };
 141  2 
                     FacesMessage message = FacesMessageUtil.getMessage(context,
 142   
                             getMaximumMessageId(), convertArgs(args));
 143  2 
                     throw new ValidatorException(message,
 144   
                             getMaximumMessageId(), args);
 145   
                 }
 146   
             }
 147  2 
         } catch (NumberFormatException e) {
 148  2 
             Object[] args = { UIComponentUtil.getLabel(component) };
 149  2 
             FacesMessage message = FacesMessageUtil.getMessage(context,
 150   
                     getTypeMessageId(), args);
 151  2 
             throw new ValidatorException(message, getTypeMessageId(), args);
 152  0 
         }
 153   
 
 154  0 
     }
 155   
 
 156   
     protected String getMaximumMessageId() {
 157  4 
         return MAXIMUM_MESSAGE_ID;
 158   
     }
 159   
 
 160   
     protected String getMinimumMessageId() {
 161  4 
         return MINIMUM_MESSAGE_ID;
 162   
     }
 163   
 
 164   
     protected String getNotInRangeMessageId() {
 165  8 
         return NOT_IN_RANGE_MESSAGE_ID;
 166   
     }
 167   
 
 168   
     protected String getTypeMessageId() {
 169  4 
         return TYPE_MESSAGE_ID;
 170   
     }
 171   
 
 172   
     protected Object[] convertArgs(Object[] args) {
 173  8 
         return args;
 174   
     }
 175   
 }
Report generated by Cobertura 1.9 on 11/09/19 13:14.