JSR-349: Bean Validation TCK Coverage

1.1.0

Contents

Chapter Summary
Section Summary
Coverage Detail
Unmatched Tests
Unversioned Tests
Test Group Summary

Coverage Distribution

 
 
 
 
 
 
 
 
 
 

Chapter Summary

Chapter Assertions Testable Total Tested Total Tests Tested
(problematic)
Tested
(working)
Coverage %
1 Introduction000000
2 What's new in 1.1000000
3 Constraint Definition695959126059100.00%
4 Constraint declaration and validation process124111105276010594.59%
5 Validation APIs1581401406290140100.00%
6 Constraint metadata request APIs494949212049100.00%
7 Built-in Constraint definitions1515150015100.00%
8 XML deployment descriptor969494144094100.00%
9 Exception model5441704100.00%
10 Integration33262696026100.00%
Total5494984921500049298.80%

Section Summary

SectionAssertionsTestableTotal TestedTested
(problematic)
Tested
(working)
Coverage %
1 Introduction00000
2 What's new in 1.100000
3 Constraint Definition00000
3.1 Constraint annotation73303100.00%
3.1.1 Constraint definition properties22202100.00%
3.1.1.1 message11101100.00%
3.1.1.2 groups44404100.00%
3.1.1.3 payload33303100.00%
3.1.1.4 validationAppliesTo77707100.00%
3.2 Applying multiple constraints of the same type11101100.00%
3.3 Constraint composition202020020100.00%
3.4 Constraint validation implementation201515015100.00%
3.5 The ConstraintValidatorFactory43303100.00%
4 Constraint declaration and validation process00000
4.1 Requirements on classes to be validated54404100.00%
4.1.1 Object validation22202100.00%
4.1.2 Field and property validation55505100.00%
4.1.3 Graph validation121212012100.00%
4.2 Constraint declaration11101100.00%
4.3 Inheritance (interface and superclass)33303100.00%
4.4 Group and group sequence44404100.00%
4.4.1 Group inheritance22202100.00%
4.4.2 Group sequence107707100.00%
4.4.3 Redefining the Default group for a class43303100.00%
4.4.4 Implicit grouping11101100.00%
4.4.5 Group conversion101010010100.00%
4.4.6 Formal group definitions10930333.33%
4.5 Method and constructor constraints00000
4.5.1 Requirements on methods to be validated10000
4.5.2 Declaring parameter constraints11101100.00%
4.5.2.1 Cross-parameter constraints33303100.00%
4.5.2.2 Naming parameters22202100.00%
4.5.3 Declaring return value constraints22202100.00%
4.5.4 Marking parameters and return values for cascaded validation43303100.00%
4.5.5 Method constraints in inheritance hierarchies66606100.00%
4.6 Validation routine32202100.00%
4.6.1 Object graph validation55505100.00%
4.6.2 Method and constructor validation32202100.00%
4.6.3 Traversable property151212012100.00%
4.6.4 ConstraintValidator resolution algorithm101010010100.00%
5 Validation APIs00000
5.1 Validator API10000
5.1.1 Validation methods111111011100.00%
5.1.2 Methods for validating method and constructor constraints131313013100.00%
5.1.3 groups32202100.00%
5.2 ConstraintViolation414040040100.00%
5.3 Message interpolation00000
5.3.1 Default message interpolation99909100.00%
5.3.1.1 Default message interpolation algorithm75505100.00%
5.3.1.2 Locale for default message interpolation22202100.00%
5.3.1.3 Message expressions using Expression Language (EL)66606100.00%
5.3.2 Custom message interpolation76606100.00%
5.4 Triggering method validation22202100.00%
5.5 Bootstrapping11101100.00%
5.5.1 Examples10000
5.5.2 ValidatorFactory65505100.00%
5.5.3 Configuration121010010100.00%
5.5.4 ValidationProvider and ValidationProviderResolver00000
5.5.4.1 ValidationProviderResolver31101100.00%
5.5.4.2 ValidationProvider55505100.00%
5.5.5 Validation66606100.00%
5.5.6 XML configuration: META-INF/validation.xml201616016100.00%
5.5.7 Bootstrapping considerations20000
6 Constraint metadata request APIs00000
6.1 Validator33303100.00%
6.2 ElementDescriptor77707100.00%
6.3 BeanDescriptor88808100.00%
6.4 CascadableDescriptor22202100.00%
6.5 GroupConversionDescriptor22202100.00%
6.6 PropertyDescriptor11101100.00%
6.7 ExecutableDescriptor, MethodDescriptor and ConstructorDescriptor88808100.00%
6.8 ParameterDescriptor22202100.00%
6.9 CrossParameterDescriptor11101100.00%
6.11 ConstraintDescriptor151515015100.00%
7 Built-in Constraint definitions151515015100.00%
8 XML deployment descriptor11101100.00%
8.1 Constraint definition and declaration55505100.00%
8.1.1 Constraint declaration in XML66606100.00%
8.1.1.1 Class-level overriding55505100.00%
8.1.1.2 Field-level overriding77707100.00%
8.1.1.3 Property-level overriding77707100.00%
8.1.1.4 Constructor-level overriding151515015100.00%
8.1.1.5 Method-level overriding161616016100.00%
8.1.1.6 Constraint declaration99909100.00%
8.1.1.7 Declaration of group conversions22202100.00%
8.1.2 Overriding constraint definitions in XML55505100.00%
8.1.3 Converting the string representation of a value121212012100.00%
8.1.4 XML Schema32202100.00%
8.2 Configuration schema32202100.00%
9 Exception model11101100.00%
9.2 Constraint definition: ConstraintDefinitionException11101100.00%
9.3 Constraint declaration: ConstraintDeclarationException and UnexpectedTypeException21101100.00%
9.4 Group definition: GroupDefinitionException11101100.00%
10 Integration00000
10.1 General requirements00000
10.1.1 Objects lifecycle64404100.00%
10.1.2 Method and constructor validation171414014100.00%
10.2 Java EE33303100.00%
10.3 Context and Dependency Injection (CDI) integration11101100.00%
10.3.1 ValidatorFactory and Validator11101100.00%
10.3.2 ConstraintValidatorFactory, MessageInterpolator, ParameterNameProvider and TraversableResolver32202100.00%
10.3.3 Method and constructor validation21101100.00%

Coverage Detail

Colour Key
Assertion is covered
Assertion is not covered
Assertion test is unimplemented
Assertion is untestable

Section 3.1 - Constraint annotation

a)

An annotation is considered a constraint definition if its retention policy contains RUNTIME and if the annotation itself is annotated with javax.validation.Constraint

b)

Generic constraint annotations can target any of the following ElementTypes: FIELD for constrained attributes METHOD for constrained getters and constrained method return values CONSTRUCTOR for constrained constructor return values PARAMETER for constrained method and constructor parameters TYPE for constrained beans ANNOTATION_TYPE for constraints composing other constraints

c)

Cross-parameter constraint annotations can target any of the following ElementTypes: METHOD CONSTRUCTOR ANNOTATION_TYPE for cross-parameter constraints composing other cross-parameter constraints

d)

A constraint annotation that is both can target the union of the generic and cross-parameter constraint annotations targets.

e)

Applying a constraint annotation to an incompatible type will raise an UnexpectedTypeException.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()
f)

At most one ConstraintValidator supporting cross-parameter validation must be present for a given constraint. A ConstraintDefinitionException is raised otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testCrossParameterConstraintWithSeveralValidatorsCausesException()
InvalidConstraintDefinitionsTest.testCrossParameterConstraintWithValidatorForObjectAndObjectArrayCausesException()
g)

If a constraint definition is not valid, a ConstraintDefinitionException is raised either at validation time or when the metadata is requested.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()
InvalidConstraintDefinitionsTest.testGenericAndCrossParameterConstraintWithoutValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testGenericConstraintWithValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testCrossParameterConstraintWithValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongValidationAppliesToType()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultValidationAppliesTo()

Section 3.1.1 - Constraint definition properties

a)

A constraint definition may have attributes that are specified at the time the constraint is applied to a JavaBean.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintdefinition
ConstraintDefinitionsTest.testConstraintWithCustomAttributes()
b)

Annotation elements starting with valid are not allowed

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()

Section 3.1.1.1 - message

a)

Every constraint annotation must define a message element of type String.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()

Section 3.1.1.2 - groups

a)

Every constraint annotation must define a groups element that specifies the processing groups with which the constraint declaration is associated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()
b)

The type of the groups parameter is Class<?>[].

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()
c)

The default value must be an empty array.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()
d)

If no group is specified when declaring the constraint on an element, the Default group is considered declared.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintdefinition
ConstraintDefinitionsTest.testDefaultGroupAssumedWhenNoGroupsSpecified()

Section 3.1.1.3 - payload

a)

Constraint annotations must define a payload element that specifies the payload with which the constraint declaration is associated. The type of the payload parameter is Payload[].

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()
b)

The default value must be an empty array.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()
c)

Each attachable payload extends Payload.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()

Section 3.1.1.4 - validationAppliesTo

a)

The element validationAppliesTo must only be present for constraints that are both generic and cross-parameter, it is mandatory in this situation. A ConstraintDefinitionException is raised if these rules are violated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testGenericAndCrossParameterConstraintWithoutValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testGenericConstraintWithValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testCrossParameterConstraintWithValidationAppliesToCausesException()
b)

The type of the validationAppliesTo parameter is ConstraintTarget. The default value must be ConstraintTarget.IMPLICIT.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongValidationAppliesToType()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultValidationAppliesTo()
c)

If a ConstraintTarget is used in an illegal situation, a ConstraintDeclarationException is raised either at validation time or when the metadata is requested.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnMethodWithParametersAndReturnValueCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnConstructorWithParametersCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnMethodWithoutParametersCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnConstructorWithoutParametersCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnVoidMethodCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnClassCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnClassCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnInterfaceCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnInterfaceCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnFieldCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnFieldCausesException()
d)

Using IMPLICIT in a situation that cannot be inferred (see the JavaDoc for the detailed rules),

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnMethodWithParametersAndReturnValueCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnConstructorWithParametersCausesException()
e)

Using PARAMETERS on a constructor or method that has no parameter,

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnMethodWithoutParametersCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnConstructorWithoutParametersCausesException()
f)

Using RETURN_VALUE on a method with no return value,

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnVoidMethodCausesException()
g)

Using PARAMETERS or RETURN_VALUE on a type - class or interface - or on a field.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnClassCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnClassCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnInterfaceCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnInterfaceCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnFieldCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetReturnValueOnFieldCausesException()

Section 3.2 - Applying multiple constraints of the same type

a)

The bean validation provider treats regular annotations (annotations not annotated by @Constraint) whose value element has a return type of an array of constraint annotations in a special way. Each element in the value array are processed by the Bean Validation implementation as regular constraint annotations.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintdefinition
ConstraintDefinitionsTest.testConstraintWithCustomAttributes()

Section 3.3 - Constraint composition

a)

More formally, each constraint annotation hosted on a constraint annotation is applied to the target element and this is done recursively.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testComposedConstraints()
ConstraintCompositionTest.testComposedConstraintsAreRecursive()
b)

Note that the main annotation and its constraint validation implementation is also applied.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testValidationOfMainAnnotationIsAlsoApplied()
c)

By default, each failing constraint generates an error report.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()
d)

Groups from the main constraint annotation are inherited by the composing annotations.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testGroupsDefinedOnMainAnnotationAreInherited()
e)

Any groups definition on a composing annotation is ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testGroupsDefinedOnMainAnnotationAreInherited()
f)

Payload from the main constraint annotation is inherited by the composing annotations.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testPayloadPropagationInComposedConstraints()
g)

Any payload definition on a composing annotation is ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testPayloadPropagationInComposedConstraints()
h)

The constraint target from the main constraint annotation is inherited by the composing annotations.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testConstraintTargetPropagationInComposedConstraints()
i)

Any validationAppliesTo definition on a composing annotation is ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testConstraintTargetPropagationInComposedConstraints()
j)

The type upon which composed constraint is placed must be compatible with all constraints (composing and composed).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testAllComposingConstraintsMustBeApplicableToAnnotatedType()
k)

All composed and composing constraints must have a constraint type in common.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testMixedConstraintTargetsInComposedAndComposingConstraintsCauseException()
ConstraintCompositionTest.testMixedConstraintTargetsInComposingConstraintsCauseException()
l)

More specifically, if a composed constraint is marked as @ReportAsSingleViolation, the evaluation of the composing constraints stops at the first failing constraint and the error report corresponding to the composed constraint is generated and returned.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testOnlySingleConstraintViolation()
org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition.nestedconstraintcomposition
NestedConstraintCompositionTest.testCompositeConstraint1WithNestedConstraintSingleViolation()
NestedConstraintCompositionTest.testCompositeConstraint2WithNestedConstraintSingleViolation()
NestedConstraintCompositionTest.testCompositeConstraint3WithNestedConstraint()
NestedConstraintCompositionTest.testCompositeConstraint4WithNestedConstraintSingleViolation()
m)

Composing annotations can define the value of message and custom attributes (excluding groups, payload and validationAppliesTo) but these are fixed in the composed constraint definition.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testAttributesDefinedOnComposingConstraints()
n)

It is possible to override attributes and messages defined on a composing annotation. An attribute from the main annotation is used to override one or more attributes of the composing annotations. Such an attribute is annotated with the @OverridesAttribute annotation or its multivalued equivalent @OverridesAttribute.List.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()
o)

The types of the overridden and overriding attributes must be identical.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testOverriddenAttributesMustMatchInType()
p)

A composing constraint can itself be a composed constraint. In this case, attribute values are overridden recursively according to the described rules.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testComposedConstraints()
ConstraintCompositionTest.testComposedConstraintsAreRecursive()
q)

If a constraint is used more than once as a composing constraint, the multi value constraints model as described in 3.2 is used.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()
r)

To select a specific composing constraint, OverridesAttribute.constraintIndex is used. It represents the constraint index in the value array.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()
s)

If index is undefined, the single constraint declaration is targeted.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()
t)

If the composition is invalid, e.g. infinitely recursive composition wrong attribute overriding a single attribute mapped to more than one source attribute a composing and composed constraint marked as different constraint types (i.e., generic and cross-parameter) etc. a ConstraintDefinitionException is raised either at validation time or when the metadata is requested.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testOverriddenAttributesMustMatchInType()
ConstraintCompositionTest.testMixedConstraintTargetsInComposedAndComposingConstraintsCauseException()
ConstraintCompositionTest.testMixedConstraintTargetsInComposingConstraintsCauseException()

Section 3.4 - Constraint validation implementation

a)

A constraint validation implementation performs the validation of a given constraint annotation for a given type.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()
CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()
b)

The implementation classes are specified by the validatedBy element of the @Constraint annotation that decorates the constraint definition.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()
CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()
org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
GenericAndCrossParameterConstraintTest.testAnnotatedElementIsTargetedByDefault()
c)

The constraint validation implementation implements the ConstraintValidator interface.

d)

Some restrictions apply on the generic type T (used in the isValid() method). T must resolve to a non parameterized type (i.e. because the type is not using generics or because the raw type is used instead of the generic version) or generic parameters of T must be unbounded wildcard types (i.e. <?>).

e)

By default, a ConstraintValidator targets the (returned) element annotated by the constraint. You can make a ConstraintValidator target the array of parameters of a method or constructor (aka cross-parameter) by annotating the validator implementation with @SupportedValidationTarget.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
GenericAndCrossParameterConstraintTest.testAnnotatedElementIsTargetedByDefault()
GenericAndCrossParameterConstraintTest.testAnnotatedElementIsTargetedUsingSupportedValidationTarget()
GenericAndCrossParameterConstraintTest.testParametersAreTargetedUsingSupportedValidationTarget()
f)

A ConstraintValidator implementation can target both annotated elements and array of parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
GenericAndCrossParameterConstraintTest.testOneValidatorSupportsBothValidationTargets()
g)

If a ConstraintValidator targets array of parameters (cross-parameter), T must resolve to Object[] (or Object) in order to have the array of parameter values passed to the isValid() method. A ConstraintDefinitionException is raised otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testCrossParameterValidatorValidatingObjectArray()
ValidatorResolutionTest.testCrossParameterValidatorValidatingObject()
org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testValidatorForCrossParameterConstraintMustValidateObjectOrObjectArray()
h)

The initialize() method is called by the Bean validation provider prior to any use of the constraint implementation.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()
i)

The isValid() method is evaluated by the Bean Validation provider each time a given value is validated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()
j)

It returns false if the value is not valid, true otherwise.

k)

isValid() implementations must be thread-safe.

l)

If the property is of an unanticipated type, an UnexpectedTypeException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()
org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testUnexpectedTypeExceptionIsRaisedForInvalidType()
m)

If an exception occurs either in the initialize() or isValid() method, the runtime exception is wrapped into a ValidationException by the Bean Validation engine.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testRuntimeExceptionFromIsValidIsWrapped()
CustomConstraintValidatorTest.testRuntimeExceptionFromInitializeIsWrapped()
n)

The constraint validation implementation is not allowed to change the state of the value passed to isValid().

o)

By default, each invalid constraint leads to the generation of one error object represented by a ConstraintViolation object. This object is built from the default constraint message template as defined by the constraint declaration and the context in which the constraint declaration is placed (bean, property, executable parameter, cross-parameter or executable return value).

Coverage

org.hibernate.beanvalidation.tck.tests.validation.validatorcontext
ConstraintValidatorContextTest.testDefaultError()
org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testOneConstraintViolationPerFailingConstraint()
p)

The ConstraintValidatorContext methods let the constraint implementation disable the default ConstraintViolation generation and create one or more custom ones.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.validatorcontext
ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorNoSubNode()
ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorWithSubNode()
ConstraintValidatorContextTest.propertyPathInIterable()
q)

The non-interpolated message passed as a parameter is used to build the ConstraintViolation message (the message interpolation operation is applied to it).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testNonInterpolatedMessageParameterIsUsed()
r)

By default, the Path exposed on the ConstraintViolation represents the path to the bean, property, parameter, cross-parameter or return value hosting the constraint (see 5.2 for more information).

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testGraphValidationWithList()
ValidateTest.testGraphValidationWithArray()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
org.hibernate.beanvalidation.tck.tests.constraints.customconstraint
CustomConstraintValidatorTest.testDefaultPropertyPath()
s)

You can point it to a subpath of this default path by using the constraint violation builder fluent API.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.validatorcontext
ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorWithSubNode()
ConstraintValidatorContextTest.propertyPathInIterable()
org.hibernate.beanvalidation.tck.tests.constraints.constraintcomposition
ConstraintCompositionTest.testValidationOfMainAnnotationIsAlsoApplied()
t)

If disableDefaultConstraintViolation() is called, no custom error is added (using the error builder) and if the constraint is not valid, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.validatorcontext
ConstraintValidatorContextTest.testDisableDefaultErrorWithoutAddingCustomError()

Section 3.5 - The ConstraintValidatorFactory

a)

Bean Validation providers must release each instance retrieved. The ConstraintValidatorFactory instance that has created a ConstraintValidator instance must be the one that releases it. In other words, passing an instance of ConstraintValidator to a ConstraintValidatorFactory that has not created it is an error.

b)

The default ConstraintValidatorFactory provided by the Bean Validation provider implementation uses the public no-arg constructor of the ConstraintValidator class.

Coverage

org.hibernate.beanvalidation.tck.tests.validatorfactory
CustomConstraintValidatorTest.testDefaultConstructorInValidatorCalled()
c)

If an exception occurs in the factory while retrieving the ConstraintValidator instance, the runtime exception is wrapped in a ValidationException.

Coverage

org.hibernate.beanvalidation.tck.tests.validatorfactory
CustomConstraintValidatorTest.testRuntimeExceptionInValidatorCreationIsWrapped()
d)

