You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@bval.apache.org by mb...@apache.org on 2018/02/21 23:21:46 UTC
[5/5] bval git commit: TCK test fixes
TCK test fixes
Project: http://git-wip-us.apache.org/repos/asf/bval/repo
Commit: http://git-wip-us.apache.org/repos/asf/bval/commit/f09af4dd
Tree: http://git-wip-us.apache.org/repos/asf/bval/tree/f09af4dd
Diff: http://git-wip-us.apache.org/repos/asf/bval/diff/f09af4dd
Branch: refs/heads/bv2
Commit: f09af4ddb73d636cc4ce3748295ef932f8ee9e56
Parents: 2850b94
Author: Matt Benson <mb...@apache.org>
Authored: Wed Feb 21 17:21:33 2018 -0600
Committer: Matt Benson <mb...@apache.org>
Committed: Wed Feb 21 17:21:33 2018 -0600
----------------------------------------------------------------------
.../ComputeConstraintValidatorClass.java | 15 +++--
.../bval/jsr/metadata/ReflectionBuilder.java | 68 ++++++++++++++------
2 files changed, 60 insertions(+), 23 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/bval/blob/f09af4dd/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComputeConstraintValidatorClass.java
----------------------------------------------------------------------
diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComputeConstraintValidatorClass.java b/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComputeConstraintValidatorClass.java
index 64d913f..d2595ea 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComputeConstraintValidatorClass.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/descriptor/ComputeConstraintValidatorClass.java
@@ -23,6 +23,7 @@ import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.HashMap;
import java.util.Map;
+import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
@@ -139,7 +140,7 @@ class ComputeConstraintValidatorClass<A extends Annotation>
@SuppressWarnings("unchecked")
final Class<A> constraintType = (Class<A>) constraint.annotationType();
- Exceptions.raiseIf(set.size() > 1 || !composed && set.isEmpty(), UnexpectedTypeException::new,
+ Exceptions.raiseIf(set.size() > 1 || !composed && set.isEmpty(), ConstraintDefinitionException::new,
"%d cross-parameter %ss found for constraint type %s", set.size(), CV, constraintType);
final Class<? extends ConstraintValidator<A, ?>> result = set.iterator().next().getType();
@@ -153,10 +154,14 @@ class ComputeConstraintValidatorClass<A extends Annotation>
private Class<? extends ConstraintValidator<A, ?>> findAnnotatedElementValidator(
Set<ConstraintValidatorInfo<A>> infos) {
- final Map<Class<?>, Class<? extends ConstraintValidator<?, ?>>> validators =
- infos.stream().filter(info -> info.getSupportedTargets().contains(ValidationTarget.ANNOTATED_ELEMENT))
- .map(ConstraintValidatorInfo::getType)
- .collect(Collectors.toMap(ComputeConstraintValidatorClass::getValidatedType, Function.identity()));
+ final Map<Class<?>, Class<? extends ConstraintValidator<?, ?>>> validators = infos.stream()
+ .filter(info -> info.getSupportedTargets().contains(ValidationTarget.ANNOTATED_ELEMENT))
+ .map(ConstraintValidatorInfo::getType).collect(
+ Collectors.toMap(ComputeConstraintValidatorClass::getValidatedType, Function.identity(), (v1, v2) -> {
+ Exceptions.raiseUnless(Objects.equals(v1, v2), UnexpectedTypeException::new,
+ "Detected collision of constraint and target type between %s and %s", v1, v2);
+ return v1;
+ }));
final Map<Type, Class<? extends ConstraintValidator<?, ?>>> candidates = new HashMap<>();
http://git-wip-us.apache.org/repos/asf/bval/blob/f09af4dd/bval-jsr/src/main/java/org/apache/bval/jsr/metadata/ReflectionBuilder.java
----------------------------------------------------------------------
diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/metadata/ReflectionBuilder.java b/bval-jsr/src/main/java/org/apache/bval/jsr/metadata/ReflectionBuilder.java
index fc21ea7..776012d 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/metadata/ReflectionBuilder.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/metadata/ReflectionBuilder.java
@@ -40,6 +40,8 @@ import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
+import javax.validation.ConstraintDeclarationException;
+import javax.validation.ConstraintTarget;
import javax.validation.GroupSequence;
import javax.validation.Valid;
import javax.validation.constraintvalidation.ValidationTarget;
@@ -51,6 +53,7 @@ import org.apache.bval.jsr.descriptor.GroupConversion;
import org.apache.bval.jsr.util.AnnotationsManager;
import org.apache.bval.jsr.util.Methods;
import org.apache.bval.jsr.util.ToUnmodifiable;
+import org.apache.bval.util.Exceptions;
import org.apache.bval.util.ObjectUtils;
import org.apache.bval.util.Validate;
import org.apache.bval.util.reflection.Reflection;
@@ -209,7 +212,7 @@ public class ReflectionBuilder {
@Override
public Annotation[] getDeclaredConstraints(Metas<E> meta) {
- return getConstraints(meta, ValidationTarget.ANNOTATED_ELEMENT);
+ return getConstraints(ConstraintTarget.RETURN_VALUE);
}
};
}
@@ -219,44 +222,73 @@ public class ReflectionBuilder {
return new ReflectionBuilder.ForElement<E>(meta) {
@Override
public Annotation[] getDeclaredConstraints(Metas<E> meta) {
- return getConstraints(meta, ValidationTarget.PARAMETERS);
+ return getConstraints(ConstraintTarget.PARAMETERS);
}
};
}
- private Annotation[] getConstraints(Metas<E> ignored, ValidationTarget validationTarget) {
- return Optional.of(getConstraintsByTarget(meta)).map(m -> m.get(validationTarget))
+ private Annotation[] getConstraints(ConstraintTarget constraintTarget) {
+ return Optional.of(getConstraintsByTarget()).map(m -> m.get(constraintTarget))
.map(l -> l.toArray(new Annotation[l.size()])).orElse(ObjectUtils.EMPTY_ANNOTATION_ARRAY);
}
- private Map<ValidationTarget, List<Annotation>> getConstraintsByTarget(Metas<E> ignored) {
+ private Map<ConstraintTarget, List<Annotation>> getConstraintsByTarget() {
final Annotation[] declaredConstraints = AnnotationsManager.getDeclaredConstraints(meta);
if (ObjectUtils.isEmpty(declaredConstraints)) {
return Collections.emptyMap();
}
- final Map<ValidationTarget, List<Annotation>> result = new EnumMap<>(ValidationTarget.class);
+ final Map<ConstraintTarget, List<Annotation>> result = new EnumMap<>(ConstraintTarget.class);
for (Annotation constraint : declaredConstraints) {
final Class<? extends Annotation> constraintType = constraint.annotationType();
- final Optional<ValidationTarget> explicitTarget =
+ final Optional<ConstraintTarget> explicitTarget =
Optional.of(ConstraintAnnotationAttributes.VALIDATION_APPLIES_TO.analyze(constraintType))
- .filter(ConstraintAnnotationAttributes.Worker::isValid).map(w -> w.read(constraint));
+ .filter(ConstraintAnnotationAttributes.Worker::isValid)
+ .<ConstraintTarget> map(w -> w.read(constraint)).filter(et -> et != ConstraintTarget.IMPLICIT);
- final ValidationTarget target = explicitTarget.orElseGet(() -> {
- final Set<ValidationTarget> supportedTargets =
- validatorFactory.getAnnotationsManager().supportedTargets(constraintType);
-
- Validate.validState(supportedTargets.size() == 1,
- "Found %d possible %s types for constraint type %s and no explicit assignment via #%s()",
- supportedTargets.size(), ValidationTarget.class.getSimpleName(), constraintType.getName(),
- ConstraintAnnotationAttributes.VALIDATION_APPLIES_TO.getAttributeName());
+ final ConstraintTarget target;
- return supportedTargets.iterator().next();
- });
+ if (explicitTarget.isPresent()) {
+ target = explicitTarget.get();
+ } else {
+ final Set<ValidationTarget> supportedTargets =
+ validatorFactory.getAnnotationsManager().supportedTargets(constraintType);
+
+ if (supportedTargets.size() == 1) {
+ final ValidationTarget validationTarget = supportedTargets.iterator().next();
+ switch (validationTarget) {
+ case PARAMETERS:
+ target = ConstraintTarget.PARAMETERS;
+ break;
+ case ANNOTATED_ELEMENT:
+ target = ConstraintTarget.RETURN_VALUE;
+ break;
+ default:
+ throw Exceptions.create(IllegalStateException::new, "Unknown %s %s for %s",
+ ValidationTarget.class.getSimpleName(), validationTarget, constraintType);
+ }
+ } else {
+ target = impliedConstraintTarget();
+ Exceptions.raiseIf(target == null, ConstraintDeclarationException::new,
+ "Found %d possible %s types for constraint type %s and no explicit assignment via #%s()",
+ supportedTargets.size(), ValidationTarget.class.getSimpleName(), constraintType.getName(),
+ ConstraintAnnotationAttributes.VALIDATION_APPLIES_TO.getAttributeName());
+ }
+ }
result.computeIfAbsent(target, k -> new ArrayList<>()).add(constraint);
}
return result;
}
+
+ private ConstraintTarget impliedConstraintTarget() {
+ if (meta.getHost().getParameterCount() == 0) {
+ return ConstraintTarget.RETURN_VALUE;
+ }
+ if (Void.TYPE.equals(meta.getType())) {
+ return ConstraintTarget.PARAMETERS;
+ }
+ return null;
+ }
}
private final ApacheValidatorFactory validatorFactory;