@Test
public void testIsValidMinValidator() {
AnnotationDescriptor<Min> descriptor = new AnnotationDescriptor<Min>(Min.class);
descriptor.setValue("value", 15L);
descriptor.setValue("message", "{validator.min}");
Min m = AnnotationFactory.create(descriptor);
MinValidatorForCharSequence constraint = new MinValidatorForCharSequence();
constraint.initialize(m);
testMinValidator(constraint, true);
}
@Test
public void testIsValidDecimalMax() {
AnnotationDescriptor<DecimalMax> descriptor =
new AnnotationDescriptor<DecimalMax>(DecimalMax.class);
descriptor.setValue("value", "15.0E0");
descriptor.setValue("message", "{validator.max}");
DecimalMax m = AnnotationFactory.create(descriptor);
DecimalMaxValidatorForCharSequence constraint = new DecimalMaxValidatorForCharSequence();
constraint.initialize(m);
testMaxValidator(constraint, true);
}
@Test
@TestForIssue(jiraKey = "HV-256")
public void testIsValidDecimalMinExclusive() {
boolean inclusive = false;
AnnotationDescriptor<DecimalMin> descriptor =
new AnnotationDescriptor<DecimalMin>(DecimalMin.class);
descriptor.setValue("value", "1500E-2");
descriptor.setValue("inclusive", inclusive);
descriptor.setValue("message", "{validator.min}");
DecimalMin m = AnnotationFactory.create(descriptor);
DecimalMinValidatorForCharSequence constraint = new DecimalMinValidatorForCharSequence();
constraint.initialize(m);
testMinValidator(constraint, inclusive);
}
@Test
public void testInitializeDecimalMaxWithInvalidValue() {
AnnotationDescriptor<DecimalMin> descriptor =
new AnnotationDescriptor<DecimalMin>(DecimalMin.class);
descriptor.setValue("value", "foobar");
descriptor.setValue("message", "{validator.min}");
DecimalMin m = AnnotationFactory.create(descriptor);
DecimalMinValidatorForNumber constraint = new DecimalMinValidatorForNumber();
try {
constraint.initialize(m);
fail();
} catch (IllegalArgumentException e) {
// success
}
}
private <A extends Annotation, T> MetaConstraint<?> createMetaConstraint(
ConstraintType constraint, Class<T> beanClass, Member member, String defaultPackage) {
@SuppressWarnings("unchecked")
Class<A> annotationClass = (Class<A>) getClass(constraint.getAnnotation(), defaultPackage);
AnnotationDescriptor<A> annotationDescriptor = new AnnotationDescriptor<A>(annotationClass);
if (constraint.getMessage() != null) {
annotationDescriptor.setValue(MESSAGE_PARAM, constraint.getMessage());
}
annotationDescriptor.setValue(GROUPS_PARAM, getGroups(constraint.getGroups(), defaultPackage));
annotationDescriptor.setValue(
PAYLOAD_PARAM, getPayload(constraint.getPayload(), defaultPackage));
for (ElementType elementType : constraint.getElement()) {
String name = elementType.getName();
checkNameIsValid(name);
Class<?> returnType = getAnnotationParameterType(annotationClass, name);
Object elementValue = getElementValue(elementType, returnType);
annotationDescriptor.setValue(name, elementValue);
}
A annotation;
try {
annotation = AnnotationFactory.create(annotationDescriptor);
} catch (RuntimeException e) {
throw log.getUnableToCreateAnnotationForConfiguredConstraintException(e);
}
java.lang.annotation.ElementType type = java.lang.annotation.ElementType.TYPE;
if (member instanceof Method) {
type = java.lang.annotation.ElementType.METHOD;
} else if (member instanceof Field) {
type = java.lang.annotation.ElementType.FIELD;
}
// we set initially ConstraintOrigin.DEFINED_LOCALLY for all xml configured constraints
// later we will make copies of this constraint descriptor when needed and adjust the
// ConstraintOrigin
ConstraintDescriptorImpl<A> constraintDescriptor =
new ConstraintDescriptorImpl<A>(
annotation, constraintHelper, type, ConstraintOrigin.DEFINED_LOCALLY);
return new MetaConstraint<A>(
constraintDescriptor, new BeanConstraintLocation(beanClass, member));
}
private <A extends Annotation> Annotation createAnnotation(
AnnotationType annotationType, Class<A> returnType) {
AnnotationDescriptor<A> annotationDescriptor = new AnnotationDescriptor<A>(returnType);
for (ElementType elementType : annotationType.getElement()) {
String name = elementType.getName();
Class<?> parameterType = getAnnotationParameterType(returnType, name);
Object elementValue = getElementValue(elementType, parameterType);
annotationDescriptor.setValue(name, elementValue);
}
return AnnotationFactory.create(annotationDescriptor);
}