If the instance returned by the factory is null, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.validatorfactory
CustomConstraintValidatorTest.testValidationExceptionIsThrownInCaseFactoryReturnsNull()

Section 4.1 - Requirements on classes to be validated

a)

Properties to be validated must follow the method signature conventions for JavaBeans read properties, as defined by the JavaBeans specification. These properties are commonly referred as getters.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testUnexpectedTypeException()
ValidateTest.testConstraintViolation()
b)

Static fields and static methods are excluded from validation.

c)

Constraints can be applied to interfaces and superclasses.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testClassLevelConstraints()
d)

What is a getter? The JavaBeans specification specifies that a getter is a method whose name starts with get and has a return type but no parameter name starts with is, has no parameter and is returning boolean

Coverage

org.hibernate.beanvalidation.tck.tests.validation
GetterDefinitionTest.testGetterMethod()
GetterDefinitionTest.testBooleanGetterMethod()
e)

The target of an annotation definition can be a field, property, type, constructor or method return value, constructor or method parameter or constructor or method cross-parameter provided that: the constraint definition supports the specified target (java.lang.annotation.Target) one of the ConstraintValidators declared on the constraint supports the declared type of the target or in the case of cross-parameter, one cross-parameter ConstraintValidator is present (see 4.6.4 to learn about ConstraintValidator resolution).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testClassLevelConstraints()
ValidationRequirementTest.testFieldAccess()
ValidationRequirementTest.testPropertyAccess()

Section 4.1.1 - Object validation

a)

Constraint declarations can be applied to a class or an interface.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testClassLevelConstraints()
b)

Applying a constraint to a class or interface expresses a validation over the state of the class or the class implementing the interface.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testClassLevelConstraints()

Section 4.1.2 - Field and property validation

a)

Constraint declarations can be applied on both fields and properties for the same object type.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testFieldAccess()
ValidationRequirementTest.testPropertyAccess()
ValidationRequirementTest.testConstraintAppliedOnFieldAndProperty()
b)

The same constraint should however not be duplicated between a field and its associated property (the constraint validation would be applied twice).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testConstraintAppliedOnFieldAndProperty()
c)

When a field is annotated with a constraint declaration, field access strategy is used to access the state validated by such constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testFieldAccess()
d)

When a property is annotated with a constraint declaration, property access strategy is used to access the state validated by such constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testPropertyAccess()
e)

The fields or methods visibility are not constrained.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application
ValidationRequirementTest.testFieldAndPropertyVisibilityIsNotConstrained()

Section 4.1.3 - Graph validation

a)

Consider the situation where bean X contains a field of type Y. By annotating field Y with the @Valid annotation, the Validator will validate Y (and its properties) when X is validated.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testGraphNavigationDeterminism()
b)

The exact type Z of the value contained in the field declared of type Y (subclass, implementation) is determined at runtime. The constraint definitions of Z are used.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testTypeOfContainedValueIsDeterminedAtRuntime()
c)

Any object implementing java.lang.Iterable is supported.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testContainedIterable()
d)

Arrays of objects

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testGraphValidationWithArray()
e)

java.util.Collection

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testTypeOfContainedValuesIsDeterminedAtRuntime()
f)

java.util.Set

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testContainedSet()
g)

java.util.List

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testNoEndlessLoop()
h)

java.util.Map

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testContainedMap()
i)

Each object provided by the iterator is validated.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testGraphValidationWithArray()
org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testContainedSet()
GraphNavigationTest.testContainedIterable()
GraphNavigationTest.testContainedMap()
j)

For Map, the value (retrieved by getValue) of each Map.Entry is validated (the key is not validated).

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testContainedMap()
k)

Like regular references, its type is determined at runtime and the constraint definitions for this particular type are used.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testTypeOfContainedValuesIsDeterminedAtRuntime()
l)

The @Valid annotation is applied recursively.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testGraphNavigationDeterminism()

Section 4.2 - Constraint declaration

a)

When a constraint is defined on a class, the class instance being validated is passed to the ConstraintValidator. When a constraint is defined on a field, the value of the field is passed to the ConstraintValidator. When a constraint is defined on a getter, the result of the getter invocation is passed to the ConstraintValidator.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValueAccessStrategyTest.testValueFromFieldIsPassedToValidatorOfFieldLevelConstraint()
ValueAccessStrategyTest.testValueFromGetterIsPassedToValidatorOfPropertyLevelConstraint()
ValueAccessStrategyTest.testValidatedObjectIsPassedToValidatorOfClassLevelConstraint()

Section 4.3 - Inheritance (interface and superclass)

a)

A constraint declaration can be placed on an interface.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance
ConstraintInheritanceTest.testConstraintsOnInterfaceAreInherited()
ConstraintInheritanceTest.testConstraintsOnInterfaceAndImplementationAddUp()
ConstraintInheritanceTest.testConstraintsOnSuperAndSubClassAddUp()
b)

For a given class, constraint declarations held on superclasses as well as interfaces are evaluated by the Bean Validation provider.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance
ConstraintInheritanceTest.testConstraintsOnInterfaceAreInherited()
ConstraintInheritanceTest.testConstraintsOnSuperClassAreInherited()
c)

The effect of constraint declarations is cumulative. Constraints declared on a superclass getter will be validated along with any constraints defined on an overridden version of the getter according to the Java Language Specification visibility rules.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance
ConstraintInheritanceTest.testConstraintsOnInterfaceAndImplementationAddUp()
ConstraintInheritanceTest.testConstraintsOnSuperAndSubClassAddUp()

Section 4.4 - Group and group sequence

a)

If no group is explicitly declared, a constraint belongs to the Default group.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testConstraintWithNoExplicitlySpecifiedGroupBelongsToDefault()
b)

Groups are represented by interfaces.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testValidateAgainstDifferentGroups()
c)

A constraint can belong to one or more groups.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testValidationFailureInMultipleGroups()
GroupTest.testConstraintCanBelongToMoreThanOneGroup()
d)

During the validation call, one or more groups are validated. All the constraints belonging to this set of group is evaluated on the object graph.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testValidateAgainstDifferentGroups()
GroupTest.testGroups()
GroupTest.testGroupSequenceFollowedByGroup()

Section 4.4.1 - Group inheritance

a)

A group may inherit one or more groups by using interface inheritance.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.inheritance
GroupInheritanceTest.testGroupCanInheritGroupsViaInterfaceInheritance()
b)

For a given interface Z, constraints marked as belonging to the group Z (i.e. where the annotation element groups contains the interface Z) or any of the super interfaces of Z (inherited groups) are considered part of the group Z.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.inheritance
GroupInheritanceTest.testGroupMembership()

Section 4.4.2 - Group sequence

a)

By default, constraints are evaluated in no particular order regardless of which groups they belong to.

b)

Each group in a group sequence must be processed sequentially in the order defined by @GroupSequence.value when the group defined as a sequence is requested.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testFullGraphValidationBeforeNextGroupInSequence()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testGroupSequence()
org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testOnlyFirstGroupInSequenceGetEvaluated()
c)

Note that a group member of a sequence can itself be composed of several groups via inheritance or sequence definition. In this case, each composed group must respect the sequence order as well.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testGroupSequenceContainerOtherGroupSequences()
d)

If one of the groups processed in the sequence generates one or more constraint violations, the groups following in the sequence must not be processed.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testFullGraphValidationBeforeNextGroupInSequence()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testGroupSequence()
e)

Groups defining a sequence and groups composing a sequence must not be involved in a cyclic dependency: either directly or indirectly either through cascaded sequence definitions or group inheritance

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testCyclicGroupSequence()
f)

If a group containing such a circularity is evaluated, a GroupDefinitionException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testCyclicGroupSequence()
g)

Groups defining a sequence should not directly inherit other groups. In other words, the interface hosting the group sequence should not have any super interface.

h)

Groups defining a sequence should not be used directly in constraint declarations.

i)

To define a group as a sequence, the interface must be annotated with the @GroupSequence annotation.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testCyclicGroupSequence()
j)

A given constraint can belong to two or more groups ordered by a sequence. In this case, the constraint is evaluated as part of the first group and ignored in the subsequent group(s).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testOnlyFirstGroupInSequenceGetEvaluated()

Section 4.4.3 - Redefining the Default group for a class

a)

To redefine Default for a class, place a @GroupSequence annotation on the class; this sequence expresses the sequence of groups that does substitute Default for this class.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequenceisolation
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()
org.hibernate.beanvalidation.tck.tests.constraints.groups
DefaultGroupRedefinitionTest.testRedefiningDefaultGroup()
DefaultGroupRedefinitionTest.testValidatingAgainstRedefinedDefaultGroup()
b)

Constraints hosted on a class A and belonging to the Default group (by default or explicitly) implicitly belong to the group A.

c)

A sequence defined on a class A (i.e. redefining the Default groups for the class) must contain the group A.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequenceisolation
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()
org.hibernate.beanvalidation.tck.tests.constraints.groups
DefaultGroupRedefinitionTest.testGroupSequenceContainingDefault()
DefaultGroupRedefinitionTest.testGroupSequenceWithNoImplicitDefaultGroup()
d)

If a @GroupSequence redefining the Default group for a class A does not contain the group A, a GroupDefinitionException is raised when the class is validated or when its metadata is requested.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
DefaultGroupRedefinitionTest.testGroupSequenceContainingDefault()
DefaultGroupRedefinitionTest.testGroupSequenceWithNoImplicitDefaultGroup()

Section 4.4.4 - Implicit grouping

a)

Every constraint hosted on an interface Z and part of the Default group (implicitly or explicitly) belongs to the group Z.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testImplicitGrouping()

Section 4.4.5 - Group conversion

a)

@ConvertGroup and @ConvertGroup.List can be used everywhere @Valid can be used (associations, method/constructor parameters and return value). If these annotations are used without @Valid, a ConstraintDeclarationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnField()
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnProperty()
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnMethodReturnValue()
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnMethodParameter()
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnConstructorReturnValue()
InvalidGroupDefinitionsTest.testGroupConversionWithoutValidAnnotationOnConstructorParameter()
b)

Groups are passed as is to the nested elements unless the @ConvertGroup annotation is used.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.groupconversion
GroupConversionValidationTest.testGroupIsPassedAsIsToNestedElementWithoutConversion()
c)

If the group expected to be passed to the nested element validation is defined as the from attribute of a @ConvertGroup annotation, the group used to effectively validate the nested element is the corresponding group defined in the to attribute.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.groupconversion
GroupConversionValidationTest.testGroupConversionIsAppliedOnField()
GroupConversionValidationTest.testSeveralGroupConversionsAppliedOnField()
GroupConversionValidationTest.testGroupConversionIsAppliedOnProperty()
GroupConversionValidationTest.testGroupConversionIsAppliedOnMethodReturnValue()
GroupConversionValidationTest.testGroupConversionDefinedInSubClassIsAppliedOnMethodReturnValue()
GroupConversionValidationTest.testGroupConversionDefinedInImplementedClassIsAppliedOnMethodReturnValue()
GroupConversionValidationTest.testGroupConversionIsAppliedOnMethodParameter()
GroupConversionValidationTest.testGroupConversionIsAppliedOnConstructorReturnValue()
GroupConversionValidationTest.testGroupConversionIsAppliedOnConstructorParameter()
d)

Rules are not executed recursively.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.groupconversion
GroupConversionValidationTest.testGroupConversionIsNotExecutedRecursively()
e)

It is not legal to have more than one conversion rule containing the same from value. In this case, a ConstraintDeclarationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testSeveralGroupConversionsWithSameFrom()
f)

Like regular constraint declarations, the from attribute cannot refer to a group sequence. A ConstraintDeclarationException is raised in this situation.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testGroupConversionWithSequenceAsFrom()
g)

The to attribute can. The group sequence will then be expanded before validating the associated object.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.groupconversion
GroupConversionValidationTest.testGroupConversionWithSequenceAsTo()
h)

@ConvertGroup and @ConvertGroup.List can only be placed where @Valid is present to ensure proper respect of the Liskov substitution principle

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInSubClass()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInImplementingClass()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInParallelInterfaces()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInSuperClassAndImplementedInterface()
i)

Likewise, if a sub type overrides/implements a method originally defined in several parallel types of the hierarchy (e.g. two interfaces not extending each other, or a class and an interface not implemented by said class) and if that method's return value has been marked for cascading validation in one of the parallel types, no group conversion rule may be declared for that method's return value in the parallel types of the hierarchy.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testGroupConversionGivenOnReturnValueInParallelInterfaces()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnReturnValueInSuperClassAndImplementedInterface()
j)

If any of these rules is violated, a ConstraintDeclarationException is raised by default as defined in 4.5.5.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupconversion
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInSubClass()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInImplementingClass()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInParallelInterfaces()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnReturnValueInParallelInterfaces()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnParameterInSuperClassAndImplementedInterface()
InvalidGroupDefinitionsTest.testGroupConversionGivenOnReturnValueInSuperClassAndImplementedInterface()

Section 4.4.6 - Formal group definitions

a)

The group X contains the following constraints: every constraint declared by the class X which does not declare a group or does declare the group Default explicitly. every constraint declared by any interface implemented by X and not annotated @GroupSequence which does not explicitly declare a group or does declare the group Default explicitly. if X has a direct superclass Y, every constraint in the group Y

Coverage

No tests exist for this assertion

b)

If X has no @GroupSequence annotation, the group Default contains the following constraints: every constraint in the group X if X has a direct superclass Y, every constraint in the group Default of Y

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequenceisolation
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance3()
c)

If X does have a @GroupSequence annotation, the group Default contains every constraint belonging to every group declared by the @GroupSequence annotation.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequenceisolation
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()
GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()
d)

The @GroupSequence annotation must declare the group X

Coverage

No tests exist for this assertion

e)

For every interface Z, the group Z contains the following constraints: every constraint declared by the interface Z which does not explicitly declare a group or does declare the group Default explicitly. every constraint (which does not explicitly declare a group) declared by any superinterface not annotated @GroupSequence of the interface Z every constraint declared by the class X which explicitly declares the group Z every constraint declared by any interface implemented by X and not annotated @GroupSequence which explicitly declares the group Z if X has a direct superclass Y, every constraint in the group Z of Y

Coverage

No tests exist for this assertion

f)

For every interface Z annotated @GroupSequence, the group Z contains every constraint belonging to every group declared by the @GroupSequence annotation.

Coverage

No tests exist for this assertion

g)

When a given group G (represented by an interface G) is requested for the validation of a class X: constraints belonging to the group G are evaluated if the interface G is not annotated @GroupSequence, every group represented by the super interface of G are requested for validation if the interface G is annotated with @GroupSequence, every group represented by the interfaces declared by the @GroupSequence annotation are requested for validation the validation of groups declared to the @GroupSequence must happen in the sequencing order declared by @GroupSequence: the sequencing order is propagated to the groups composing the sequenced group (via inheritance or group sequence) if a group validation triggers the failure of one or more constraints, groups following in the sequence must not be evaluated. if the group G represents the Default group of X overridden by @GroupSequence, operations are equivalent

Coverage

No tests exist for this assertion

h)

When the Default group of a given class X is overridden via @GroupSequence, its validation is as followed: every group represented by the interfaces declared by the @GroupSequence annotation are requested for validation the validation of groups declared to the @GroupSequence must happen in the sequencing order declared by @GroupSequence: the sequencing order is propagated to the groups composing the sequenced group (via inheritance or group sequence) if a group validation triggers the failure of one or more constraints, groups following in the sequence must not be evaluated.

Coverage

No tests exist for this assertion

i)

Unless defined by a @GroupSequence, evaluation ordering is not constrained. In particular, several groups can be validated in the same pass.

j)

If a group definition leads to a circular sequencing order between groups, a GroupDefinitionException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testCyclicGroupSequence()

Section 4.5.1 - Requirements on methods to be validated

a)

Static methods are ignored by validation. Putting constraints on a static method is not portable.

Section 4.5.2 - Declaring parameter constraints

a)

Parameter constraints are declared by putting constraint annotations on method or constructor parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testMethodParameterConstraintsAreDeclaredByAnnotatingParameters()
MethodValidationRequirementTest.testConstructorParameterConstraintsAreDeclaredByAnnotatingParameters()

Section 4.5.2.1 - Cross-parameter constraints

a)

Cross-parameter constraints are declared by putting cross-parameter constraint annotations on methods or constructors

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testCrossParameterConstraintsAreDeclaredByAnnotatingMethods()
MethodValidationRequirementTest.testCrossParameterConstraintsAreDeclaredByAnnotatingConstructors()
b)

It is not legal to declare a cross-parameter constraint on a method or constructor which has no parameters. A ConstraintDeclarationException is raised in this case.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnMethodWithoutParametersCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetParametersOnConstructorWithoutParametersCausesException()
c)

They are known to be both generic and cross-parameter constraints. When using such a constraint on an executable to target the parameters, one must set validationAppliesTo if there is an ambiguity.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnMethodWithParametersAndReturnValueCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnConstructorWithParametersCausesException()
GenericAndCrossParameterConstraintTest.testOneValidatorSupportsBothValidationTargets()

Section 4.5.2.2 - Naming parameters

a)

A conforming Bean Validation implementation provides a default ParameterNameProvider implementation which returns parameter names in the form argPARAMETERINDEX, where PARAMETERINDEX starts at 0 for the first parameter, e.g. arg0, arg1 etc.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation.parameternameprovider
DefaultParameterNameProviderTest.testDefaultParameterProviderForMethod()
DefaultParameterNameProviderTest.testDefaultParameterProviderForConstructor()
b)

If an exception occurs during invocation of the getParameterNames() methods, this exception is wrapped into a ValidationException by the Bean Validation engine.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation.parameternameprovider
ParameterNameProviderTest.testExceptionInParameterNameProviderIsWrappedIntoValidationException()

Section 4.5.3 - Declaring return value constraints

a)

Return value constraints are declared by putting constraint annotations directly on a method or constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testReturnValueConstraintsAreDeclaredByAnnotatingMethods()
MethodValidationRequirementTest.testReturnValueConstraintsAreDeclaredByAnnotatingConstructors()
b)

They are known to be both generic and cross-parameter constraints. When using such constraint on an executable to target the return value, one must set validationAppliesTo in case there is an ambiguity.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.crossparameter
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnMethodWithParametersAndReturnValueCausesException()
InvalidDeclarationOfGenericAndCrossParameterConstraintTest.testConstraintTargetImplicitOnConstructorWithParametersCausesException()
GenericAndCrossParameterConstraintTest.testOneValidatorSupportsBothValidationTargets()

Section 4.5.4 - Marking parameters and return values for cascaded validation

a)

The @Valid annotation is used to declare that a cascaded validation of the given method/constructor parameters or return values is performed by the Bean Validation provider. When marked, the parameter or return value is considered a bean object to validate.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testMethodParameterIsMarkedAsCascaded()
MethodValidationRequirementTest.testConstructorParameterIsMarkedAsCascaded()
MethodValidationRequirementTest.testMethodReturnValueIsMarkedAsCascaded()
MethodValidationRequirementTest.testConstructorReturnValueIsMarkedAsCascaded()
b)

Null arguments and null return values are ignored

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testPassingNullToCascadedMethodParameterCausesNoViolation()
MethodValidationRequirementTest.testPassingNullToCascadedConstructorParameterCausesNoViolation()
MethodValidationRequirementTest.testReturningNullFromCascadedMethodCausesNoViolation()
c)

The validation is recursive; that is, if validated parameter or return value objects have references marked with @Valid themselves, these references will also be validated

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testCascadedMethodParameterIsValidatedRecursively()
MethodValidationRequirementTest.testCascadedConstructorParameterIsValidatedRecursively()
MethodValidationRequirementTest.testCascadedMethodReturnValueIsValidatedRecursively()
MethodValidationRequirementTest.testCascadedConstructorReturnValueIsValidatedRecursively()
d)

Bean Validation providers must guarantee the prevention of infinite loops during cascaded validation

