package org.grails.validation;
import grails.validation.AbstractConstraintTests;
import grails.validation.ConstrainedProperty;
import grails.validation.Constraint;
import grails.validation.TestClass;
import java.math.BigDecimal;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.validation.BindException;
import org.springframework.validation.Errors;
/**
* Test cases for 'scale' constraint.
*
* @author Sergey Nebolsin (<a href="mailto:nebolsin@gmail.com"/>)
*/
public class ScaleConstraintTests extends AbstractConstraintTests {
@Override
protected Class<?> getConstraintClass() {
return ScaleConstraint.class;
}
public void testValidation() {
testFloat(3, 0.1234f, 0.123f);
// test a Float value that should round up
testFloat(3, 0.1235f, 0.124f);
// test a Float value that should not change (i.e., should require no rounding)
testFloat(3, 0.12f, 0.120f);
// test an integral value masquerading as a Float
testFloat(3, 47f, 47.000f);
// test a scale of zero applied to a Float
testFloat(0, 0.123f, 0f);
// test a Double value that should round down
testDouble(3, 0.1234, 0.123);
// test a Double value that should round up
testDouble(3, 0.1235, 0.124);
// test a Double value that should not change (i.e., should require no rounding)
testDouble(3, 0.12, 0.120);
// test an integral value masquerading as a Double
testDouble(3, 47d, 47.000);
// test a scale of zero applied to a Double
testDouble(0, 0.123, 0d);
// test a BigDecimal value that should round down
testBigDecimal(3, "0.1234", "0.123");
// test a BigDecimal value that should round up
testBigDecimal(3, "0.1235", "0.124");
// test a BigDecimal value that should not change (i.e., should require no rounding)
testBigDecimal(3, "0.12", "0.120");
// test an integral value masquerading as a BigDecimal
testBigDecimal(3, "47", "47.000");
// test a scale of zero applied to a BigDecimal
testBigDecimal(0, "0.123", "0");
}
public void testNullPasses() {
Constraint constraint = getConstraint("testBigDecimal", 2);
assertEquals(null, proceedValidation(constraint, null));
}
public void testValidationOnInvalidField() {
Constraint constraint = getConstraint("testString", 2);
try {
proceedValidation(constraint, "123");
fail("ScaleConstraint must throw an exception when applied to field with unsupported type");
} catch (IllegalArgumentException iae) {
// Great
}
}
public void testCreation() {
ScaleConstraint constraint = (ScaleConstraint) getConstraint("testFloat", 2);
assertEquals(ConstrainedProperty.SCALE_CONSTRAINT, constraint.getName());
assertTrue(constraint.supports(BigDecimal.class));
assertTrue(constraint.supports(Float.class));
assertTrue(constraint.supports(Double.class));
assertFalse(constraint.supports(String.class));
assertFalse(constraint.supports(Object.class));
assertFalse(constraint.supports(null));
assertEquals(2, constraint.getScale());
try {
getConstraint("testFloat", "wrong");
fail("EmailConstraint must throw an exception for non-integer parameters.");
} catch (IllegalArgumentException iae) {
// Great
}
try {
getConstraint("testFloat", -1);
fail("EmailConstraint must throw an exception for negative parameters.");
} catch (IllegalArgumentException iae) {
// Great
}
}
private void testFloat(int scale, float value, float result) {
Constraint constraint = getConstraint("testFloat", scale);
assertEquals(result, proceedValidation(constraint, value));
}
private void testDouble(int scale, double value, double result) {
Constraint constraint = getConstraint("testDouble", scale);
assertEquals(Double.valueOf(result), proceedValidation(constraint, value));
}
private void testBigDecimal(int scale, String value, String result) {
Constraint constraint = getConstraint("testBigDecimal", scale);
assertEquals(new BigDecimal(result), proceedValidation(constraint, new BigDecimal(value)));
}
private Object proceedValidation(Constraint constraint, Object value) {
BeanWrapper constrainedBean = new BeanWrapperImpl(new TestClass());
constrainedBean.setPropertyValue(constraint.getPropertyName(), value);
Errors errors = new BindException(constrainedBean.getWrappedInstance(), constrainedBean.getWrappedClass().getName());
assertFalse(errors.hasErrors());
constraint.validate(constrainedBean.getWrappedInstance(), value, errors);
return constrainedBean.getPropertyValue(constraint.getPropertyName());
}
}