Section 4.5.5 - Method constraints in inheritance hierarchies

a)

In sub types (be it sub classes/interfaces or interface implementations), no parameter constraints may be declared on overridden or implemented methods, nor may parameters be marked for cascaded validation. This would pose a strengthening of preconditions to be fulfilled by the caller.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.invaliddeclarations
InvalidMethodConstraintDeclarationTest.testParameterConstraintsAddedInInterfaceImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testParameterConstraintsAddedInSubClassCausesException()
InvalidMethodConstraintDeclarationTest.testParameterMarkedAsCascadedInInterfaceImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testParameterMarkedAsCascadedInSubClassCausesException()
b)

If a sub type overrides/implements a method originally defined in several parallel types of the hierarchy (e.g. two interfaces not extending each other, or a class and an interface not implemented by said class), no parameter constraints may be declared for that method at all nor parameters be marked for cascaded validation. This again is to avoid an unexpected strengthening of preconditions to be fulfilled by the caller.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.invaliddeclarations
InvalidMethodConstraintDeclarationTest.testConstrainedParameterInOneMethodOfParallelInterfacesCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsConstrainedInInterfaceMethodAndSuperClassMethodCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsCascadingInOneMethodOfParallelInterfacesCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsCascadingInInterfaceMethodAndSuperClassMethodCausesException()
c)

In sub types (be it sub classes/interfaces or interface implementations), return value constraints may be declared on overridden or implemented methods and the return value may be marked for cascaded validation. Upon validation, all return value constraints of the method in question are validated, wherever they are declared in the hierarchy. This only poses possibly a strengthening but no weakening of the method's postconditions guaranteed to the caller.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.validdeclarations
ValidMethodConstraintDeclarationTest.testReturnValueConstraintAddedInInterfaceImplementation()
ValidMethodConstraintDeclarationTest.testReturnValueConstraintAddedInSubClass()
ValidMethodConstraintDeclarationTest.testReturnValueMarkedAsCascadedInInterfaceImplementation()
ValidMethodConstraintDeclarationTest.testReturnValueConstraintFromInterfaceAndImplementationAddUp()
ValidMethodConstraintDeclarationTest.testReturnValueConstraintFromInterfacesAndImplementationAddUp()
ValidMethodConstraintDeclarationTest.testReturnValueMarkedAsCascadedInSubClass()
d)

One must not mark a method return value for cascaded validation more than once in a line of a class hierarchy. In other words, overriding methods on sub types (be it sub classes/interfaces or interface implementations) cannot mark the return value for cascaded validation if the return value has already been marked on the overridden method of the super type or interface.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.invaliddeclarations
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInInterfaceAndImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInBaseAndSubClassCausesException()
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInSuperAndDerivedInterfaceCausesException()
org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.validdeclarations
ValidMethodConstraintDeclarationTest.testReturnValueMarkedAsCascadedInParallelInterfaces()
e)

Out of the box, a conforming Bean Validation provider must throw a ConstraintDeclarationException when discovering that any of these rules are violated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.invaliddeclarations
InvalidMethodConstraintDeclarationTest.testParameterConstraintsAddedInInterfaceImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testParameterConstraintsAddedInSubClassCausesException()
InvalidMethodConstraintDeclarationTest.testParameterMarkedAsCascadedInInterfaceImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testParameterMarkedAsCascadedInSubClassCausesException()
InvalidMethodConstraintDeclarationTest.testConstrainedParameterInOneMethodOfParallelInterfacesCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsConstrainedInInterfaceMethodAndSuperClassMethodCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsCascadingInOneMethodOfParallelInterfacesCausesException()
InvalidMethodConstraintDeclarationTest.testParameterIsCascadingInInterfaceMethodAndSuperClassMethodCausesException()
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInInterfaceAndImplementationCausesException()
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInBaseAndSubClassCausesException()
InvalidMethodConstraintDeclarationTest.testReturnValueIsMarkedAsCascadedInSuperAndDerivedInterfaceCausesException()
f)

The above rules do not apply when validating constructor constraints as constructors do not override one another. Parameter and return value constraints can be applied to any constructor in the type hierarchy, but only the constraints defined directly on the validated constructor are evaluated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.inheritance.method.validdeclarations
ValidMethodConstraintDeclarationTest.testParameterConstraintAddedToConstructorInSubClass()
ValidMethodConstraintDeclarationTest.testParameterConstraintMarkedAsCascadedAtConstructorInSubClass()
ValidMethodConstraintDeclarationTest.testReturnValueConstraintAddedToConstructorInSubClass()
ValidMethodConstraintDeclarationTest.testReturnValueMarkedAsCascadedAtConstructorInSuperAndSubClass()

Section 4.6 - Validation routine

a)

For a given group, the validation routine applied on a given bean instance is expected to execute the following constraint validations in no particular order: for all reachable fields, execute all field level validations (including the ones expressed on superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. for all reachable getters, execute all getter level validations (including the ones expressed on interfaces and superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. execute all class level validations (including the ones expressed on interfaces and superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. for all reachable and cascadable associations, execute all cascading validations (see 4.6.1) including the ones expressed on interfaces and superclasses (see 4.4.6). Note that group conversion can apply (see 4.4.5).

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
ValidateTest.testClassLevelConstraintViolation()
ValidateTest.testGraphValidationWithList()
org.hibernate.beanvalidation.tck.tests.validation.groupconversion
GroupConversionValidationTest.testGroupConversionIsAppliedOnField()
GroupConversionValidationTest.testSeveralGroupConversionsAppliedOnField()
org.hibernate.beanvalidation.tck.tests.validation
ValueAccessStrategyTest.testValueFromFieldIsPassedToValidatorOfFieldLevelConstraint()
ValueAccessStrategyTest.testValueFromGetterIsPassedToValidatorOfPropertyLevelConstraint()
org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testValidationFailureInMultipleGroups()
org.hibernate.beanvalidation.tck.tests.constraints.inheritance
ConstraintInheritanceTest.testValidationConsidersConstraintsFromSuperTypes()
b)

Unless ordered by group sequences, groups can be validated in no particular order.

c)

The object validation routine is described as such. For each constraint declaration: determine for the constraint declaration, the appropriate ConstraintValidator to use (see 4.6.4). execute the isValid operation (from the constraint validation implementation) on the appropriate data (see 3.4) if isValid() returns true, continue to the next constraint, if isValid() returns false, the Bean Validation provider populates ConstraintViolation object(s) according to the rules defined in 3.4 and appends these objects to the list of constraint violations.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testMultipleConstraintViolationOfDifferentTypes()
ValidateTest.testConstraintViolation()

Section 4.6.1 - Object graph validation

a)

The @Valid annotation on a given association (i.e. object reference or collection, array, Iterable of objects), dictates the Bean Validator implementation to apply recursively the Bean Validation routine on (each of) the associated object(s).

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testGraphNavigationDeterminism()
b)

This mechanism is recursive: an associated object can itself contain cascaded references.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testGraphNavigationDeterminism()
c)

Null references are ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testNullReferencesGetIgnored()
d)

To prevent infinite loops, the Bean Validation implementation must ignore the cascading operation if the associated object instance has already been validated in the current navigation path (starting from the root object).

Coverage

org.hibernate.beanvalidation.tck.tests.validation.graphnavigation
GraphNavigationTest.testNoEndlessLoop()
e)

@Valid is an orthogonal concept to the notion of group. If two groups are in sequence, the first group must pass for all associated objects before the second group is evaluated.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequenceisolation
GroupSequenceIsolationTest.testCorrectDefaultSequenceContainedCaseWithoutGroupRedefinitionOnContainedEntity()
GroupSequenceIsolationTest.testCorrectDefaultSequenceContainedCaseWithGroupRedefinitionOnContainedEntity()

Section 4.6.2 - Method and constructor validation

a)

For a given group, the validation routine applied to validate parameters of a method or constructor is expected to execute the following constraint validations in no particular order: execute all parameter validations (in case of overriding method validation, including the ones expressed on overridden methods of the interfaces and superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. execute all cross parameter validations (in case of overriding method validation, including the ones expressed on overridden methods of the interfaces and superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. for all parameters marked for cascaded validation, execute all cascading validations (see 4.6.1), in case of overriding method validation including the ones expressed on overridden methods of the interfaces and superclasses (see 4.4.6). Note that group conversion can apply (see 4.4.5).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
MethodValidationTest.methodParameterValidationTargetsParameterCrossParameterAndCascadedConstraints()
MethodValidationTest.methodParameterValidationIncludesConstraintsFromSuperClass()
MethodValidationTest.methodParameterValidationIncludesConstraintsFromImplementedInterface()
MethodValidationTest.methodParameterValidationIsAppliedGroupWise()
MethodValidationTest.methodParameterValidationPerformsGroupConversion()
MethodValidationTest.methodParameterValidationValidatesEachConstraintOnlyOnce()
MethodValidationTest.methodParameterValidationUsingSequence()
MethodValidationTest.methodParameterValidationWithRedefinedDefaultGroupSequence()
MethodValidationTest.constructorParameterValidationTargetsParameterCrossParameterAndCascadedConstraints()
MethodValidationTest.constructorParameterValidationDoesNotIncludeConstraintsFromSuperClass()
MethodValidationTest.constructorParameterValidationIsAppliedGroupWise()
MethodValidationTest.constructorParameterValidationPerformsGroupConversion()
MethodValidationTest.constructorParameterValidationValidatesEachConstraintOnlyOnce()
MethodValidationTest.constructorParameterValidationUsingSequence()
MethodValidationTest.constructorParameterValidationWithRedefinedDefaultGroupSequence()
c)

For a given group, the validation routine applied to validate the return value of a method or constructor is expected to execute the following constraint validations in no particular order: execute all return value validations (including the ones expressed on interfaces and superclasses) matching the targeted group unless the given validation constraint has already been processed during this validation routine for a given navigation path (see 4.6.1) as part of a previous group match. if the return value is marked for cascaded validation, execute all cascading validations (see 4.6.1) including the ones expressed on interfaces and superclasses (see 4.4.6). Note that group conversion can apply (see 4.4.5).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
MethodValidationTest.methodReturnValueValidationTargetsReturnValueAndCascadedConstraints()
MethodValidationTest.methodReturnValueValidationIncludesConstraintsFromSuperClass()
MethodValidationTest.methodReturnValueValidationIncludesConstraintsFromImplementedInterface()
MethodValidationTest.methodReturnValueValidationIsAppliedGroupWise()
MethodValidationTest.methodReturnValueValidationPerformsGroupConversion()
MethodValidationTest.methodReturnValueValidationValidatesEachConstraintOnlyOnce()
MethodValidationTest.methodReturnValueValidationUsingSequence()
MethodValidationTest.methodReturnValueValidationWithRedefinedDefaultGroupSequence()
MethodValidationTest.constructorReturnValueValidationTargetsReturnValueAndCascadedConstraints()
MethodValidationTest.constructorReturnValueValidationDoesNotIncludeConstraintsFromSuperClass()
MethodValidationTest.constructorReturnValueValidationIsAppliedGroupWise()
MethodValidationTest.constructorReturnValueValidationPerformsGroupConversion()
MethodValidationTest.constructorReturnValueValidationValidatesEachConstraintOnlyOnce()
MethodValidationTest.constructorReturnValueValidationUsingSequence()
MethodValidationTest.constructorReturnValueValidationWithRedefinedDefaultGroupSequence()
d)

Unless ordered by group sequences, groups can be validated in no particular order.

Section 4.6.3 - Traversable property

a)

isReachable() is called for every property about to be accessed either for validation or for cascading.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
b)

isCascadable() is called for every property about to be cascaded (i.e. marked as @Valid).

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
c)

isCascadable() for a given property is only called if isReachable() returns true. In other words, isReachable() is always called before isCascadable() for a given property.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
d)

traversableObject is the object instance being evaluated. null if the check is triggered as part of a validateValue() call.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
e)

traversableProperty is the Node representing the property hosted by the traversableObject being considered for traversal. The name of a property is defined in 4.1.2.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
f)

rootBeanType is the class of the root being validated, i.e. either the type of the object passed to the validate method or the type declaring the validated method/constructor in case of method validation).

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
g)

pathToTraversableObject is the Path from the rootBeanType down to the traversableObject. If the root object is traversableObject, pathToTraversableObject is composed of a single Node whose name is null. The path is described following the conventions described in 5.2 (getPropertyPath).

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
h)

elementType is the java.lang.annotation.ElementType the annotation is placed on. It can be either FIELD or METHOD. Any other value is not expected.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForValidateValue()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
i)

The Bean Validation provider must not access the state of a property, nor validate its constraints if the property is not traversable. A property is traversable if TraversableResolver returns true for this property.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCustomTraversableResolverViaConfiguration()
j)

If an exception occurs when the TraversableResolver is called, the exception is wrapped into a ValidationException.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testResolverExceptionsGetWrappedInValidationException()
k)

The following elements are not passed through the traversable resolver filter: the bean instance validated the method and constructor parameter values being validated the method and constructor return value being validated

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
l)

But the properties of these elements (if validated) are. In this case the complete path is provided via pathToTraversableObject.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadable()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForParameterValidation()
TraversableResolverTest.testCorrectCallsToIsReachableAndIsCascadableForReturnValueValidation()
m)

If Java Persistence is available in the runtime environment, a property is considered reachable if Java Persistence considers the property as loaded.

n)

If Java Persistence is not available in the runtime environment, all properties are considered reachable.

o)

All properties are considered cascadable.

Section 4.6.4 - ConstraintValidator resolution algorithm

a)

The list of ConstraintValidators can contain at most one which targets cross-parameter. If the constraint targets the parameters of an executable either implicitly or by the use of validationAppliesTo in the constraint - see 3.1.1.4, then the cross-parameter ConstraintValidator is used. If none is present, a ConstraintDefinitionException is raised. If more than one cross-parameter ConstraintValidator is present, a ConstraintDefinitionException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testCrossParameterValidatorValidatingObjectArray()
ValidatorResolutionTest.testCrossParameterValidatorValidatingObject()
ValidatorResolutionTest.testSeveralCrossParameterValidatorsCauseConstraintDefinitionException()
ValidatorResolutionTest.testCrossParameterConstraintWithoutValidatorCausesConstraintDefinitionException()
ValidatorResolutionTest.testCrossParameterValidatorIsUsedForConstraintImplicitlyTargetingParameters()
ValidatorResolutionTest.testCrossParameterValidatorIsUsedForConstraintExplicitlyTargetingParameters()
b)

If the constraint is a generic constraint, the following rules apply. If the constraint declaration is hosted on a class or an interface, the targeted type is the class or the interface.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testTargetTypeIsInterface()
ValidatorResolutionTest.testTargetTypeIsClass()
c)

If the constraint is hosted on a class attribute, the type of the attribute is the targeted type.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testTargetedTypeIsField()
d)

If the constraint is hosted on a getter, the return type of the getter is the targeted type.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testTargetedTypeIsGetter()
e)

The ConstraintValidator chosen to validate the generic constraint on a declared type T is the one where the ConstraintValidator targets the annotated element, where the type supported by the ConstraintValidator is a supertype of T and where there is no other ConstraintValidator whose supported type is a supertype of T and not a supertype of the chosen ConstraintValidator supported type.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testResolutionOfMultipleSizeValidators()
ValidatorResolutionTest.testResolutionOfMinMaxForDifferentTypes()
f)

Only ConstraintValidator implementations targeting annotated elements are considered.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testGenericValidatorIsUsedForConstraintTargetingMethodReturnValue()
ValidatorResolutionTest.testGenericValidatorIsUsedForConstraintTargetingField()
g)

Primitive types are considered equivalent to their respective primitive wrapper class.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testValidatorForWrapperTypeIsAppliedForPrimitiveType()
h)

If no ConstraintValidator compliant with T is found amongst the ConstraintValidators listed by the constraint A, an UnexpectedTypeException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testUnexpectedTypeException()
org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()
j)

A ConstraintValidator<A, U> compliant with T is considered strictly more specific than a ConstraintValidator<A, V> compliant with T if U is a strict subtype of V. U is a strict subtype of V if U is a subtype of V and U != V (according to the Java Language Specification 3rd edition chapter 4.10 Subtyping).

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testTargetedTypeIsField()
ValidatorResolutionTest.testTargetedTypeIsGetter()
ValidatorResolutionTest.testClassLevelValidatorForSubTypeHasPredenceOverValidatorForSuperClass()
k)

If more than one maximally specific ConstraintValidator is found, an UnexpectedTypeException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testAmbiguousValidatorResolution()
ValidatorResolutionTest.testTwoValidatorsForSameTypeCauseUnexpectedTypeException()

Section 5.1 - Validator API

a)

Validator implementations must be thread-safe.

Section 5.1.1 - Validation methods

a)

<T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) is used to validate a given object.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testMultipleViolationOfTheSameType()
b)

An IllegalArgumentException is thrown when null is passed for the object parameter or the varargs groups parameter.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testValidateWithNullValue()
ValidateTest.testValidateWithNullGroup()
c)

A Set containing all ConstraintViolation objects representing the failing constraints is returned, an empty Set is returned otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testMultipleViolationOfTheSameType()
ValidateTest.testMultipleConstraintViolationOfDifferentTypes()
ValidatePropertyTest.testValidateProperty()
d)

<T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups) validates a given field or property of an object.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidatePropertyTest.testValidateProperty()
e)

An IllegalArgumentException is thrown when validateProperty() is called and object is null or propertyName is null empty or invalid or null is passed to the varargs groups parameter.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidatePropertyTest.testValidatePropertyWithInvalidPropertyPath()
ValidatePropertyTest.testPassingNullAsGroup()
ValidatePropertyTest.testIllegalArgumentExceptionIsThrownForNullValue()
ValidatePropertyTest.testValidatePropertyWithNullProperty()
ValidatePropertyTest.testValidatePropertyWithEmptyProperty()
f)

The property name is the JavaBeans property name (as defined by the JavaBeans Introspector class).

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidatePropertyTest.testValidatePropertyWithInvalidPropertyPath()
ValidatePropertyTest.testValidateProperty()
g)

@Valid is not honored by this method.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidatePropertyTest.testValidIsNotHonoredValidateProperty()
h)

<T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) validates the property referenced by propertyName present on beanType or any of its superclasses, if the property value were value.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateValueTest.testValidateValueSuccess()
ValidateValueTest.testValidateValueFailure()
i)

An IllegalArgumentException is thrown when validateValue() is called and object is null or propertyName is null empty or invalid or null is passed to the varargs groups parameter.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValueWithInvalidPropertyPath()
ValidateValueTest.testExistingPropertyWoConstraintsNorCascaded()
ValidateValueTest.testValidateValuePassingNullAsGroup()
ValidateValueTest.testValidateValueWithEmptyPropertyPath()
ValidateValueTest.testValidateValueWithNullObject()
ValidateValueTest.testValidateValueWithNullPropertyName()
j)

@Valid is not honored by this method.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidIsNotHonoredValidateValue()
k)

If some unrecoverable failure happens during validation, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testUnexpectedExceptionsInValidateGetWrappedInValidationExceptions()
ValidatePropertyTest.testUnexpectedExceptionsInValidatePropertyGetWrappedInValidationExceptions()

Section 5.1.2 - Methods for validating method and constructor constraints

a)

<T> Set<ConstraintViolation<T>> validateParameters(T object, Method method, Object[] parameterValues, Class<?>... groups) validates the arguments (as given in parameterValues) for the parameters of a given method (identified by method). Cross-parameter constraints are also validated.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testUnexpectedType()
org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testMethodParameterAndCrossParameterConstraintsAreEvaluatedAtTheSameTime()
b)

A set containing all ConstraintViolation objects representing the failing constraints is returned, an empty set is returned if no constraint violation occurred.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testOneViolationFromCrossParameterConstraint()
ValidateParametersTest.testTwoViolations()
ValidateParametersTest.testTwoViolationsOnSameParameter()
ValidateParametersTest.testTwoConstraintsOfSameType()
ValidateParametersTest.testCrossParameterConstraintGivenSeveralTimes()
ValidateParametersTest.testNoViolations()
ValidateParametersTest.testValidationWithGroup()
ValidateParametersTest.testCrossParameterConstraintValidationWithGroup()
ValidateParametersTest.testValidationWithSeveralGroups()
c)

An IllegalArgumentException will be thrown if null is passed for any of the parameters or if the parameters don't match with each other (i.e. object and method don't match, parameterValues and method don't match).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateParametersTest.testNullPassedForObjectCausesException()
ValidateParametersTest.testNullPassedForMethodCausesException()
ValidateParametersTest.testNullPassedForParameterValuesCausesException()
ValidateParametersTest.testNullPassedForGroupsCausesException()
ValidateParametersTest.testNullPassedAsSingleGroupCausesException()
d)

<T> Set<ConstraintViolation<T>> validateReturnValue(T object, Method method, Object returnValue, Class<?>... groups) validates the return value (specified by returnValue) of a given method (identified by method).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testUnexpectedType()
e)

A set containing all ConstraintViolation objects representing the failing constraints is returned, an empty set is returned if no constraint violation occurred.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testTwoViolations()
ValidateReturnValueTest.testTwoConstraintsOfSameType()
ValidateReturnValueTest.testNoViolations()
ValidateReturnValueTest.testValidationWithGroup()
ValidateReturnValueTest.testValidationWithSeveralGroups()
f)

An IllegalArgumentException will be thrown if null is passed for any of the parameters object, method and groups or if the parameters don't match with each other (i.e. object and method don't match, returnValue and method don't match).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateReturnValueTest.testNullPassedForObjectCausesException()
ValidateReturnValueTest.testNullPassedForMethodCausesException()
ValidateReturnValueTest.testNullPassedForGroupsCausesException()
ValidateReturnValueTest.testNullPassedAsSingleGroupCausesException()
g)

<T> Set<ConstraintViolation<T>> validateConstructorParameters(Constructor<T> constructor, Object[] parameterValues, Class<?>... groups) validates the arguments (as given in parameterValues) for the parameters of a given constructor (identified by constructor). Cross-parameter constraints are also validated.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testUnexpectedType()
org.hibernate.beanvalidation.tck.tests.constraints.application.method
MethodValidationRequirementTest.testConstructorParameterAndCrossParameterConstraintsAreEvaluatedAtTheSameTime()
h)

A set containing all ConstraintViolation objects representing the failing constraints is returned, an empty set is returned if no constraint violation occurred.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolationFromCrossParameterConstraint()
ValidateConstructorParametersTest.testTwoViolations()
ValidateConstructorParametersTest.testTwoViolationsOnSameParameter()
ValidateConstructorParametersTest.testTwoConstraintsOfSameType()
ValidateConstructorParametersTest.testCrossParameterConstraintGivenSeveralTimes()
ValidateConstructorParametersTest.testNoViolations()
ValidateConstructorParametersTest.testValidationWithGroup()
ValidateConstructorParametersTest.testCrossParameterConstraintValidationWithGroup()
ValidateConstructorParametersTest.testValidationWithSeveralGroups()
i)

An IllegalArgumentException will be thrown if null is passed for any of the parameters or if the parameters don't match with each other (i.e. parameterValues and constructor don't match).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorParametersTest.testNullPassedForConstructorCausesException()
ValidateConstructorParametersTest.testNullPassedForParameterValuesCausesException()
ValidateConstructorParametersTest.testNullPassedForGroupsCausesException()
ValidateConstructorParametersTest.testNullPassedAsSingleGroupCausesException()
j)

<T> Set<ConstraintViolation<T>> validateConstructorReturnValue(Constructor<T> constructor, T createdObject, Class<?>... groups) validates the object (specified by createdObject) of a given constructor (identified by constructor).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testUnexpectedType()
k)

A set containing all ConstraintViolation objects representing the failing constraints is returned, an empty set is returned if no constraint violation occurred.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testTwoViolations()
ValidateConstructorReturnValueTest.testTwoConstraintsOfSameType()
ValidateConstructorReturnValueTest.testNoViolations()
ValidateConstructorReturnValueTest.testValidationWithGroup()
ValidateConstructorReturnValueTest.testValidationWithSeveralGroups()
l)

An IllegalArgumentException will be thrown if null is passed for any of the parameters or if the parameters don't match with each other (i.e. createdObject and constructor don't match).

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testNullPassedForConstructorCausesException()
ValidateConstructorReturnValueTest.testNullPassedForReturnValueCausesException()
ValidateConstructorReturnValueTest.testNullPassedForGroupsCausesException()
ValidateConstructorReturnValueTest.testNullPassedAsSingleGroupCausesException()
m)

None of those methods honor the XML configuration around executable validation nor the presence of @ValidateOnExecution. In other words, elements will be validated regardless of these settings when explicitly calling the validation methods.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateConstructorParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateConstructorReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnExecutableLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateConstructorParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnExecutableLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnExecutableLevel()
ExecutableValidationIgnoresValidatedExecutableAnnotationSettingsTest.testValidateConstructorReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEOnExecutableLevel()
ExecutableValidationIgnoresValidatedExecutableXmlSettingsTest.testValidateParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEInXml()
ExecutableValidationIgnoresValidatedExecutableXmlSettingsTest.testValidateConstructorParametersYieldsConstraintViolationIfValidateExecutableIsSetToNONEInXml()
ExecutableValidationIgnoresValidatedExecutableXmlSettingsTest.testValidateReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEInXml()
ExecutableValidationIgnoresValidatedExecutableXmlSettingsTest.testValidateConstructorReturnValueYieldsConstraintViolationIfValidateExecutableIsSetToNONEInXml()

Section 5.1.3 - groups

a)

All constraints belonging to the targeted group(s) are applied during the 4.6.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidate()
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateProperty()
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateValue()
b)

If no group is passed, the Default group is assumed.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidate()
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateProperty()
ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateValue()
c)

When more than one group is evaluated and passed to the various validate methods, order is not constrained.

Section 5.2 - ConstraintViolation

a)

The getMessage() method returns the interpolated (localized) message for the failing constraint

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
b)

The getMessageTemplate() method returns the non-interpolated error message

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
c)

The getRootBean() method returns the root object being validated that led to the failing constraint

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
ValidateTest.testClassLevelConstraintViolation()
d)

For method validation, returns the object the method is executed on. For constructors or when Validator.validateValue() is used, returns null.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolation()
ValidateParametersTest.testOneViolation()
e)

The getRootBeanClass() method returns the class of the root bean being validated. For method validation, this is the object class the method is executed on. For constructor validation, this is the class the constructor is declared on.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateTest.testConstraintViolation()
ValidateTest.testClassLevelConstraintViolation()
ValidatePropertyTest.testValidateProperty()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolation()
ValidateParametersTest.testOneViolation()
f)

The getLeafBean() method returns the following object: If a bean constraint, the bean instance the constraint is applied on. If a property constraint, the bean instance hosting the property the constraint is applied on. If a property constraint, null when the ConstraintViolation is returned after calling Validator.validateValue(). If a method parameter, cross-parameter or return value constraint, the object the method is executed on. If a constructor parameter or cross-parameter constraint, null. If a constructor return value constraint, the object the constructor has created.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateTest.testConstraintViolation()
ValidateTest.testClassLevelConstraintViolation()
ValidateTest.testGraphValidationWithList()
ValidatePropertyTest.testValidateProperty()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testOneViolationForCascadedValidation()
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolationForCascadedValidation()
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolationFromCrossParameterConstraint()
ValidateConstructorParametersTest.testOneViolationForCascadedValidation()
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testOneViolationFromCrossParameterConstraint()
ValidateParametersTest.testOneViolationForCascadedValidation()
g)

The getExecutableParameters() returns the parameters provided to the method or constructor invocation or null if not validating the method or constructor parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateTest.testConstraintViolation()
ValidatePropertyTest.testValidateProperty()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testOneViolationForCascadedValidation()
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolationForCascadedValidation()
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolationForCascadedValidation()
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testOneViolationForCascadedValidation()
h)

The getExecutableReturnValue() returns the return value of the method or constructor invocation or null if the method has no return value or if not validating the method or constructor return value.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateTest.testConstraintViolation()
ValidatePropertyTest.testValidateProperty()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testOneViolationForCascadedValidation()
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolationForCascadedValidation()
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolationForCascadedValidation()
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testOneViolationForCascadedValidation()
i)

The getInvalidValue() method returns the value (field, property, method/constructor parameter, method/constructor return value or validated object) being passed to isValid().

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateValueTest.testValidateValue()
ValidateTest.testConstraintViolation()
ValidateTest.testClassLevelConstraintViolation()
ValidatePropertyTest.testValidateProperty()
org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorReturnValueTest.testOneViolation()
ValidateConstructorReturnValueTest.testOneViolationForCascadedValidation()
ValidateReturnValueTest.testOneViolation()
ValidateReturnValueTest.testOneViolationForCascadedValidation()
ValidateConstructorParametersTest.testOneViolation()
ValidateConstructorParametersTest.testOneViolationForCascadedValidation()
ValidateParametersTest.testOneViolation()
ValidateParametersTest.testOneViolationForCascadedValidation()
j)

For a cross-parameter constraint failure, an Object[] representing the method/constructor invocation arguments is returned.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation
ValidateConstructorParametersTest.testOneViolationFromCrossParameterConstraint()
ValidateParametersTest.testOneViolationFromCrossParameterConstraint()
k)

getConstraintDescriptor() provides access to the failing constraint metadata

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
l)

The getPropertyPath() method returns the Path object representing the navigation path from the root object to the failing object.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
m)

getName() returns the name of the element which the node represents

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
n)

isInIterable() returns true if the node represents an object contained in an Iterable or in a Map, false otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
o)

getIndex() returns the index of the node if it is contained in an array or List. Returns null otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
p)

getKey() returns the key of the node if it is contained in a Map. Returns null otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
q)

getKind() returns the ElementKind corresponding to the actual node type. This can be used in conjunction with the method as() to narrow the type and access node specific methods

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
r)

as(Class<? extends Node>) returns the node instance narrowed to the type passed as a parameter or ClassCastException if the type and node don't match.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPassingWrongTypeToAsOnBeanNodeCausesClassCastException()
PropertyPathTest.testPassingWrongTypeToAsOnConstructorNodeCausesClassCastException()
PropertyPathTest.testPassingWrongTypeToAsOnParameterNodeCausesClassCastException()
s)

In particular, MethodNode and ConstructorNode host getParameterTypes() which return the method or constructor parameter list.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
t)

Likewise ParameterNode hosts getParameterIndex() which returns the parameter index in the method or constructor parameter list.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
u)

The runtime type is considered, not the static type. For example if a property is declared Collection<String> but its runtime type is ArrayList<String>, the property is considered an ArrayList<String>.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
v)

If the failing object is the root object, a BeanNode with name set to null is added to the Path. The ElementKind of the node is ElementKind.BEAN.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
w)

A PropertyNode object whose name equals the name of the association property (field name or Java Bean property name) is added to Path. The ElementKind of the node is ElementKind.PROPERTY.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversedObject()
x)

If the association is a List or an array, the following Node object added contains the index value in getIndex().

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
y)

If the association is a Map, the following Node object added (representing a given map entry) contains the key value in getKey()

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithMap()
z)

For all Iterable or Map, the following Node object added is marked as inIterable (isInIterable())

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithList()
PropertyPathTest.testPropertyPathWithArray()
PropertyPathTest.testPropertyPathWithRuntimeTypeList()
PropertyPathTest.testPropertyPathWithMap()
PropertyPathTest.testPropertyPathSet()
aa)

For a property level constraint (field and getter) a PropertyNode object is added to Path whose name equals the name of the property (field name or Java Bean property name). The ElementKind of the is ElementKind.PROPERTY. the property path is considered complete

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversedObject()
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
ab)

For a class level constraint: a BeanNode object is added to Path whose name is null. The ElementKind of the node is ElementKind.BEAN. the property path is considered complete

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()
ac)

A MethodNode respectively a ConstructorNode object is added to the Path which represents the validated method respectively constructor. The name of the node equals the validated method name or the validated constructor's unqualified class name, the ElementKind of the node is ElementKind.METHOD respectively ElementKind.CONSTRUCTOR.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
ad)

If the constraint is on a parameter, a ParameterNode object is added to the Path which represents the validated parameter. The name of the node equals the parameter name as determined by the current parameter name provider (see 4.5.2.2). The ElementKind of the node is elementKind.PARAMETER.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
ae)

If the constraint is a cross-parameter constraint, a CrossParameterNode object is added to the Path which represents the validated cross-parameter element. The name of the node has the constant value <cross-parameter>. The ElementKind of the node is ElementKind.CROSS_PARAMETER.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
af)

If the constraint is on the return value, a ReturnValueNode object is added to the Path which represents the validated return value. The name of the node has the constant value <return value>. The ElementKind of the node is ElementKind.RETURN_VALUE.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
ag)

The property path is considered complete

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathForMethodParameterConstraint()
PropertyPathTest.testPropertyPathForMethodParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForMethodReturnValueConstraint()
PropertyPathTest.testPropertyPathForMethodCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorParameterConstraintWithCustomParameterNameProvider()
PropertyPathTest.testPropertyPathForConstructorCrossParameterConstraint()
PropertyPathTest.testPropertyPathForConstructorReturnValueConstraint()
ah)

A MethodNode respectively ConstructorNode object is added to the Path which represents the concerned method respectively constructor. The name of the node equals the concerned method name or the constructor's unqualified class name, the ElementKind of the node is ElementKind.METHOD or ElementKind.CONSTRUCTOR, respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
ai)

If a parameter is traversed, a ParameterNode object is added to the Path which represents the traversed parameter. The name of the node equals the parameter name as determined by the current parameter name provider. The ElementKind of the node is ElementKind.PARAMETER.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodParameter()
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
aj)

If a return value is traversed, a ReturnValueNode object is added to the Path which represents the traversed return value. The name of the node has the constant value <return value>. The ElementKind of the node is ElementKind.RETURN_VALUE.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
PropertyPathTest.testPropertyPathTraversingConstructorReturnValue()
ak)

If the parameter/return value is a List or an array, the following Node object added contains the index value in getIndex().

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
al)

If the parameter/return value is a Map, the following Node object added (representing a given map entry) contains the key value in getKey().

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
am)

For all Iterable or Map, the following Node object added is marked as inIterable (isInIterable()).

Coverage

org.hibernate.beanvalidation.tck.tests.validation
PropertyPathTest.testPropertyPathTraversingMethodListParameter()
PropertyPathTest.testPropertyPathTraversingMethodArrayParameter()
PropertyPathTest.testPropertyPathTraversingMethodSetParameter()
PropertyPathTest.testPropertyPathTraversingMethodMapParameter()
PropertyPathTest.testPropertyPathTraversingConstructorListParameter()
PropertyPathTest.testPropertyPathTraversingConstructorArrayParameter()
PropertyPathTest.testPropertyPathTraversingConstructorSetParameter()
PropertyPathTest.testPropertyPathTraversingConstructorMapParameter()
PropertyPathTest.testPropertyPathTraversingMethodListReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodArrayReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodSetReturnValue()
PropertyPathTest.testPropertyPathTraversingMethodMapReturnValue()
an)

If additional path nodes are added in a constraint validator implementation using the node builder API (see 3.4), the following rules apply: if the default path ends with a BeanNode, this node is removed and the first added node (a PropertyNode) inherits its inIterable, key and index values. inIterable, key and index value must not be specified directly on this first node by the user. if the default path ends with a CrossParameterNode, this node is removed. then the additional nodes are appended to the (possibly amended) path generated by the Bean Validation engine as previously described: A PropertyNode is appended in case addPropertyNode(String) is invoked. The node name is equal to the name provided. The ElementKind of the node is ElementKind.PROPERTY. A BeanNode is appended in case addBeanNode() is invoked. The node name is null. The ElementKind of the node is ElementKind.BEAN. A ParameterNode is appended in case addParameterNode(int) is invoked. The node name is equal to the parameter name at the provided index. The name is determined by the current parameter name provider. The ElementKind of the node is ElementKind.PARAMETER. The previous node (removed) must be a CrossParameterNode. if inIterable() is invoked, the node returns true for isInIterable(), false otherwise. if atIndex(Integer) is invoked, the node returns the provided integer for getIndex(), null otherwise. if atKey(Object) is invoked, the node returns the provided object for getKey(), null otherwise.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
CustomPropertyPathTest.testAddPropertyNode()
CustomPropertyPathTest.testAddBeanNode()
CustomPropertyPathTest.testAddingNodesInClassLevelConstraintKeepsInIterableKeyAndIndex()
CustomPropertyPathTest.testAddParameterNode()
CustomPropertyPathTest.testAddParameterNodeUsingCustomParameterNameProvider()
CustomPropertyPathTest.testAddParameterNodeForFieldLevelConstraintCausesException()
au)

Bean Validation implementations should ensure that a ConstraintViolation implementation is Serializable provided that the root bean, the leaf bean, the invalid value and keys in the Path object are Serializable objects.

Section 5.3.1 - Default message interpolation

a)

Every conforming Bean Validation implementation includes a default message interpolator which has to comply with

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testDefaultMessageInterpolatorIsNotNull()
b)

Each constraint defines a message descriptor via its message property.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()
c)

Every constraint definition defines a default message descriptor for that constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()
d)

Messages can be overridden at constraint declaration time by setting the message property on the constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testMessagesCanBeOverriddenAtConstraintLevel()
e)

The message descriptor is a string literal and may contain one or more message parameters or expressions. Message parameters and expressions are string literals enclosed in {} or ${} respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithElExpression()
f)

\{ is considered as the literal { instead of being considered as the beginning of a message parameter

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testEscapedCharactersAreConsideredAsLiterals()
g)

\} is considered as the literal } instead of being considered as the end of a message parameter

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testEscapedCharactersAreConsideredAsLiterals()
h)

\\ is considered as the literal \ instead of being considered as the escaping character

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testEscapedCharactersAreConsideredAsLiterals()
i)

\$ is considered as the literal $ instead of being considered as the beginning of a message expression

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testEscapedCharactersAreConsideredAsLiterals()

Section 5.3.1.1 - Default message interpolation algorithm

a)

Message parameters are extracted from the message string and used as keys to search the ResourceBundle named ValidationMessages

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()
MessageInterpolationTest.testUnSuccessfulInterpolation()
MessageInterpolationTest.testUnknownTokenInterpolation()
b)

Step 1 is applied recursively until no replacement is performed

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testRecursiveMessageInterpolation()
c)

Message parameters are extracted from the message string and used as keys to search the Bean Validation provider's built-in ResourceBundle using the defined locale (see 5.3.1.2). If a property is found, the message parameter is replaced with the property value in the message string.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testParametersAreExtractedFromBeanValidationProviderBundle()
d)

Contrary to step 1, step 2 is not processed recursively.

e)

If step 2 triggers a replacement, then step 1 is applied again.

f)

Message parameters are extracted from the message string. Those matching the name of an attribute of the constraint are replaced by the value of that attribute in the constraint declaration. Parameter interpolation has precedence over message expressions. For example for the message descriptor ${value}, trying to evaluate {value} as message parameter has precedence over evaluating ${value} as message expression.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testConstraintAttributeValuesAreInterpolated()
MessageInterpolationTest.testParameterInterpolationHasPrecedenceOverExpressionEvaluation()
g)

Message expressions are extracted from the message string and evaluated using Expression Language. See also 5.3.1.3.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testElExpressionsAreInterpolated()

Section 5.3.1.2 - Locale for default message interpolation

a)

If the locale is passed explicitly to the interpolator method via interpolate(String, Context, Locale), this provided instance is used.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testMessageInterpolationWithLocale()
b)

Otherwise, the default Locale as provided by Locale.getDefault() is used.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testIfNoLocaleIsSpecifiedTheDefaultLocaleIsAssumed()

Section 5.3.1.3 - Message expressions using Expression Language (EL)

a)

The default message interpolation allows the use of Expression Language (EL) as defined in JSR 341.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationWithElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithSeveralElExpressions()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithUnknownElExpression()
ExpressionLanguageMessageInterpolationTest.testOnlyDollarSignIsSupportedForEnclosingElExpressions()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingAnnotationAttributesInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingGroupsAndPayloadInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingValidatedValueInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingFormatterInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingFormatterWithSeveralObjectsInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithFormatterUsesDefaultLocaleInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithIncompleteElExpression()
b)

Expressions to be evaluated by EL need to be enclosed in ${} within the message descriptor

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationWithElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithSeveralElExpressions()
ExpressionLanguageMessageInterpolationTest.testOnlyDollarSignIsSupportedForEnclosingElExpressions()
c)

The attribute values of the constraint declaration mapped to their attribute name

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingAnnotationAttributesInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingGroupsAndPayloadInElExpression()
d)

The validated value mapped under the name validatedValue.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingValidatedValueInElExpression()
e)

A bean mapped to the name formatter exposing the vararg method format(String format, Object... args). This method must behave like java.util.Formatter.format(String format, Object... args). The locale used for formatting is defined by 5.3.1.2. The formatter bean allows to format property values, for example in the case of the validated value being 98.12345678, ${formatter.format('%1$.2f', validatedValue)} would format it to 98.12 (two digits after the decimal point, where the use of '.' vs ',' would be locale specific).

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingFormatterInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationUsingFormatterWithSeveralObjectsInElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithFormatterUsesDefaultLocaleInElExpression()
f)

If an exception occurs during message interpolation, e.g. due invalid expressions or references to an unknown property, the message expression stays unchanged.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
ExpressionLanguageMessageInterpolationTest.testInterpolationWithUnknownElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithInvalidElExpression()
ExpressionLanguageMessageInterpolationTest.testInterpolationWithElExpressionThrowingAnException()

Section 5.3.2 - Custom message interpolation

a)

messageTemplate is the value of the message attribute of the constraint declaration or provided to the ConstraintValidatorContext methods.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForPropertyConstraint()
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForClassLevelConstraint()
b)

getConstraintDescriptor() returns the ConstraintDescriptor object representing the metadata of the failing constraint (see 6).

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForPropertyConstraint()
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForClassLevelConstraint()
c)

getValidatedValue() returns the value being validated.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForPropertyConstraint()
MessageInterpolationTest.testCorrectValuesArePassedToInterpolateForClassLevelConstraint()
d)

A message interpolator implementation must be thread-safe.

e)

It is possible to override the MessageInterpolator implementation for a given Validator instance by invoking ValidatorFactory.usingContext().messageInterpolator(messageInterpolator).getValidator().

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()
CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaConfiguration()
f)

The default implementation is accessible through Configuration.getDefaultMessageInterpolator().

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testDefaultMessageInterpolatorIsNotNull()
MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()
g)

If the interpolation process leads to an exception, the exception is wrapped into a ValidationException.

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testExceptionDuringMessageInterpolationIsWrappedIntoValidationException()

Section 5.4 - Triggering method validation

a)

The validation of method / constructor constraints comprises the following steps: Intercept the method call to be validated Validate the parameter values provided by the method caller using ExecutableValidator.validateParameters() or ExecutableValidator.validateConstructorParameters(). If this validation yields a non-empty set of constraint violations, throw a ConstraintViolationException wrapping the violations. Otherwise proceed with the actual method invocation. Validate the result returned by the invoked method using ExecutableValidator.validateReturnValue() or ExecutableValidator.validateConstructorReturnValue(). If this validation yields a non-empty set of constraint violations, throw a ConstraintViolationException wrapping the violations. Otherwise return the invocation result to the method caller.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testMethodValidationInvokesParameterAndReturnValueValidationUsingDefaultGroup()
ExecutableValidationTest.testConstructorValidationInvokesParameterAndReturnValueValidationUsingDefaultGroup()
b)

The Default group is used for validation out of the box.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testMethodValidationInvokesParameterAndReturnValueValidationUsingDefaultGroup()
ExecutableValidationTest.testConstructorValidationInvokesParameterAndReturnValueValidationUsingDefaultGroup()

Section 5.5 - Bootstrapping

a)

A bootstrap implementation must be able to bootstrap any Bean Validation provider implementation.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapCustomProviderDefinedInValidationXmlTest.testGetFactoryByProviderSpecifiedInValidationXml()
BootstrapCustomProviderDefinedInServiceFileTest.testGetFactoryByProviderSpecifiedProgrammatically()

Section 5.5.1 - Examples

a)

The ValidatorFactory object is thread-safe.

Section 5.5.2 - ValidatorFactory

a)

ValidatorFactory implementations must be thread-safe.

b)

getMessageInterpolator() returns the MessageInterpolator instance configured during the initialization of the ValidatorFactory.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()
c)

getTraversableResolver() returns the TraversableResolver instance configured during the initialization of the ValidatorFactory.

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testTraversableResolverFromValidatorFactory()
d)

getConstraintValidatorFactory() returns the ConstraintValidatorFactory instance configured during the initialization of the ValidatorFactory.

Coverage

org.hibernate.beanvalidation.tck.tests.validatorfactory
CustomConstraintValidatorTest.testGetConstraintValidatorFactoryFromValidatorFactory()
e)

getParameterNameProvider() returns the ParameterNameProvider instance configured during the initialization of the ValidatorFactory.

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation.parameternameprovider
ParameterNameProviderTest.testGetParameterNameProviderFromValidatorFactory()
g)

The MessageInterpolator, the TraversableResolver, the ConstraintValidatorFactory or the ParameterNameProvider passed to the ValidatorContext are used instead of the ValidatorFactory's MessageInterpolator, TraversableResolver, ConstraintValidatorFactory or ParameterNameProvider instances.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()
org.hibernate.beanvalidation.tck.tests.methodvalidation.parameternameprovider
ParameterNameProviderTest.testParameterNameProviderSetUsingContext()

Section 5.5.3 - Configuration

a)

Configuration does provide a MessageInterpolator implementation following the default Bean Validation MessageInterpolator rules as defined in 5.3.1. You can access it by calling getDefaultMessageInterpolator().

Coverage

org.hibernate.beanvalidation.tck.tests.messageinterpolation
MessageInterpolationTest.testDefaultMessageInterpolatorIsNotNull()
MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()
b)

Configuration does provide a TraversableResolver implementation following the default Bean Validation TraversableResolver rules as defined in 4.6.3. You can access it by calling getDefaultTraversableResolver().

Coverage

org.hibernate.beanvalidation.tck.tests.traversableresolver
TraversableResolverTest.testDefaultTraversableResolverIsNotNull()
c)

Configuration does provide a ConstraintValidatorFactory implementation following the default Bean Validation ConstraintValidatorFactory rules as defined in 3.5. You can access it by calling getDefaultConstraintValidatorFactory().

Coverage

org.hibernate.beanvalidation.tck.tests.validatorfactory
DefaultConstraintValidatorFactoryTest.testDefaultConstructorInValidatorCalled()
DefaultConstraintValidatorFactoryTest.testRuntimeExceptionInValidatorCreationIsWrapped()
d)

Configuration does provide a ParameterNameProvider implementation following the default Bean Validation ParameterNameProvider rules as defined in 4.5.2.2. You can access it by calling getDefaultParameterNameProvider().

Coverage

org.hibernate.beanvalidation.tck.tests.methodvalidation.parameternameprovider
DefaultParameterNameProviderTest.testGetDefaultParameterNameProviderFromConfiguration()
f)

Via getBootstrapConfiguration(), Configuration also exposes data stored in META-INF/validation.xml

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
BootstrapConfigurationWithValidatedExecutableTypesContainingNONETest.testGetDefaultValidatedExecutableTypesReturnsEmptySetIfNONEIsContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingALLAndNONETest.testGetDefaultValidatedExecutableTypesReturnsSetWithAllOptionsIfALLAndNONEAreContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingALLTest.testGetDefaultValidatedExecutableTypesReturnsSetWithAllOptionsIfALLIsContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingSomeTest.testGetDefaultValidatedExecutableTypesReturnsSetWithConfiguredValues()
BootstrapConfigurationWithoutValidationXmlTest.testGetBootstrapConfigurationNoValidationXml()
BootstrapConfigurationTest.testGetBootstrapConfiguration()
BootstrapConfigurationWithEmptyValidatedExecutableTypesTest.testEmptyExecutableTypesCauseValidationException()
g)

Using addMapping(), additional constraint mapping XML descriptors can be added to the configuration

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ConfigurationTest.testMappingsCanBeAddedViaConfiguration()
h)

Streams not supporting the mark() and reset() methods will be wrapped with an InputStream implementation supporting these methods by the Bean Validation provider in order to allow the streams to be read several times.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ConfigurationTest.testNonResettableInputStreamCanBeAddedViaConfigurationAndFactoryCanBeCreatedSeveralTimes()
i)

It is legal to invoke buildValidatorFactory() several times, e.g. in order to retrieval several ValidatorFactory instances with a slightly different configuration (see ).

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ConfigurationTest.testSeveralFactoriesCanBeBuildFromOneConfiguration()
j)

A Bean Validation provider must define a sub interface of Configuration uniquely identifying the provider.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ConfigurationTest.testProviderUnderTestDefinesSubInterfaceOfConfiguration()
k)

Streams represented in the XML configuration and opened by the Configuration implementation must be closed by the Configuration implementation after the ValidatorFactory creation (or if an exception occurs).

l)

The requested provider implementation is resolved according to the following rules in the following order: Use the provider implementation requested if Configuration has been created from Validation.byProvider(Class). Use the provider implementation described in the XML configuration (under validation-config.default-provider see 5.5.6) if defined: the value of this element is the fully qualified class name of the ValidationProvider implementation uniquely identifying the provider. Use the first provider implementation returned by validationProviderResolver.getValidationProviders().

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapCustomProviderDefinedInValidationXmlTest.testGetFactoryByProviderSpecifiedInValidationXml()
BootstrapCustomProviderDefinedInServiceFileTest.testGetFactoryByProviderSpecifiedProgrammatically()
BootstrapCustomProviderDefinedInServiceFileTest.testProviderResolverReturnsListOfAvailableProviders()
m)

If no ValidationProviderResolver instance has been specified, the default ValidationProviderResolver is used.

Section 5.5.4.1 - ValidationProviderResolver

a)

ValidationProviderResolver returns the list of Bean Validation providers available at runtime and more specifically a ValidationProvider instance for each provider available in the context.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapCustomProviderDefinedInServiceFileTest.testProviderResolverReturnsListOfAvailableProviders()
b)

Implementations must be thread-safe.

c)

Bean Validation providers must supply a service provider configuration file by creating a text file javax.validation.spi.ValidationProvider and placing it in the META-INF/services directory of one of its jar files.

Section 5.5.4.2 - ValidationProvider

a)

A client can request a specific Bean Validation provider by using <T extends Configuration<T>, U extends ValidationProvider<T>> Validation.byProvider(Class<U>) or by defining the provider in the XML configuration file.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapCustomProviderDefinedInValidationXmlTest.testGetFactoryByProviderSpecifiedInValidationXml()
BootstrapCustomProviderDefinedInServiceFileTest.testGetFactoryByProviderSpecifiedProgrammatically()
b)

The provider discovery mechanism uses the following algorithm: Retrieve available providers using ValidationProviderResolver.getValidationProviders(). The first ValidationProvider matching the requested provider is returned. Providers are evaluated in the order they are returned by ValidationProviderResolver. A provider instance is considered matching if it is assignable to the requested provider class.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ValidationProviderTest.testFirstMatchingValidationProviderResolverIsReturned()
c)

When the default Bean Validation provider is requested, the first ValidationProvider returned by the ValidationProviderResolver strategy is returned.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ValidationProviderTest.testByDefaultProviderUsesTheFirstProviderReturnedByValidationProviderResolver()
d)

Every Bean Validation provider must provide a ValidationProvider implementation containing a public no-arg constructor

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ValidationProviderTest.testValidationProviderContainsNoArgConstructor()
e)

If a problem occurs while building the ValidatorFactory, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
ValidationProviderTest.testValidationExceptionIsThrownInCaseValidatorFactoryCreationFails()

Section 5.5.5 - Validation

a)

The first entry point, buildDefaultValidatorFactory(), is considered to be the default ValidatorFactory and is equivalent to the ValidatorFactory returned by Validation.byDefaultProvider().configure().buildValidatorFactory().

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidationTest.testBuildDefaultValidatorFactory()
b)

The second entry point lets the client provide a custom ValidationProviderResolution instance. This instance is passed to GenericBootstrap. GenericBootstrap builds a generic Configuration using the first ValidationProvider returned by ValidationProviderResolution and calling ValidationProvider.createGenericConfiguration(BootstrapState state).

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidationTest.testCustomValidationProviderResolution()
c)

The last entry point lets the client define the specific Bean Validation provider requested as well as a custom ValidationProviderResolver implementation if needed. The entry point method, Validation.byProvider(Class<U> providerType), takes the provider specific ValidationProvider implementation type and returns a ProviderSpecificBootstrap object that guarantees to return an instance of the specific Configuration sub interface.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidationTest.testSpecificValidationProvider()
d)

The Validation implementation must not contain any non private attribute or method aside from the three public static bootstrap methods

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidationTest.testVerifyMethodsOfValidationObjects()
e)

The bootstrap implementation must ensure it can bootstrap third party providers.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidationTest.testCustomValidationProviderResolution()
ValidationTest.testSpecificValidationProvider()
f)

When bootstrapping a Bean Validation provider, if the ValidationProviderResolver either fails or if the expected provider is not found, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapNonAvailableValidationProviderTest.testUnknownProviderConfiguredInValidationXml()
BootstrapNonAvailableValidationProviderTest.testConfiguredValidationProviderIsNotLoadable()
org.hibernate.beanvalidation.tck.tests.bootstrap
ValidationProviderTest.testValidationExceptionIsThrownInCaseValidatorFactoryCreationFails()

Section 5.5.6 - XML configuration: META-INF/validation.xml

a)

Unless explicitly ignored by calling Configuration.ignoreXMLConfiguration(), a Configuration takes into account the configuration available in META-INF/validation.xml.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
b)

This configuration file is optional

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
OptionalValidationXmlTest.testIgnoreValidationXml()
c)

If more than one META-INF/validation.xml file is found in the classpath, a ValidationException is raised.

d)

Implementations supporting Bean Validation 1.1 must properly parse deployment descriptors of Bean Validation 1.0 and 1.1.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.versioning
Version10InValidationXmlTest.testValidationXmlVersion10()
Version11InValidationXmlTest.testValidationXmlVersion11()
e)

Unless stated otherwise, XML based configuration settings are overridden by values explicitly set via the Configuration API.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
TraversableResolverSpecifiedInValidationXmlTest.testTraversableResolverSpecifiedInValidationXmlCanBeOverridden()
MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()
f)

default-provider: represents the class name of the provider specific ValidationProvider implementation class. If defined, the specific provider is used

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DefaultProviderSpecifiedInValidationXmlTest.testProviderSpecifiedInValidationXml()
g)

message-interpolator: represents the fully qualified class name of the MessageInterpolator implementation. When defined in XML, the implementation must have a public no-arg constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
MessageInterpolatorSpecifiedInValidationXmlNoDefaultConstructorTest.testMessageInterpolatorSpecifiedInValidationXmlHasNoDefaultConstructor()
MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()
MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXml()
h)

traversable-resolver: represents the fully qualified class name of the TraversableResolver implementation. When defined in XML, the implementation must have a public no-arg constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXmlCanBeOverridden()
TraversableResolverSpecifiedInValidationXmlTest.testTraversableResolverSpecifiedInValidationXmlCanBeOverridden()
TraversableResolverSpecifiedInValidationXmlNoDefaultConstructorTest.testTraversableResolverSpecifiedInValidationXmlHasNoDefaultConstructor()
TraversableResolverSpecifiedInValidationXmlTest.testTraversableResolverSpecifiedInValidationXml()
i)

constraint-validator-factory: represents the fully qualified class name of the ConstraintValidatorFactory implementation. When defined in XML, the implementation must have a public no-arg constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXmlCanBeOverridden()
ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXml()
j)

parameter-name-provider: represents the fully qualified class name of the ParameterNameProvider implementation. When defined in XML, the implementation must have a public no-arg constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
ParameterNameProviderSpecifiedInValidationXmlTest.testParameterNameSpecifiedInValidationXml()
k)

executable-validation: allows to disable executable validation entirely via its attribute enabled="false" and optionally contains default-validated-executable-types. enabled defaults to true.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.global
ExecutableValidationBasedOnGlobalConfigurationTest.testValidationOfConstrainedMethodOnTypeAnnotatedWithValidateOnExecutionContainingExecutableType()
org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.globallydisabled
ExecutableValidationGloballyDisabledTest.testExecutableValidationGloballyTurnedOff()
l)

default-validated-executable-types: declared under executable-validation, contains the list of executable-type that are considered by default by the integration technology validating executables upon execution.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap
BootstrapConfigurationWithValidatedExecutableTypesContainingNONETest.testGetDefaultValidatedExecutableTypesReturnsEmptySetIfNONEIsContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingALLAndNONETest.testGetDefaultValidatedExecutableTypesReturnsSetWithAllOptionsIfALLAndNONEAreContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingALLTest.testGetDefaultValidatedExecutableTypesReturnsSetWithAllOptionsIfALLIsContained()
BootstrapConfigurationWithValidatedExecutableTypesContainingSomeTest.testGetDefaultValidatedExecutableTypesReturnsSetWithConfiguredValues()
m)

constraint-mapping: represents the resource path of an XML mapping file.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
n)

More than one constraint-mapping element can be present.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
o)

Mappings provided via Configuration.addMapping(InputStream) are added to the list of mappings described via constraint-mapping.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testMappingFilesAddedViaConfigurationGetAddedToXmlConfiguredMappings()
p)

The namespace javax.validation is reserved for use by this specification.

q)

Properties defined via Configuration.addProperty(String, String) are added to the properties defined via property.

r)

If a property with the same name are defined in both XML and via the programmatic API, the value provided via programmatic API has priority.

s)

All these top level elements are optional.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DefaultProviderSpecifiedInValidationXmlTest.testProviderSpecifiedInValidationXml()
t)

If a public no-arg constructor is missing on any of the classes referenced by the relevant XML elements, a ValidationException is raised during the Configuration.buildValidatorFactory() call.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
MessageInterpolatorSpecifiedInValidationXmlNoDefaultConstructorTest.testMessageInterpolatorSpecifiedInValidationXmlHasNoDefaultConstructor()
TraversableResolverSpecifiedInValidationXmlNoDefaultConstructorTest.testTraversableResolverSpecifiedInValidationXmlHasNoDefaultConstructor()

Section 5.5.7 - Bootstrapping considerations

a)

ValidatorFactory is a thread-safe object that should be built once per deployment unit

b)

Validator is a thread-safe and lightweight object which can be cached by the ValidatorFactory instance.

Section 6.1 - Validator

a)

getConstraintsForClass() returns a BeanDescriptor object describing the bean level constraints (see 4.1.1) and providing access to the property level constraints metadata.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testIsBeanConstrainedDueToValidAnnotation()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnEntity()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintProperty()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnInterface()
BeanDescriptorTest.testUnconstrainedClass()
BeanDescriptorTest.testGetConstraintsForConstrainedProperty()
BeanDescriptorTest.testGetConstraintsForNonExistingProperty()
BeanDescriptorTest.testGetConstrainedProperties()
BeanDescriptorTest.testGetConstrainedPropertiesForUnconstrainedEntity()
org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintDescriptorWithoutExplicitGroup()
b)

An IllegalArgumentException is raised if the clazz parameter is null.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testNullParameterToGetConstraintsForClass()
c)

If a constraint definition or declaration hosted by the requested class (or any of it's superclasses and interfaces according to the constraint propagation rules) is invalid, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testUnexpectedTypeException()

Section 6.2 - ElementDescriptor

a)

getElementClass() returns the object type when invoked on BeanDescriptor, the type of a property or parameter when invoked on PropertyDescriptor or ParameterDescriptor respectively, Object[].class when invoked on CrossParameterDescriptor, the return type when invoked on ConstructorDescriptor, MethodDescriptor or ReturnValueDescriptor.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testGetElementClass()
ReturnValueDescriptorTest.testGetElementClassForMethod()
ReturnValueDescriptorTest.testGetElementClassForVoidMethod()
ReturnValueDescriptorTest.testGetElementClassForConstructor()
BeanDescriptorTest.testGetElementClassReturnsBeanClass()
ParameterDescriptorTest.testGetElementClassForMethod()
ParameterDescriptorTest.testGetElementClassForConstructor()
ExecutableDescriptorTest.testGetElementClassForMethod()
ExecutableDescriptorTest.testGetElementClassForVoidMethod()
ExecutableDescriptorTest.testGetElementClassForConstructor()
ElementDescriptorTest.testGetElementClass()
PropertyDescriptorTest.testGetElementClass()
b)

getConstraintDescriptors() returns all the ConstraintDescriptors (see 6.11) hosted on the given element in the class hierarchy, each ConstraintDescriptor describing one of the constraints declared on the given element.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testGetConstraintsForMethod()
CrossParameterDescriptorTest.testGetConstraintsForMethodWithoutCrossParameterConstraints()
CrossParameterDescriptorTest.testGetConstraintsForConstructor()
CrossParameterDescriptorTest.testGetConstraintsForConstructorWithoutCrossParameterConstraints()
ElementDescriptorTest.testGetConstraintDescriptors()
c)

hasConstraints() returns true if the given element in the class hierarchy holds at least one constraint declaration.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testHasConstraintsForMethod()
CrossParameterDescriptorTest.testHasConstraintsForUnconstrainedMethod()
CrossParameterDescriptorTest.testHasConstraintsForConstructor()
CrossParameterDescriptorTest.testHasConstraintsForConstructorWithoutCrossParameterConstraints()
ElementDescriptorTest.testHasConstraints()
d)

If you need to query the metadata API in a more fine grained way for example by restricting the constraints to the one described on fields or on getters or by restricting to a given set of groups, you can use the ConstraintFinder fluent API by calling findConstraints().

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testFindConstraintsForMethod()
CrossParameterDescriptorTest.testFindConstraintsForMethodWithoutCrossParameterConstraints()
CrossParameterDescriptorTest.testFindConstraintsForConstructor()
CrossParameterDescriptorTest.testFindConstraintsForConstructorWithoutCrossParameterConstraints()
ExecutableDescriptorTest.testFindConstraintsForMethod()
ExecutableDescriptorTest.testFindConstraintsForMethodLookingAt()
ExecutableDescriptorTest.testFindConstraintsForMethodDefinedOnSuperTypeLookingAt()
ExecutableDescriptorTest.testFindConstraintsForConstructor()
ElementDescriptorTest.testUnorderedAndMatchingGroups()
ElementDescriptorTest.testUnorderedAndMatchingGroupsWithInheritance()
ElementDescriptorTest.testUnorderedAndMatchingGroupsWithDefaultGroupOverriding()
ElementDescriptorTest.testDeclaredOn()
ElementDescriptorTest.testLookingAt()
e)

unorderedAndMatchingGroups() restricts the results to the ConstraintDescriptors (see 6.11) matching the given groups. Order is not respected but group inheritance and inheritance via sequence (including the Default group overriding at the class level) are honored.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ElementDescriptorTest.testUnorderedAndMatchingGroups()
ElementDescriptorTest.testUnorderedAndMatchingGroupsWithInheritance()
ElementDescriptorTest.testUnorderedAndMatchingGroupsWithDefaultGroupOverriding()
f)

declaredOn() lets you restrict the list of element types constraints are hosted on.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ElementDescriptorTest.testDeclaredOn()
g)

lookingAt() lets you restrict which constraints are considered. Either constraints belonging to the element but hosted on the class represented by the given descriptor (Scope.LOCAL_ELEMENT), or constraints belonging to the element but hosted anywhere in the class hierarchy (Scope.HIERARCHY).

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testFindConstraintsForMethodLookingAt()
CrossParameterDescriptorTest.testFindConstraintsForMethodDefinedOnSuperTypeLookingAt()
ExecutableDescriptorTest.testFindConstraintsForMethodLookingAt()
ExecutableDescriptorTest.testFindConstraintsForMethodDefinedOnSuperTypeLookingAt()
ElementDescriptorTest.testLookingAt()

Section 6.3 - BeanDescriptor

a)

isBeanConstrained() returns true if the given class (and superclasses and interfaces) has at least one class-level or property-level constraint or validation cascade.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testIsBeanConstrainedDueToValidAnnotation()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnEntity()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintProperty()
BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnInterface()
BeanDescriptorTest.testUnconstrainedClass()
b)

getConstraintsForProperty() returns a PropertyDescriptor object describing the property level constraints (See 4.1.2). The property is uniquely identified by its name as per the JavaBeans convention: field level and getter level constraints of the given name are all returned.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstraintsForConstrainedProperty()
BeanDescriptorTest.testGetConstraintsForUnConstrainedProperty()
BeanDescriptorTest.testGetConstraintsForNonExistingProperty()
c)

An IllegalArgumentException is raised if the propertyName parameter is null.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstraintsForNullProperty()
d)

getConstrainedProperties() returns the PropertyDescriptors of the bean properties having at least one constraint or being cascaded (@Valid annotation).

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstrainedProperties()
BeanDescriptorTest.testGetConstrainedPropertiesForUnconstrainedEntity()
e)

getConstraintsForMethod() returns a MethodDescriptor object describing the method constraints of the given method. The method is uniquely identified by its name and the types of its parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstraintsForParameterConstrainedMethod()
BeanDescriptorTest.testGetConstraintsForCrossParameterConstrainedMethod()
BeanDescriptorTest.testGetConstraintsForCascadedParameterMethod()
BeanDescriptorTest.testGetConstraintsForReturnValueConstrainedMethod()
BeanDescriptorTest.testGetConstraintsForCascadedReturnValueMethod()
BeanDescriptorTest.testGetConstraintsForUnconstrainedMethod()
BeanDescriptorTest.testGetConstraintsForNonExistingMethod()
BeanDescriptorTest.testGetConstraintsForNullMethod()
f)

getConstrainedMethods() returns the MethodDescriptors of the methods matching the MethodTypes provided as parameter and having at least one constraint or cascaded parameter or return value.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstrainedMethodsTypeNON_GETTER()
BeanDescriptorTest.testGetConstrainedMethodsTypeGETTER()
BeanDescriptorTest.testGetConstrainedMethodsTypesGETTERAndNON_GETTER()
BeanDescriptorTest.testGetConstrainedMethodsForUnconstrainedEntity()
g)

getConstraintsForConstructor() returns a ConstructorDescriptor object describing the method constraints of the given constructor. The constructor is uniquely identified by its name and the types of its parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstraintsForParameterConstrainedConstructor()
BeanDescriptorTest.testGetConstraintsForCrossParameterConstrainedConstructor()
BeanDescriptorTest.testGetConstraintsForCascadedParameterConstructor()
BeanDescriptorTest.testGetConstraintsForReturnValueConstrainedConstructor()
BeanDescriptorTest.testGetConstraintsForCascadedReturnValueConstructor()
BeanDescriptorTest.testGetConstraintsForUnconstrainedConstructor()
BeanDescriptorTest.testGetConstraintsForNonExistingConstructorConstructor()
h)

getConstrainedConstructors() returns the ConstructorDescriptors of the constructors having at least one constraint or cascaded parameter or return value.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstrainedConstructors()
BeanDescriptorTest.testGetConstrainedConstructorsForUnconstrainedEntity()

Section 6.4 - CascadableDescriptor

a)

The isCascaded() method returns true if the element is marked for cascaded validation.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
BeanDescriptorTest.testGetConstraintsForUnConstrainedProperty()
ReturnValueDescriptorTest.testIsCascadedForMethodReturnValue()
ReturnValueDescriptorTest.testIsCascadedForConstructorReturnValue()
ReturnValueDescriptorTest.testIsCascadedForVoidMethod()
ParameterDescriptorTest.testIsCascadedForMethod()
ParameterDescriptorTest.testIsCascadedForConstructor()
PropertyDescriptorTest.testIsNotCascaded()
PropertyDescriptorTest.testIsCascaded()
b)

The method getGroupConversions() returns a set with the group conversions declared for the cascadable element. An empty set will be returned if no group conversions are configured.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ReturnValueDescriptorTest.testGetGroupConversionsForConstructorReturnValue()
ReturnValueDescriptorTest.testGetGroupConversionsForVoidMethod()
ReturnValueDescriptorTest.testGetGroupConversionsForMethodReturnValue()
ParameterDescriptorTest.testGetGroupConversionsForConstructorParameter()
ParameterDescriptorTest.testGetGroupConversionsForMethodParameter()
PropertyDescriptorTest.testGetGroupConversionsForField()
PropertyDescriptorTest.testGetGroupConversionsForProperty()
ReturnValueDescriptorTest.testGetGroupConversionsReturnsEmptySetForConstructorReturnValue()
ReturnValueDescriptorTest.testGetGroupConversionsReturnsEmptySetForMethodReturnValue()
ParameterDescriptorTest.testGetGroupConversionsReturnsEmptySetForConstructorParameter()
ParameterDescriptorTest.testGetGroupConversionsReturnsEmptySetForMethodParameter()
PropertyDescriptorTest.testGetGroupConversionsReturnsEmptySet()

Section 6.5 - GroupConversionDescriptor

a)

The getFrom() method returns the source of a group conversion rule.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ReturnValueDescriptorTest.testGetGroupConversionsForConstructorReturnValue()
ReturnValueDescriptorTest.testGetGroupConversionsForVoidMethod()
ReturnValueDescriptorTest.testGetGroupConversionsForMethodReturnValue()
ParameterDescriptorTest.testGetGroupConversionsForConstructorParameter()
ParameterDescriptorTest.testGetGroupConversionsForMethodParameter()
PropertyDescriptorTest.testGetGroupConversionsForField()
PropertyDescriptorTest.testGetGroupConversionsForProperty()
b)

The getTo() method returns the target of a group conversion rule.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ReturnValueDescriptorTest.testGetGroupConversionsForConstructorReturnValue()
ReturnValueDescriptorTest.testGetGroupConversionsForVoidMethod()
ReturnValueDescriptorTest.testGetGroupConversionsForMethodReturnValue()
ParameterDescriptorTest.testGetGroupConversionsForConstructorParameter()
ParameterDescriptorTest.testGetGroupConversionsForMethodParameter()
PropertyDescriptorTest.testGetGroupConversionsForField()
PropertyDescriptorTest.testGetGroupConversionsForProperty()

Section 6.6 - PropertyDescriptor

a)

getPropertyName() returns the property name as described in 5.2.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
PropertyDescriptorTest.testPropertyName()

Section 6.7 - ExecutableDescriptor, MethodDescriptor and ConstructorDescriptor

a)

getName() returns the name of the represented method (e.g. "placeOrder") respectively the non-qualified name of the declaring class of the represented constructor (e.g. "OrderService").

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testGetNameForMethod()
ExecutableDescriptorTest.testGetNameForConstructor()
b)

getParameterDescriptors() returns a list of ParameterDescriptors representing the method's or constructor's parameters in order of their declaration, including synthetic parameters. An empty list will be returned in case the method or constructor has no parameters.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testGetParameterDescriptorsForMethod()
ExecutableDescriptorTest.testGetParameterDescriptorsForParameterlessMethod()
ExecutableDescriptorTest.testGetParameterDescriptorsForConstructor()
ExecutableDescriptorTest.testGetParameterDescriptorsForConstructorOfInnerClass()
ExecutableDescriptorTest.testGetParameterDescriptorsForParameterlessConstructor()
c)

getCrossParameterDescriptor() returns a descriptor containing cross-parameter constraints of the method or constructor. If no cross-parameter constraint is present, the descriptor will return an empty set of constraint descriptors.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testGetConstraintsForMethod()
CrossParameterDescriptorTest.testGetConstraintsForMethodWithoutCrossParameterConstraints()
CrossParameterDescriptorTest.testGetConstraintsForConstructor()
CrossParameterDescriptorTest.testGetConstraintsForConstructorWithoutCrossParameterConstraints()
CrossParameterDescriptorTest.testFindConstraintsForMethod()
CrossParameterDescriptorTest.testFindConstraintsForMethodLookingAt()
CrossParameterDescriptorTest.testFindConstraintsForMethodDefinedOnSuperTypeLookingAt()
CrossParameterDescriptorTest.testFindConstraintsForMethodWithoutCrossParameterConstraints()
CrossParameterDescriptorTest.testFindConstraintsForConstructor()
CrossParameterDescriptorTest.testFindConstraintsForConstructorWithoutCrossParameterConstraints()
ExecutableDescriptorTest.testGetCrossParameterDescriptorForMethod()
ExecutableDescriptorTest.testGetCrossParameterDescriptorForMethodWithoutCrossParameterConstraints()
ExecutableDescriptorTest.testGetCrossParameterDescriptorForConstructor()
ExecutableDescriptorTest.testGetCrossParameterDescriptorForConstructorWithoutCrossParameterConstraints()
d)

getReturnValueDescriptor() returns a descriptor for the method's or constructor's return value. A descriptor representing the special class void, without any constraint descriptors, will be returned for executables which have no return value.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testGetReturnValueDescriptorForMethod()
ExecutableDescriptorTest.testGetUnconstrainedReturnValueDescriptorForMethod()
ExecutableDescriptorTest.testReturnValueDescriptorForVoidMethod()
ExecutableDescriptorTest.testGetReturnValueDescriptorForConstructor()
ExecutableDescriptorTest.testGetUnconstrainedReturnValueDescriptorForConstructor()
e)

hasConstrainedParameters() returns true if any of the parameters is constrained or cascaded or if the represented executable has at least one cross-parameter constraint. Returns false if there is no parameter.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testAreParametersConstrainedForConstrainedMethod()
ExecutableDescriptorTest.testAreParametersConstrainedForCascadedMethod()
ExecutableDescriptorTest.testAreParametersConstrainedForCrossParameterConstrainedMethod()
ExecutableDescriptorTest.testAreParametersConstrainedForNotConstrainedMethod()
ExecutableDescriptorTest.testAreParametersConstrainedForParameterlessMethod()
ExecutableDescriptorTest.testAreParametersConstrainedForConstrainedConstructor()
ExecutableDescriptorTest.testAreParametersConstrainedForCascadedConstructor()
ExecutableDescriptorTest.testAreParametersConstrainedForCrossParameterConstrainedConstructor()
ExecutableDescriptorTest.testAreParametersConstrainedForNotConstrainedConstructor()
ExecutableDescriptorTest.testAreParametersConstrainedForParameterlessConstructor()
f)

hasConstrainedReturnValue() returns true if the return value is constrained or cascaded. Returns false if there is no return value.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testIsReturnValueConstrainedForConstrainedMethod()
ExecutableDescriptorTest.testIsReturnValueConstrainedForCascadedMethod()
ExecutableDescriptorTest.testIsReturnValueConstrainedForNotConstrainedMethod()
ExecutableDescriptorTest.testIsReturnValueConstrainedForVoidMethod()
ExecutableDescriptorTest.testIsReturnValueConstrainedForConstrainedConstructor()
ExecutableDescriptorTest.testIsReturnValueConstrainedForCascadedConstructor()
ExecutableDescriptorTest.testIsReturnValueConstrainedForNotConstrainedConstructor()
g)

The methods hasConstraints(), getConstraintDescriptors() and findConstraints() defined on ElementDescriptor are redefined to clarify that executables do not host constraints directly and thus will always return false or an empty set of constraints, respectively. Constraint descriptors for individual parameters can be obtained from the corresponding ParameterDescriptor object, constraint descriptors for cross-parameter constraints can be obtained from the corresponding CrossParameterDescriptor object and constraint descriptors for the return value can be obtained from ReturnValueDescriptor.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorTest.testFindConstraintsForMethod()
ExecutableDescriptorTest.testFindConstraintsForMethodLookingAt()
ExecutableDescriptorTest.testFindConstraintsForMethodDefinedOnSuperTypeLookingAt()
ExecutableDescriptorTest.testFindConstraintsForConstructor()
ExecutableDescriptorTest.testHasConstraintsForMethod()
ExecutableDescriptorTest.testHasConstraintsForConstructor()
ExecutableDescriptorTest.testGetConstraintsForMethod()
ExecutableDescriptorTest.testGetConstraintsForConstructor()
h)

None of the metadata API methods honor the XML configuration around executable validation nor the presence of @ValidateOnExecution. In other words, all constrained methods and constructors will be returned by the metadata API regardless of these settings.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ExecutableDescriptorIgnoresValidatedExecutableXmlSettingsTest.testMethodDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEInXml()
ExecutableDescriptorIgnoresValidatedExecutableXmlSettingsTest.testConstructorDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEInXml()
ExecutableDescriptorIgnoresValidatedExecutableAnnotationSettingsTest.testMethodDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableDescriptorIgnoresValidatedExecutableAnnotationSettingsTest.testConstructorDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEOnTypeLevel()
ExecutableDescriptorIgnoresValidatedExecutableAnnotationSettingsTest.testMethodDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEOnMethodLevel()
ExecutableDescriptorIgnoresValidatedExecutableAnnotationSettingsTest.testConstructorDescriptorCanBeRetrievedAlsoIfValidateExecutableIsSetToNONEOnConstructorLevel()

Section 6.8 - ParameterDescriptor

a)

getIndex() returns the index of the represented parameter within the parameter array of the method or constructor holding it.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ParameterDescriptorTest.testGetIndexForMethod()
ParameterDescriptorTest.testGetIndexForConstructor()
b)

getName() returns the name of the represented parameter.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ParameterDescriptorTest.testGetNameForMethod()
ParameterDescriptorTest.testGetNameForConstructor()

Section 6.9 - CrossParameterDescriptor

a)

getElementClass() returns Object[].

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testGetElementClass()

Section 6.11 - ConstraintDescriptor

a)

getAnnotation() returns the annotation instance (or an annotation instance representing the given constraint declaration).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testConstraintOnConstructorReturnValueAndParameter()
org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testConstraintOnMethodReturnValueAndParameter()
org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
PropertyLevelOverridingTest.testIncludeAnnotations()
org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
FieldLevelOverridingTest.testIncludeAnnotations()
org.hibernate.beanvalidation.tck.tests.validation
ValidateTest.testConstraintViolation()
org.hibernate.beanvalidation.tck.tests.metadata
CrossParameterDescriptorTest.testGetConstraintsForMethod()
ConstraintDescriptorTest.testAnnotationAndMapParametersReflectParameterOverriding()
b)

If ConstraintDescriptor represents a composing annotation (see 3.3), the returned annotation must reflect parameter overriding.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testAnnotationAndMapParametersReflectParameterOverriding()
c)

getAttributes() returns a map containing the annotation attribute names as a key, and the annotation attribute values as a value

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testGetAttributesFromConstraintDescriptor()
d)

If ConstraintDescriptor() represents a composing annotation (see 3.3), the returned Map must reflect attribute overriding.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testAnnotationAndMapParametersReflectParameterOverriding()
e)

getMessageTemplate() returns the non-interpolated error message.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testGetMessageTemplate()
f)

getGroups() returns the groups the constraint is supposed to be applied upon.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testGetGroups()
ConstraintDescriptorTest.testGetGroupsOnInterface()
ConstraintDescriptorTest.testGetGroupsWithImplicitGroup()
g)

If no group is set on the constraint declaration, the Default group is returned.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testDefaultGroupIsReturnedIfNoGroupSpecifiedInDeclaration()
h)

The groups of a composing constraint are the groups of the composed constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testComposingConstraints()
i)

getPayload() returns the payloads associated to the constraint or an empty set if none.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testPayload()
j)

The payload from the main constraint annotation is inherited by the composing annotations.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testComposingConstraintsPayload()
k)

Any payload definition on a composing annotation is ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testComposingConstraintsPayload()
l)

getValidationAppliesTo() returns the ConstraintTarget returned by validationAppliesTo if the constraint hosts the attribute or null otherwise. The constraint target from the main constraint annotation is inherited by the composing annotation. Any constraint target definition on a composing annotation is ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testGetValidationAppliesTo()
ConstraintDescriptorTest.testGetValidationAppliesToFromComposingConstraint()
ConstraintDescriptorTest.testGetValidationAppliesToReturnsNull()
m)

isReportAsSingleViolation() returns true if the constraint is annotated with @ReportAsSingleViolation.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testReportAsSingleViolation()
n)

getComposingConstraints() return a set of composing ConstraintDescriptors where each descriptor describes a composing constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.metadata
ConstraintDescriptorTest.testComposingConstraints()
ConstraintDescriptorTest.testEmptyComposingConstraints()
o)

getConstraintValidatorClasses() returns the ConstraintValidator classes associated with the constraint.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdefinition
XmlConfiguredConstraintValidatorTest.testExcludeExistingValidators()
XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()

Section 7 - Built-in Constraint definitions

a)

Each Bean Validation provider must recognize built-in constraint annotations as valid constraint definitions and provide compliant constraint implementations for each.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testNullConstraint()
BuiltinConstraintsTest.testNotNullConstraint()
BuiltinConstraintsTest.testAssertTrueConstraint()
BuiltinConstraintsTest.testAssertFalseConstraint()
BuiltinConstraintsTest.testMinConstraint()
BuiltinConstraintsTest.testMaxConstraint()
BuiltinConstraintsTest.testDecimalMinConstraint()
BuiltinConstraintsTest.testDecimalMaxConstraint()
BuiltinConstraintsTest.testSizeConstraint()
BuiltinConstraintsTest.testDigitsConstraint()
BuiltinConstraintsTest.testPastConstraint()
BuiltinConstraintsTest.testFutureConstraint()
BuiltinConstraintsTest.testPatternConstraint()
b)

The built-in constraint validation implementation is having a lower priority than an XML mapping definition.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinValidatorOverrideTest.testXmlConfiguredValidatorConfigurationHasPrecedence()
c)

@Null constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testNullConstraint()
d)

@NotNull constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testNotNullConstraint()
e)

@AssertTrue constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testAssertTrueConstraint()
f)

@AssertFalse constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testAssertFalseConstraint()
g)

@Min constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testMinConstraint()
h)

@Max constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testMaxConstraint()
i)

@DecimalMin constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testDecimalMinConstraint()
j)

@DecimalMax constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testDecimalMaxConstraint()
k)

@Size constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testSizeConstraint()
l)

@Digits constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testDigitsConstraint()
m)

@Past constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testPastConstraint()
n)

@Future constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testFutureConstraint()
o)

@Pattern constraint

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.builtinconstraints
BuiltinConstraintsTest.testPatternConstraint()

Section 8 - XML deployment descriptor

a)

If an XML descriptor does not validate against the corresponding XSD file, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
InvalidXmlConfigurationTest.testInvalidValidationXml()

Section 8.1 - Constraint definition and declaration

a)

Specifically when exploring metadata, the Bean Validation provider must ensure that an annotation instance corresponding to the XML declaration is provided via ConstraintDescriptor.getAnnnotation().

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DuplicateConfigurationTest.testXmlConfiguredConstraintExposesCorrespondingAnnotationViaMetadata()
b)

A given class must not be described more than once amongst all the XML mapping descriptors.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DuplicateConfigurationTest.testBeanCannotBeDescribedMoreThanOnce()
c)

A given field or getter must not be described more than once on a given class description.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DuplicateConfigurationTest.testFieldMappingCannotOccurMoreThanOnce()
d)

A given constraint definition must not be overridden more than once amongst all the XML mapping descriptors.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DuplicateConfigurationTest.testGetterMappingCannotOccurMoreThanOnce()
e)

If any of these rule is violated in a given validation deployment, a ValidationException is raised during the creation of the ValidatorFactory.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
DuplicateConfigurationTest.testBeanCannotBeDescribedMoreThanOnce()
DuplicateConfigurationTest.testFieldMappingCannotOccurMoreThanOnce()
DuplicateConfigurationTest.testGetterMappingCannotOccurMoreThanOnce()

Section 8.1.1 - Constraint declaration in XML

a)

If default-package is set, all unqualified class names (including annotations) are considered part of the package described by default-package.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
ConfigurationViaXmlAndAnnotationsTest.testEntityConfiguredViaAnnotationsAndXml()
b)

A given JavaBean is described by the bean element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
c)

The name of the class is mandatory.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
MissingClassNameOnBeanNodeTest.testClassNameIsMandatory()
d)

By default, all constraint declarations expressed via annotation are ignored for classes described in XML.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
ConstraintDeclarationTest.testConstraintAnnotationsArePerDefaultIgnoredForXmlConfiguredEntities()
e)

You can force Bean Validation to consider both annotations and XML constraint declarations by using ignore-annotations="false" on bean.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
ConfigurationViaXmlAndAnnotationsTest.testEntityConfiguredViaAnnotationsAndXml()
f)

If the name of the class does refer to a class not present in the classpath, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
ConfiguredBeanNotInClassPathTest.testExceptionIsThrownForUnknownBeanNameInXml()

Section 8.1.1.1 - Class-level overriding

a)

If ignore-annotations is declared, Bean Validation must honor the explicit value for this element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel
ClassLevelOverridingTest.testIgnoreClassLevelAnnotations()
ClassLevelOverridingTest.testClassLevelAnnotationsApplied()
b)

If not declared, the default value defined in the encapsulating bean element is considered.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel
ClassLevelOverridingTest.testIgnoreAnnotationsFromEnclosingBeanIsApplied()
c)

When ignore-annotations is true, class-level Bean Validation annotations are ignored for this class (including the @GroupSequence).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel
ClassLevelOverridingTest.testIgnoreClassLevelAnnotations()
d)

Constraints declared in XML and constraints declared in annotations are added and form the list of class-level declared constraints.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel
ClassLevelOverridingTest.testClassLevelAnnotationsApplied()
e)

@GroupSequence is considered unless group-sequence element is explicitly used.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
DefaultSequenceDefinedInXmlTest.testDefaultGroupDefinitionDefinedInEntityApplies()
ConfigurationViaXmlAndAnnotationsTest.testDefaultGroupDefinitionDefinedInEntityApplies()

Section 8.1.1.2 - Field-level overriding

a)

If ignore-annotations is declared, Bean Validation must honor the explicit value for this element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
FieldLevelOverridingTest.testIgnoreAnnotations()
FieldLevelOverridingTest.testIncludeAnnotations()
b)

If not declared, the default value defined in the encapsulating bean element is considered.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
IncludeFieldLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()
ExcludeFieldLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()
c)

When ignore-annotations is true, field-level Bean Validation annotations on the targeted field are ignored (including @Valid and @ConvertGroup).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
ExcludeFieldLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()
FieldLevelOverridingTest.testIgnoreAnnotations()
d)

Constraints declared in XML and constraints declared in annotations are added and form the list of field-level declared constraints.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
IncludeFieldLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()
FieldLevelOverridingTest.testIncludeAnnotations()
e)

@Valid is considered unless the valid element is explicitly used.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
FieldLevelOverridingTest.testCascadedConfiguration()
f)

Group conversions declared in XML and via the @ConvertGroup annotation are added and form the list of applied conversions. Note that the rules for the declaration of group conversions as outlined in 4.4.5 apply, in particular it is not legal to declare several conversions for the same source group.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
InvalidGroupConversionInFieldLevelOverridingTest.testGroupConversionsAreAdditiveAndExceptionIsThrownForMultipleConversionWithSameSource()
FieldLevelOverridingTest.testGroupConversionsAreAdditive()
h)

If the name of the field does not correspond to a field in the given bean a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel
WrongFieldNameTest.testWrongFieldNameThrowsException()

Section 8.1.1.3 - Property-level overriding

a)

The name attribute corresponds to the name of the property considered as defined in 4.1.2 (for example a getter String getAge() would have <getter name="age"/> as a corresponding descriptor). If ignore-annotations is declared, Bean Validation must honor the explicit value for this element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
PropertyLevelOverridingTest.testIgnoreAnnotations()
PropertyLevelOverridingTest.testIncludeAnnotations()
b)

If not declared, the default value defined in the encapsulating bean element is considered.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
IncludePropertyLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()
ExcludePropertyLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()
c)

When ignore-annotations is true, property-level Bean Validation annotations on the targeted property are ignored (including @Valid and @ConvertGroup).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
ExcludePropertyLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()
PropertyLevelOverridingTest.testIgnoreAnnotations()
d)

Constraints declared in XML and constraints declared in annotations are added and form the list of property-level declared constraints.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
IncludePropertyLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()
PropertyLevelOverridingTest.testIncludeAnnotations()
e)

@Valid is considered unless the valid element is explicitly used.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
PropertyLevelOverridingTest.testCascadedConfiguration()
f)

Group conversions declared in XML and via the @ConvertGroup annotation are added and form the list of applied conversions. Note that the rules for the declaration of group conversions as outlined in 4.4.5 apply, in particular it is not legal to declare several conversions for the same source group.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
InvalidGroupConversionInPropertyLevelOverridingTest.testGroupConversionsAreAdditiveAndExceptionIsThrownForMultipleConversionWithSameSource()
PropertyLevelOverridingTest.testGroupConversionsAreAdditive()
h)

If the name of the property does not correspond to a property in the given bean a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel
WrongPropertyNameTest.testWrongPropertyNameThrowsException()

Section 8.1.1.4 - Constructor-level overriding

a)

To identify a constructor to be configured, zero or more parameter elements are used, matching the number and types of parameters of the configured constructor. When configuring the default constructor, no parameter element is to be used. The parameter types are specified using their fully qualified name using the syntax described in the documentation of java.lang.Class.getName().

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testXmlConfiguredConstructors()
ConstructorValidationTest.testVarargsConstructorParameter()
b)

Varargs parameters are specified using the corresponding array type, e.g. a parameter String... must be specified as "[Ljava.lang.String;".

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testVarargsConstructorParameter()
c)

If the default-package element is configured for the mapping file, any unqualified class names will be resolved using the given default package.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testXmlConfiguredConstructors()
ConstructorValidationTest.testVarargsConstructorParameter()
ConstructorValidationTest.testConstructorCrossParameterConstraint()
d)

If no constructor with the specified parameter types exists in the given bean a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
UnknownConstructorValidationTest.testUnknownConstructorThrowsException()
e)

The optional return-value element is used to change the configuration of a constructor's return value if required.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testXmlConfiguredConstructors()
f)

The optional cross-parameter element is used to change the configuration of a constructor's cross-parameter constraints if required.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testConstructorCrossParameterConstraint()
g)

The constraints applying for a constructor's parameters and its return value are specified by adding constraint elements to the parameter and return-value elements respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testConstraintOnConstructorReturnValueAndParameter()
h)

Whether or not to perform cascaded validation is controlled using the valid element

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testCascadingOnReturnValueAndParameter()
i)

Group conversion rules for cascaded validation are specified using the convert-group element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testGroupConversionOnReturnValueAndParameter()
j)

The cross-parameter constraints applied on a constructor parameter list are specified by adding constraint elements to the cross-parameter element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
ConstructorValidationTest.testConstructorCrossParameterConstraint()
k)

If ignore-annotations is declared on the parameter, cross-parameter element or return value level, Bean Validation must honor the explicit value for this element. Otherwise, if ignore-annotations is declared for the constructor element, Bean Validation must honor this value. Otherwise, the default value declared in the encapsulating bean element is considered.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
IgnoreAnnotationsOnConstructorTest.testIgnoreAnnotationsOnConstructorLevel()
IgnoreAnnotationsInConstructorConfigurationTest.testIgnoreAnnotationsOnReturnValueParameterAndCrossParameter()
l)

When ignore-annotations is true, Bean Validation annotations on the targeted constructor or parameter are ignored (including @Valid and @ConvertGroup).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
IgnoreAnnotationsOnConstructorTest.testIgnoreAnnotationsOnConstructorLevel()
m)

Constraints declared in XML and constraints declared in annotations are added and form the list of declared parameter, cross-parameter or return value constraints respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
IgnoreAnnotationsOnConstructorTest.testIgnoreAnnotationsOnConstructorLevel()
n)

@Valid is considered unless the valid element is explicitly used.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
CascadedValidationTest.testValidaAnnotationIsApplied()
DisabledCascadedValidationTest.testValidAnnotationIsIgnored()
o)

Group conversions declared in XML and via the @ConvertGroup annotation are added and form the list of applied conversions. Note that the rules for the declaration of group conversions as outlined in 4.4.5 apply, in particular it is not legal to declare several conversions for the same source group. This does not apply to cross-parameter elements as cascading does not make sense in this situation.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constructorvalidation
IgnoreAnnotationsOnConstructorTest.testIgnoreAnnotationsOnConstructorLevel()

Section 8.1.1.5 - Method-level overriding

a)

To identify a method to be configured, zero or more parameter elements are used, matching the number and types of parameters of the configured method. The parameter types are specified using their fully qualified name using the syntax described in the documentation of java.lang.Class.getName().

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testXmlMethodConfigurationApplied()
MethodValidationTest.testVarargsMethodParameter()
b)

Varargs parameters are specified using the corresponding array type, e.g. a parameter String... must be specified as "[Ljava.lang.String;".

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testVarargsMethodParameter()
c)

If the default-package element is configured for the mapping file, any unqualified class names will be resolved using the given default package.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testXmlMethodConfigurationApplied()
MethodValidationTest.testVarargsMethodParameter()
MethodValidationTest.testMethodCrossParameterConstraint()
d)

A given getter method representing a JavaBeans property may either be configured using the getter or the method element, but not both. If a getter element and a method element referring to the same method are detected by the Bean Validation provider, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodAsGetterAndMethodNodeTest.testMethodConfiguredWithMethodAndGetterNodeThrowsException()
e)

If no method with the specified name and parameter types exists in the given bean a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
UnknownMethodValidationTest.testUnknownConfiguredMethodThrowsException()
f)

The optional return-value element is used to change the configuration of a method's return value if required.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testXmlMethodConfigurationApplied()
g)

The optional cross-parameter element is used to change the configuration of a method's cross-parameter constraints if required.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testMethodCrossParameterConstraint()
h)

The constraints applying for a method's parameters and its return value are specified by adding constraint elements to the parameter and return-value elements respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testConstraintOnMethodReturnValueAndParameter()
i)

Whether or not to perform cascaded validation is controlled using the valid element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testCascadingOnReturnValueAndParameter()
j)

Group conversion rules for cascaded validation are specified using the convert-group element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testGroupConversionOnReturnValueAndParameter()
k)

The cross-parameter constraints applied on a method parameter list are specified by adding constraint elements to the cross-parameter element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
MethodValidationTest.testMethodCrossParameterConstraint()
l)

If ignore-annotations is declared on the parameter, cross-parameter element or return value level, Bean Validation must honor the explicit value for this element. Otherwise, if ignore-annotations is declared for the method element, Bean Validation must honor this value. Otherwise, the default value declared in the encapsulating bean element is considered.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
IgnoreAnnotationsOnMethodTest.testIgnoreAnnotationsOnMethodLevel()
IgnoreAnnotationsInMethodConfigurationTest.testIgnoreAnnotationsOnReturnValueParameterAndCrossParameter()
m)

When ignore-annotations is true, Bean Validation annotations on the targeted method or parameter are ignored (including @Valid and @ConvertGroup).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
IgnoreAnnotationsOnMethodTest.testIgnoreAnnotationsOnMethodLevel()
n)

Constraints declared in XML and constraints declared in annotations are added and form the list of declared parameter, cross-parameter or return value constraints respectively.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
IgnoreAnnotationsOnMethodTest.testIgnoreAnnotationsOnMethodLevel()
o)

@Valid is considered unless the valid element is explicitly used.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
CascadedValidationTest.testValidaAnnotationIsApplied()
DisabledCascadedValidationTest.testValidAnnotationIsIgnored()
p)

Group conversions declared in XML and via the @ConvertGroup annotation are added and form the list of applied conversions. Note that the rules for the declaration of group conversions as outlined in 4.4.5 apply, in particular it is not legal to declare several conversions for the same source group. This does not apply to cross-parameter elements as cascading does not make sense in this situation.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.methodvalidation
IgnoreAnnotationsOnMethodTest.testIgnoreAnnotationsOnMethodLevel()

Section 8.1.1.6 - Constraint declaration

a)

The annotation attribute is the class name of the annotation representing the constraint. Message, groups and payload are defined respectively by the message, groups and payload elements.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
b)

The name attribute is mandatory and represents the name of the element in the constraint declaration.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
MandatoryNameAttributeTest.testNameAttributeIsMandatory()
c)

Message, groups and payload are not permitted names, use the message, groups or payload elements instead. Otherwise a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
ReservedElementNameTest.testGroupIsNotAllowedAsElementName()
ReservedElementNameTest.testMessageIsNotAllowedAsElementName()
ReservedElementNameTest.testPayloadIsNotAllowedAsElementName()
d)

If the element represents a primitive type, a class or an enum, the string representation of its value is placed in the element itself.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
e)

If the element represents a primitive type array, a class array or an enum array, the string representation of each value is placed in a value element placed under the element itself.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
f)

If the element represents an annotation, the annotation element is used to represent the annotation and placed under element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
g)

If the element represents an array of annotations, one or more annotation elements are placed under element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
h)

Elements with default values in the annotation definition do not have to be represented in XML: the default value will be used in this case.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
i)

If an XML constraint declaration is missing mandatory elements, or if it contains elements not part of the constraint definition, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdeclaration
MissingMandatoryElementTest.testMissingMandatoryElementInConstraintDeclaration()

Section 8.1.1.7 - Declaration of group conversions

a)

Group conversion rules are declared by specifying one or more convert-group elements within the field, getter, parameter and return-value elements.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.groupconversion
GroupConversionTest.testGroupConversionsAppliedOnMethod()
GroupConversionTest.testGroupConversionsAppliedOnConstructor()
GroupConversionTest.testGroupConversionsAppliedOnField()
GroupConversionTest.testGroupConversionsAppliedOnGetter()
b)

Source and target group of a conversion rule are given by specifying their fully-qualified names within the from and to attribute respectively. If the default-package element is configured for the mapping file, any unqualified class names will be resolved using the given default package.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.groupconversion
GroupConversionTest.testGroupConversionsAppliedOnMethod()
GroupConversionTest.testGroupConversionsAppliedOnConstructor()
GroupConversionTest.testGroupConversionsAppliedOnField()
GroupConversionTest.testGroupConversionsAppliedOnGetter()

Section 8.1.2 - Overriding constraint definitions in XML

a)

A constraint definition is represented by a constraint-definition element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testClassConstraintDefinedInXml()
XmlConfigurationTest.testIgnoreValidationXml()
XmlConfigurationTest.testPropertyConstraintDefinedInXml()
XmlConfigurationTest.testFieldConstraintDefinedInXml()
XmlConfigurationTest.testAnnotationDefinedConstraintApplies()
XmlConfigurationTest.testCascadingConfiguredInXml()
b)

If include-existing-validator is set to false, ConstraintValidator defined on the constraint annotation are ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdefinition
XmlConfiguredConstraintValidatorTest.testExcludeExistingValidators()
c)

If set to true, the list of ConstraintValidators described in XML are concatenated to the list of ConstraintValidator described on the annotation to form a new array of ConstraintValidator evaluated.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdefinition
XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()
d)

Annotation based ConstraintValidator come before XML based ConstraintValidators in the array.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdefinition
XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()
e)

The new list is returned by ConstraintDescriptor.getConstraintValidatorClasses().

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.constraintdefinition
XmlConfiguredConstraintValidatorTest.testExcludeExistingValidators()
XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()

Section 8.1.3 - Converting the string representation of a value

a)

Primitive types, Class and Enum are represented as strings in the XML descriptor. Elements of an array are represented by the value element.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
b)

Byte are represented according to the rules defined in Byte.parseByte(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
c)

Short are represented according to the rules defined in Short.parseShort(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
d)

Int are represented according to the rules defined in Integer.parseInt(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
e)

Long are represented according to the rules defined in Long.parseLong(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
f)

Float are represented according to the rules defined in Float.parseFloat(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
g)

Double are represented according to the rules defined in Double.parseDouble(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
h)

Boolean are represented according to the rules defined in Boolean.parseBoolean(String).

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
i)

Char are represented according to the following rules: the string must be of one character long the character extracted from the string is the returned char

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
j)

A Class is represented by the fully qualified class name of the class or more precisely according to the syntax described in the documentation of java.lang.Class.getName(). Note that if the raw string is unqualified, default package is taken into account.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
k)

An enum is represented by its enum.name() value.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()
l)

If any of the string representation does not match its type counterpart, a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration
XmlConfigurationTest.testIllegalAnnotationValueInXmlMappingCausesException()

Section 8.1.4 - XML Schema

a)

Implementations supporting Bean Validation 1.1 must properly parse mapping descriptors of Bean Validation 1.0 and 1.1.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.versioning
Version10InValidationXmlTest.testValidationXmlVersion10()
Version11InValidationXmlTest.testValidationXmlVersion11()
b)

If the version attribute attribute is not given, schema version 1.0 is to be assumed by the Bean Validation Provider.

c)

In case an unknown version is given (e.g. if a mapping descriptor adhering to a future schema version is parsed by a Bean Validation 1.1 provider) a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.versioning
UnknownVersionInValidationXmlTest.testValidationXmlWithUnknownSchemaVersion()

Section 8.2 - Configuration schema

a)

Implementations supporting Bean Validation 1.1 must properly parse configuration descriptors of Bean Validation 1.0 and 1.1.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.versioning
Version11InMappingXmlTest.testValidBeanValidation11Mapping()
Version10InMappingXmlTest.testValidBeanValidation10Mapping()
b)

If the version attribute attribute is not given, schema version 1.0 is to be assumed by the Bean Validation Provider.

c)

In case an unknown version is given a ValidationException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.xmlconfiguration.versioning
UnknownVersionInMappingXmlTest.testConstraintMappingWithUnknownSchemaVersion()

Section 9 - Exception model

a)

Every (runtime) exception raised either at initialization time or execution time by any of the extension interfaces (ConstraintValidator, ConstraintValidatorFactory, MessageInterpolator, TraversableResolver, ValidationProviderResolver, ParameterNameProvider) is wrapped in a ValidationException.

Coverage

org.hibernate.beanvalidation.tck.tests.bootstrap.customprovider
BootstrapNonAvailableValidationProviderTest.testUnknownProviderConfiguredInValidationXml()
BootstrapNonAvailableValidationProviderTest.testConfiguredValidationProviderIsNotLoadable()

Section 9.2 - Constraint definition: ConstraintDefinitionException

a)

If a constraint definition does not respect the Bean Validation rules or is inconsistent, a ConstraintDefinitionException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.invalidconstraintdefinitions
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()
InvalidConstraintDefinitionsTest.testGenericAndCrossParameterConstraintWithoutValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testGenericConstraintWithValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testCrossParameterConstraintWithValidationAppliesToCausesException()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongValidationAppliesToType()
InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultValidationAppliesTo()

Section 9.3 - Constraint declaration: ConstraintDeclarationException and UnexpectedTypeException

a)

When a constraint declaration is illegal, ConstraintDeclarationException is raised.

b)

When the return type of a property cannot be processed for a given constraint an UnexpectedTypeException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.validatorresolution
ValidatorResolutionTest.testAmbiguousValidatorResolution()

Section 9.4 - Group definition: GroupDefinitionException

a)

When a group definition is illegal, GroupDefinitionException is raised.

Coverage

org.hibernate.beanvalidation.tck.tests.constraints.groups.groupsequence
SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()
org.hibernate.beanvalidation.tck.tests.constraints.groups
GroupTest.testCyclicGroupSequence()

Section 10.1.1 - Objects lifecycle

a)

Build and bootstrap the ValidatorFactory instance for an application.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.defaultinjection
DefaultInjectionTest.testDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testDefaultValidatorGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorGetsInjected()
b)

Provide access to the ValidatorFactory instance as well as Validator instances in their default configuration using the paradigm of the container: for example, such instances would be injectable in other objects via a dependency injection framework.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.defaultinjection
DefaultInjectionTest.testDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testDefaultValidatorGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorGetsInjected()
c)

Configure ValidatorFactory with a custom ConstraintValidatorFactory instance that returns managed ConstraintValidator instances, unless a custom ConstraintValidatorFactory is requested by the user. The scope of ConstraintValidator instances is still fully controlled by the Bean Validation provider as described in 3.5, but as managed beans they can receive expected services like injection of other objects.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.factory
ConstraintValidatorInjectionTest.testDependencyInjectionIntoConstraintValidator()
d)

Configure ValidatorFactory with managed instances of ConstraintValidatorFactory, MessageInterpolator, ParameterNameProvider and TraversableResolver, if such instances are defined in the XML deployment descriptor. Services provided by the container (like dependency injection) should thus be available to these instances.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.managedobjects
ManagedObjectsTest.testMessageInterpolatorIsSubjectToDependencyInjection()
ManagedObjectsTest.testTraversableResolverIsSubjectToDependencyInjection()
ManagedObjectsTest.testConstraintValidatorFactoryIsSubjectToDependencyInjection()
ManagedObjectsTest.testParameterNameProviderIsSubjectToDependencyInjection()
e)

Invoke ValidatorFactory.close() when the ValidatorFactory instance is no longer needed.

f)

Dispose of managed instances provided to the Bean Validation bootstrap process after ValidatorFactory.close() has been invoked.

Section 10.1.2 - Method and constructor validation

a)

Method interception frameworks (such as AOP or interceptor frameworks) enable interception of constrained methods following the steps defined in 5.4.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testParameterValidationOfConstrainedMethod()
ExecutableValidationTest.testReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testCascadedReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testGettersAreNotValidatedByDefault()
ExecutableValidationTest.testParameterValidationOfConstrainedConstructor()
ExecutableValidationTest.testReturnValueValidationOfConstrainedConstructor()
b)

Method validation execution is implicit for any method or constructor annotated with constraints.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testParameterValidationOfConstrainedMethod()
ExecutableValidationTest.testReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testCascadedReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testGettersAreNotValidatedByDefault()
ExecutableValidationTest.testParameterValidationOfConstrainedConstructor()
ExecutableValidationTest.testReturnValueValidationOfConstrainedConstructor()
c)

By default, method validation is applied to all constrained methods or constructors provided the integration technology can intercept the call. By default, getters (as defined in 4.1) are not considered constrained methods.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testParameterValidationOfConstrainedMethod()
ExecutableValidationTest.testReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testCascadedReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testGettersAreNotValidatedByDefault()
ExecutableValidationTest.testParameterValidationOfConstrainedConstructor()
ExecutableValidationTest.testReturnValueValidationOfConstrainedConstructor()
d)

Static methods are ignored by validation. Putting constraints on a static method is not portable.

e)

The executable is validated if it is annotated with @ValidateOnExecution and the type attribute contains the executable type or IMPLICIT. If the type attribute does neither contain the executable type nor IMPLICIT, the executable is not validated.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testValidationOfConstrainedMethodAnnotatedWithValidateOnExecutionContainingExecutableType()
ExecutableValidationTest.testValidationOfConstrainedMethodAnnotatedWithValidateOnExecutionNotContainingExecutableType()
f)

Otherwise the executable is validated if the type (class, interface) on which it is declared is annotated with @ValidateOnExecution and the type attribute contains the executable type. If the type attribute contains IMPLICIT, then this rule is ignored and the behavior is equivalent to @ValidateOnExecution not being present. If the type attribute does not contain the executable type, the executable is not validated.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testValidationOfConstrainedMethodOnClassAnnotatedWithValidateOnExecutionContainingExecutableType()
ExecutableValidationTest.testValidationOfConstrainedMethodOnClassAnnotatedWithValidateOnExecutionNotContainingExecutableType()
ExecutableValidationTest.testValidationOfConstrainedMethodOnInterfaceAnnotatedWithValidateOnExecutionContainingExecutableType()
ExecutableValidationTest.testValidationOfConstrainedMethodOnInterfaceAnnotatedWithValidateOnExecutionNotContainingExecutableType()
g)

Otherwise the executable is validated if the global executable validation setting contains the executable type. If the global setting does not contain the executable type, the executable is not validated.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.global
ExecutableValidationBasedOnGlobalConfigurationTest.testValidationOfConstrainedMethodOnTypeAnnotatedWithValidateOnExecutionContainingExecutableType()
ExecutableValidationBasedOnGlobalConfigurationTest.testValidationOfConstrainedMethodOnTypeAnnotatedWithValidateOnExecutionNotContainingExecutableType()
h)

The rules above do not apply to methods overriding a superclass method or implementing an interface method. In this case, the method inherits the behavior of the method it overrides / implements. Out of the box, a conforming implementation raises a ValidationException if the overriding / implementing method hosts the @ValidateOnExecution annotation.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testExecutableValidationUsesDefaultSettingSinceValidatedMethodImplementsAnInterfaceMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromSuperTypeMethodIfValidatedMethodImplementsAnInterfaceMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromSuperTypeIfValidatedMethodImplementsAnInterfaceMethod()
ExecutableValidationTest.testExecutableValidationUsesDefaultSettingIfValidatedMethodOverridesASuperTypeMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromSuperTypeMethodIfValidatedMethodOverridesASuperTypeMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromSuperTypeIfValidatedMethodOverridesASuperTypeMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromHighestMethodInHierarchyIfValidatedMethodImplementsAnInterfaceMethod()
ExecutableValidationTest.testExecutableValidationUsesSettingFromSuperTypeForOverriddenMethodsAndLocalSettingForNonOverriddenMethod()
i)

NONE: parameters and return values are not validated upon execution. This option is equivalent to an empty list of executable types and is present to improve readability. A list containing NONE and other types of executables is equivalent to a list containing the types of executables without NONE.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypeNONE()
ExecutableTypesTest.testValidationOfConstrainedMethodWithEmptyExecutableTypes()
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypeNONEAndOther()
j)

CONSTRUCTORS: parameters and return values are validated provided the executable is a constructor.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedConstructorParametersWithExecutableTypeCONSTRUCTORS()
ExecutableTypesTest.testValidationOfConstrainedConstructorReturnValueWithExecutableTypeCONSTRUCTORS()
ExecutableTypesTest.testValidationOfConstrainedConstructorWithoutExecutableTypeCONSTRUCTORS()
k)

NONGETTERMETHODS: parameters and return values are validated provided the executable is a method but not a getter.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedMethodParametersWithExecutableTypeNON_GETTER_METHODS()
ExecutableTypesTest.testValidationOfConstrainedMethodReturnValueWithExecutableTypeNON_GETTER_METHODS()
ExecutableTypesTest.testValidationOfConstrainedGetterWithExecutableTypeNON_GETTER_METHODS()
l)

GETTER_METHODS: return values are validated provided the executable is a getter method.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedGetterReturnValueWithExecutableTypeGETTER_METHODS()
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypeGETTER_METHODS()
m)

ALL: parameters and return values are validated for all executables (getters, non getters and constructors). This option is equivalent to a list of all executable types and is present to improve readability. A list containing ALL and other types of executables is equivalent to a list containing only ALL.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypeALL()
ExecutableTypesTest.testValidationOfConstrainedGetterWithExecutableTypeALL()
ExecutableTypesTest.testValidationOfConstrainedConstructorWithExecutableTypeALL()
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypesALLAndNONE()
n)

IMPLICIT: if @ValidateOnExecution is on a type (class or interface), then it is equivalent to @ValidateOnExecution not being present; if @ValidateOnExecution is on a an executable, the following applies: if on a constructor, it is equivalent to CONSTRUCTORS. if on a non-getter method, it is equivalent to NONGETTERMETHODS. if on a getter, it is equivalent to GETTER_METHODS.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.types
ExecutableTypesTest.testValidationOfConstrainedMethodWithExecutableTypeIMPLICIT()
ExecutableTypesTest.testValidationOfConstrainedGetterWithExecutableTypeIMPLICIT()
ExecutableTypesTest.testValidationOfConstrainedGetterWithExecutableTypeIMPLICITOnTypeLevel()
ExecutableTypesTest.testValidationOfConstrainedConstructorWithExecutableTypeIMPLICIT()
o)

Mixing IMPLICIT and other executable types is illegal.

p)

If a sub type overrides/implements a method originally defined in several parallel types of the hierarchy (e.g. two interfaces not extending each other, or a class and an interface not implemented by said class), @ValidateOnExecution cannot be placed in the parallel types of the hierarchy.

q)

You can globally disable executable validation by using <executable-validation enabled="false"/>, in this case, <default-validated-executable-types/> and @ValidateOnExecution are ignored.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.globallydisabled
ExecutableValidationGloballyDisabledTest.testExecutableValidationGloballyTurnedOff()

Section 10.2 - Java EE

a)

Java EE must obey the rules defined above and make the following instances available under JNDI: ValidatorFactory under java:comp/ValidatorFactory Validator under java:comp/Validator

Coverage

org.hibernate.beanvalidation.tck.tests.integration.ee
JndiRetrievalTest.testDefaultValidatorFactoryCanBeRetrievedFromJndi()
JndiRetrievalTest.testDefaultValidatorCanBeRetrievedFromJndi()
b)

Instead of looking the instances up via JNDI, the user can request them to be injected via the Resource annotation

Coverage

org.hibernate.beanvalidation.tck.tests.integration.ee
DefaultInjectionTest.testDefaultValidatorFactoryGetsInjectedAtResource()
DefaultInjectionTest.testDefaultValidatorGetsInjectedWithAtResource()
c)

When the application is CDI enabled, the ValidatorFactory and Validator instances returned by JNDI or @Resource injection are CDI enhanced as defined in 10.3.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.ee.cdi
ConstraintValidatorInjectionTest.testJndiBoundValidatorFactoryIsCdiEnabled()

Section 10.3 - Context and Dependency Injection (CDI) integration

a)

Bean Validation provider must integrate with CDI

Coverage

org.hibernate.beanvalidation.tck.tests.integration.ee.cdi
ConstraintValidatorInjectionTest.testJndiBoundValidatorFactoryIsCdiEnabled()
org.hibernate.beanvalidation.tck.tests.integration.cdi.managedobjects
ManagedObjectsTest.testMessageInterpolatorIsSubjectToDependencyInjection()
ManagedObjectsTest.testTraversableResolverIsSubjectToDependencyInjection()
ManagedObjectsTest.testConstraintValidatorFactoryIsSubjectToDependencyInjection()
ManagedObjectsTest.testParameterNameProviderIsSubjectToDependencyInjection()
org.hibernate.beanvalidation.tck.tests.integration.cdi.defaultinjection
DefaultInjectionTest.testDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testDefaultValidatorGetsInjected()
org.hibernate.beanvalidation.tck.tests.integration.cdi.executable
ExecutableValidationTest.testParameterValidationOfConstrainedMethod()
ExecutableValidationTest.testReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testCascadedReturnValueValidationOfConstrainedMethod()
ExecutableValidationTest.testGettersAreNotValidatedByDefault()
ExecutableValidationTest.testParameterValidationOfConstrainedConstructor()
ExecutableValidationTest.testReturnValueValidationOfConstrainedConstructor()
org.hibernate.beanvalidation.tck.tests.integration.cdi.factory
ConstraintValidatorInjectionTest.testDependencyInjectionIntoConstraintValidator()

Section 10.3.1 - ValidatorFactory and Validator

a)

Similar to the Java EE integration via @Resource (see 10.2), a CDI container must support injection of built-in default ValidatorFactory and Validator beans via @Inject. These default beans are injectable via the @Default qualifier.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.defaultinjection
DefaultInjectionTest.testDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorFactoryGetsInjected()
DefaultInjectionTest.testDefaultValidatorGetsInjected()
DefaultInjectionTest.testQualifiedDefaultValidatorGetsInjected()

Section 10.3.2 - ConstraintValidatorFactory, MessageInterpolator, ParameterNameProvider and TraversableResolver

a)

If a custom ConstraintValidatorFactory, MessageInterpolator, ParameterNameProvider or TraversableResolver class is defined in the XML deployment descriptor (see 5.5.6), the ValidatorFactory must be configured with CDI managed beans representing the requested classes. Services like dependency injection, interception and decoration must thus be made available to these instances by the container.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.managedobjects
ManagedObjectsTest.testMessageInterpolatorIsSubjectToDependencyInjection()
ManagedObjectsTest.testTraversableResolverIsSubjectToDependencyInjection()
ManagedObjectsTest.testConstraintValidatorFactoryIsSubjectToDependencyInjection()
ManagedObjectsTest.testParameterNameProviderIsSubjectToDependencyInjection()
b)

If no custom ConstraintValidatorFactory is requested by the user, the ValidatorFactory must be configured with a custom ConstraintValidatorFactory instance that returns CDI managed beans representing the requested ConstraintValidator types. The factory creates non-contextual ConstraintValidator instances for each ConstraintValidatorFactory.getInstance() call. To inject dependencies into the ConstraintValidator instance, the CDI InjectionTarget API should be used. Before returning the instance the following calls should be made: InjectionTarget.produce(), InjectionTarget.inject() and InjectionTarget.postConstruct(). calls InjectionTarget.preDestroy() and InjectionTarget.dispose() upon ConstraintValidatorFactory.releaseInstance (see also 3.5 for more information about the life cycle of a ConstraintValidator).

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.factory
ConstraintValidatorInjectionTest.testDependencyInjectionIntoConstraintValidator()
c)

Using directly or indirectly a JPA EntityManager that might call back Bean Validation for validation is not allowed in the Bean Validation extension points and in ConstraintValidator instances. This would lead to infinite flush or unexpected behavior.

Section 10.3.3 - Method and constructor validation

a)

Bean Validation requires that CDI beans support constructor and method validation as defined in 10.1.2. Validation must happen at the equivalent time an interceptor occurs when having priority Interceptor.Priority.PLATFORM_AFTER+800, in other words priority of 4800.

Coverage

org.hibernate.beanvalidation.tck.tests.integration.cdi.executable.priority
ValidationInterceptorPriorityTest.testValidationInterceptorHasPriority4800()
b)

For maximum portability, it is recommended to mark CDI bean interfaces and classes involved in executable validation with @ValidateOnExecution (defaults to IMPLICIT). This helps some implementations to be more efficient. Most CDI - Bean Validation integration implementations do not need such marker. In particular this marker should not be needed on validated beans annotated with constraint annotations, @Valid or @ValidateOnExecution anywhere in the class. Such limitation will be removed in a future version of this specification.