Author: hardy.ferentschik Date: 2009-11-25 09:51:19 -0500 (Wed, 25 Nov 2009) New Revision: 31759 Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.sha1 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.sha1 Modified: maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.md5 maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.sha1 Log: added 1.0.3.GA of BV TCK Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1,1324 @@ +<specification xmlns="http://jboss.com/products/webbeans/tck/audit" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://jboss.com/products/webbeans/tck/audit http://snapshots.jboss.org/maven2/org/hibernate/tck-utils-api/0.9-SNAPSHO... + name="JSR-303: Bean Validation" version="Revised Public Review Draft"> + + <section id="2" title="Constraint Definition"/> + <section id="2.1" title="Constraint Annotation"> + <assertion id="a" testable="false"> + <text>An annotation is considered a constraint definition if its retention policy + contains RUNTIME and if the annotation itself is annotated with + javax.validation.Constraint</text> + </assertion> + <assertion id="b" testable="false"> + <text>Constraint annotations can target any of the following ElementTypes: FIELD, + METHOD, TYPE, ANNOTATION_TYPE</text> + </assertion> + <assertion id="c"> + <text>If a constraint definition is not valid, a ConstraintDefinitionException is raised + either at validation time or when the metadata is requested</text> + </assertion> + <assertion id="d"> + <text>Applying a constraint annotation to an incompatible type will raise a + UnexpectedTypeException</text> + </assertion> + </section> + + <section id="2.1.1" title="Constraint definition properties"> + <assertion id="a"> + <text>A constraint definition may have attributes that are specified at the time the + constraint is applied to a JavaBean.</text> + </assertion> + <assertion id="b"> + <text>Annotation elements starting with valid are not allowed</text> + </assertion> + <assertion id="c"> + <text>Every constraint annotation must define a message element of type String</text> + </assertion> + <assertion id="d"> + <text>Every constraint annotation must define a groups element that specifies which + processing groups the constraint definition is associated with.</text> + </assertion> + <assertion id="e"> + <text>The default value for the groups element must be an empty array.</text> + </assertion> + <assertion id="f"> + <text>If no group is specified when declaring the constraint on an element, the Default + group is considered declared.</text> + </assertion> + <assertion id="g" implied="true"> + <text>The type of the groups parameter is Class&lt;?&gt;[].</text> + </assertion> + + <assertion id="h"> + <text>Every constraint annotation must define a payload element that specifies which + payload the constraint declaration is associated with. </text> + </assertion> + <assertion id="i"> + <text>The default value for the payload parameter must be an empty array. </text> + </assertion> + <assertion id="j"> + <text>Each attachable payload extends Payload. </text> + </assertion> + </section> + + <section id="2.2" title="Applying multiple constraints of the same type"> + <assertion id="a"> + <text>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.</text> + </assertion> + </section> + <section id="2.3" title="Constraint composition"> + <assertion id="a"> + <text>Each constraint annotation hosted on a constraint annotation is applied to the + target element and this recursively</text> + </assertion> + <assertion id="b"> + <text>Note that the main annotation and its constraint validation implementation is also + applied</text> + </assertion> + <assertion id="c"> + <text>By default, each failing constraint generates an error report</text> + </assertion> + <assertion id="d"> + <text>Groups from the main constraint annotation are inherited by the composing + annotations</text> + </assertion> + <assertion id="e"> + <text>Any groups definition on a composing annotation is ignored</text> + </assertion> + <assertion id="f"> + <text>The property type a composed constraint is placed on must be compatible with all + constraints (composing and composed)</text> + </assertion> + <assertion id="g"> + <text> If a composed constraint is marked as @ReportAsSingleViolation, and if any of its + composing constraint reports one or more violations, all reports from composing + constraints are ignored and the error report corresponding to the composed + constraint is generated</text> + </assertion> + <assertion id="h"> + <text>Composing annotations can define the value of message and custom attributes + (excluding groups) but these are fixed in the composed constraint definition</text> + </assertion> + <assertion id="i"> + <text>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</text> + </assertion> + <assertion id="j"> + <text> The types of the overridden and overriding attributes must be identical</text> + </assertion> + <assertion id="k"> + <text>A composing constraint can itself be a composed constraint. In this case, + attribute values are overridden recursively according to the described rules</text> + </assertion> + <assertion id="l"> + <text>If a constraint is used more than once as a composing constraint, the multi value + constraints model as described in Section 2.2 is used</text> + </assertion> + <assertion id="m"> + <text>To select the appropriate composing constraint targeted, OverridesAttrib- + ute.constraintIndex is used. It represents the constraint index in the value + array</text> + </assertion> + <assertion id="n"> + <text>If index is undefined, the single constraint declaration is targeted</text> + </assertion> + <assertion id="o"> + <text>If the composition is invalid (infinite composition, wrong attribute overriding, a + single attribute mapped to more than one source attribute etc), a + ConstraintDefinitionException is raised either at validation time or when the + metadata is requested</text> + </assertion> + <assertion id="p"> + <text>Any payload definition on a composing annotation is ignored</text> + </assertion> + </section> + <section id="2.4" title="Constraint validation implementation"> + <assertion id="a"> + <text>A constraint validation implementation performs the validation of a given + constraint annotation for a given type</text> + </assertion> + <assertion id="b"> + <text>The implementation classes are specified by the validatedBy element of the + @Contraint annotation that decorates the constraint definition</text> + </assertion> + <assertion id="c" testable="false"> + <text>The constraint validation implementation implements the ConstraintValidator + interface</text> + </assertion> + <assertion id="d" testable="false"> + <text>T must resolve in a non parameterized type or generic parameters of T must be + unbounded wildcard types</text> + </assertion> + <assertion id="e"> + <text>The initialize method is called by the Bean validation provider prior to any use + of the constraint implementation.</text> + </assertion> + <assertion id="f"> + <text>The isValid method is evaluated by the Bean Validation provider each time a given + value is validated</text> + </assertion> + <assertion id="g" testable="false"> + <text>It returns false if the value is not valid, true otherwise</text> + </assertion> + <assertion id="h" testable="false"> + <text>isValid implementations must be thread-safe</text> + </assertion> + <assertion id="i"> + <text>If the property is of an unanticipated type, an UnexpectedTypeException is + raised</text> + </assertion> + <assertion id="j"> + <text>If an exception occurs either in the initialize or isValid method, the runtime + exception is wrapped into a ValidationException by the Bean Validation engine + </text> + </assertion> + <assertion id="k" testable="false"> + <text>The constraint validation implementation is not allowed to change the state of the + value passed to isValid. </text> + </assertion> + <assertion id="l"> + <text>By default, each invalid constraint leads to the generation of one error object + represented by a ConstraintViolation object. This object is build from the default + error message as defined by the constraint declaration and the context in which the + constraint declaration is placed on (bean, property, attribute)</text> + </assertion> + <assertion id="m"> + <text>The ConstraintValidatorContext methods let the constraint implementation disable + the default error object generation and create one or more custom ones</text> + </assertion> + <assertion id="n"> + <text>The non-interpolated message passed as a parameter is used to build the + ConstraintViolation object (the message interpolation operation is applied to + it)</text> + </assertion> + <assertion id="o"> + <text>By default, the propertyPath exposed on the ConstraintViolation represents the + path to the bean or property hosting the constraint</text> + </assertion> + <assertion id="q"> + <text>You can point an error to a subpath of this default path by using the error + builder fluent API.</text> + </assertion> + <assertion id="r"> + <text>If disableDefaultError is called, no custom error is added (using the error + builder) and if the constraint is not valid, a ValidationException is raised.</text> + </assertion> + </section> + <section id="2.5" title="The ConstraintValidatorFactory"> + <assertion id="a"> + <text>The default ConstraintValidatorFactory provided by the Bean Validation provider + implementation uses the public constraint no-arg constructor</text> + </assertion> + <assertion id="b"> + <text>If an exception occurs in the factory while retrieving the ConstraintValidator + instance, the runtime exception is wrapped in a ValidationException</text> + </assertion> + <assertion id="c"> + <text>If the instance returned by the factory is null, a ValidationException is + raised</text> + </assertion> + </section> + + <section id="3" title="Constraint declaration and validation process"/> + <section id="3.1" title="Requirements on classes to be validated"> + <assertion id="a"> + <text>Properties to be validated must follow the method signature conventions for + JavaBeans read properties, as defined by the JavaBeans specification</text> + </assertion> + <assertion id="b" testable="false"> + <!-- The spec is not clear about whether validation of static fields/properties should just be ignored or an + exception should be thrown. --> + <text>Static fields and static methods are excluded from validation</text> + </assertion> + <assertion id="c"> + <text>Constraints can be applied to interfaces and superclasses</text> + </assertion> + <assertion id="d"> + <text>The target of an annotation definition can be a field, property, or type, provided + that the constraint definition supports the specified target and the constraint + supports the declared type of the target. </text> + </assertion> + </section> + <section id="3.1.1" title="Object validation"> + <assertion id="a"> + <text>Constraint declarations can be applied to a class or an interface</text> + </assertion> + </section> + <section id="3.1.2" title="Field and property validation"> + <assertion id="a"> + <text>Constraint declarations can be applied on both fields and properties for the same + object type</text> + </assertion> + <assertion id="b"> + <text>The same constraint should however not be duplicated between a field and its + associated property (the constraint validation would be applied twice)</text> + </assertion> + <assertion id="c"> + <text>When a field is annotated with a constraint declaration, field access strategy is + used to access the state validated by such constraint</text> + </assertion> + <assertion id="d"> + <text>When a property is annotated with a constraint declaration, property access + strategy is used to access the state validated by such constraint</text> + </assertion> + <assertion id="e"> + <text>The fields or methods visibility are not constrained</text> + </assertion> + <assertion id="f"> + <text>Constraints on non getter methods are not supported</text> + </assertion> + </section> + <section id="3.1.3" title="Graph validation"> + <assertion id="a"> + <text>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.</text> + </assertion> + <assertion id="b"> + <text> 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</text> + </assertion> + <assertion id="c"> + <text>Array of objects is supported by @Valid. The content of the array is + validated.</text> + </assertion> + <assertion id="d"> + <text>java.util.Collection is supported by @Valid. The content of the collection is + validated.</text> + </assertion> + <assertion id="e"> + <text>java.util.Set is supported by @Valid. The content of the Set is validated.</text> + </assertion> + <assertion id="f"> + <text>java.util.List is supported by @Valid. The content of the list is + validated.</text> + </assertion> + <assertion id="g"> + <text>java.util.Map is supported by @Valid</text> + </assertion> + <assertion id="h"> + <text>java.lang.Iterable is supported by @Valid. The elements of the iterable are + validated</text> + </assertion> + <assertion id="i"> + <text>For Map, the value of each entry is validated (the key is not validated)</text> + </assertion> + <assertion id="j"> + <text>Like regular references, the type of the collection, array or Iterable element is + determined at runtime and the constraint definitions for this particular type are + used</text> + </assertion> + <assertion id="k"> + <text>The @Valid annotation is applied recursively</text> + </assertion> + </section> + <section id="3.3" title="Inheritance"> + <assertion id="a"> + <text>A constraint declaration can be placed on an interface</text> + </assertion> + <assertion id="b"> + <text>For a given class, constraint declarations held on superclasses as well as + interfaces are evaluated by the Bean Validation provider</text> + </assertion> + </section> + <section id="3.4" title="Group and group sequence"> + <assertion id="a"> + <text>If no group is explicitly declared, a constraint belongs to the Default + group</text> + </assertion> + <assertion id="b"> + <text>Groups are represented by interfaces</text> + </assertion> + <assertion id="c"> + <text>A constraint can belong to one or more groups</text> + </assertion> + <assertion id="d"> + <text>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</text> + </assertion> + </section> + <section id="3.4.1" title="Group inheritance"> + <assertion id="a"> + <text>A group can inherit one or more groups by using interface inheritance</text> + </assertion> + <assertion id="b"> + <text>For a given interface Z, constraints marked as belonging to the group Z (ie where + the annotation groups property contains the interface Z) or any of the super + interfaces of Z (inherited groups) are considered part of the group Z</text> + </assertion> + </section> + + <section id="3.4.2" title="Group sequence "> + <assertion id="a" testable="false"> + <text>By default, constraints are evaluated in no particular order and this regardless + of which groups they belong to</text> + </assertion> + <assertion id="b"> + <text>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</text> + </assertion> + <assertion id="c"> + <text>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.</text> + </assertion> + <assertion id="d"> + <text>If one of the groups processed in the sequence generates one or more constraint + violation, the groups following in the sequence must not be processed</text> + </assertion> + <assertion id="e"> + <text>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 + definition or group inheritance</text> + </assertion> + <assertion id="f"> + <text>If a group containing such a circularity is evaluated, a GroupDefinitionException + is raised.</text> + </assertion> + <assertion id="g" testable="false"> + <text>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.</text> + </assertion> + <assertion id="h" testable="false"> + <text>Groups defining a sequence should not be used directly in constraint + declarations</text> + </assertion> + <assertion id="i"> + <text>To define a group as a sequence, the interface must be annotated with the + @GroupSequence annotation</text> + </assertion> + <assertion id="j"> + <text>A given constraint can belong to two 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)</text> + </assertion> + </section> + <section id="3.4.3" title="Redefining the Default group for a class"> + <assertion id="a"> + <text>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.</text> + </assertion> + <assertion id="b" testable="false"> + <text>Constraints hosted on a class A and belonging to the Default group (by default or + explicitly) implicitly belong to the group A</text> + </assertion> + <assertion id="c"> + <text>A sequence defined on a class A (ie. redefining the Default groups for the class) + must contain the group A</text> + </assertion> + <assertion id="d"> + <text>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</text> + </assertion> + </section> + <section id="3.4.4" title="Implicit grouping"> + <assertion id="a"> + <text>Every constraint hosted on an interface Z and part of the Default group + (implicitly or explicitly) belongs to the group Z</text> + </assertion> + </section> + <section id="3.4.5" title="Formal group definitions"> + <assertion id="a"> + <text>If a class does have a @GroupSequence annotation, the group Default contains every + constraint belonging to every group declared by the @GroupSequence + annotation.</text> + </assertion> + <assertion id="b"> + <text>If class X has no @GroupSequence annotation, the group Default contains every + constraint in the group X and if X has a direct superclass Y, every constraint in + the group Default of Y this rule</text> + </assertion> + </section> + <section id="3.5" title="Validation routine"> + <assertion id="a" testable="false"> + <text>For a given group to validate, the validation routine applied on a given bean + instance is expected to execute the constraint validations in no particular + order</text> + </assertion> + <assertion id="b"> + <text>Note that this implies that a given validation constraint will not be processed + more than once per validation</text> + </assertion> + <assertion id="c" testable="false"> + <text>Unless ordered by group sequences, groups can be validated in no particular + order</text> + </assertion> + </section> + <section id="3.5.1" title="Object graph validation "> + <assertion id="a"> + <text>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)</text> + </assertion> + <assertion id="b"> + <text>This mechanism is recursive</text> + </assertion> + <assertion id="c"> + <text>Null references are ignored</text> + </assertion> + <assertion id="d"> + <text>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)</text> + </assertion> + <assertion id="e"> + <text>@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.</text> + </assertion> + </section> + <section id="3.5.2" title="Traversable property"> + <assertion id="a"> + <text>isReachable is called for every property about to be accessed either for + validation or for cascading</text> + </assertion> + <assertion id="b"> + <text>isCascadable is called for every property about to be cascaded (ie. marked as + @Valid)</text> + </assertion> + <assertion id="c"> + <text>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</text> + </assertion> + <assertion id="d"> + <text>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</text> + </assertion> + <assertion id="e"> + <text>If an exception occurs when the TraversableResolver is called, the exception is + wrapped into a ValidationException</text> + </assertion> + <assertion id="f" testable="false"> + <text>If Java Persistence is available in the runtime environment, a property is + considered reachable if Java Persistence considers the property as loaded</text> + </assertion> + <assertion id="g" testable="false"> + <text>If Java Persistence is not available in the runtime environment, all properties + are considered reachable</text> + </assertion> + <assertion id="h" testable="false"> + <text>If Java Persistence is not available in the runtime environment, all properties + are considered cascadable</text> + </assertion> + </section> + <section id="3.5.3" title="ConstraintValidator resolution algorithm"> + <assertion id="a"> + <text>If the constraint declaration is hosted on a class or an interface, the targeted + type is the class or the interface</text> + </assertion> + <assertion id="b"> + <text>If the constraint is hosted on a class attribute, the type of the attribute is the + targeted type</text> + </assertion> + <assertion id="c"> + <text>If the constraint is hosted on a getter, the return type of the getter is the + targeted type</text> + </assertion> + <assertion id="d"> + <text>the ConstraintValidator chosen to validate a declared type T is the one 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</text> + </assertion> + <assertion id="e"> + <text>If no ConstraintValidator compliant with T is found amongst the + ConstraintValidators listed by the constraint A, a UnexpectedTypeException is + raised</text> + </assertion> + <assertion id="f"> + <text>If more than one maximally specific ConstraintValidator is found, a + UnexpectedTypeException is raised</text> + </assertion> + </section> + + <section id="4" title="Validation APIs"/> + <section id="4.1" title="Validator API "> + <assertion id="a" testable="false"> + <text>Validator implementations are thread-safe</text> + </assertion> + </section> + <section id="4.1.1" title="Validation methods"> + <assertion id="a"> + <text>validate(T object, Class... groups) is used to validate a given object</text> + </assertion> + <assertion id="b"> + <text>An IllegalArgumentException is thrown when validateProperty is called and object + is null or null is passed to the varargs groups.</text> + </assertion> + <assertion id="c"> + <text>A Set containing all ConstraintViolation objects representing the failing + constraints is returned, an empty Set is returned otherwise</text> + </assertion> + <assertion id="d"> + <text>validateProperty(T object, String propertyName, Class... groups) validates a given + field or property of an object</text> + </assertion> + <assertion id="e"> + <text>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.</text> + </assertion> + <assertion id="f"> + <text>The property name in validateProperty is the JavaBeans property name (as defined + by the JavaBeans Introspector class)</text> + </assertion> + <assertion id="g"> + <text>@Valid is not honored by a call to validateProperty.</text> + </assertion> + <assertion id="h"> + <text>validateValue(Class 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.</text> + </assertion> + <assertion id="i"> + <text>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.</text> + </assertion> + <assertion id="j"> + <text>@Valid is not honored by validateValue.</text> + </assertion> + <assertion id="k"> + <text>If some unrecoverable failure happens during validation, a ValidationException is + raised.</text> + </assertion> + </section> + <section id="4.1.2" title="groups"> + <assertion id="a"> + <text>All constraints belonging to the targeted group are applied during the validation + routine.</text> + </assertion> + <assertion id="b"> + <text>If no group is passed, the Default group is assumed</text> + </assertion> + <assertion id="c" testable="false"> + <text>When more than one group is evaluated and passed to the various validate methods, + order is not constrained</text> + </assertion> + </section> + <section id="4.2" title="ConstraintViolation"> + <assertion id="a"> + <text>The getMessage method returns the interpolated (localized) message for the failing + constraint</text> + </assertion> + <assertion id="b"> + <text>The getMessageTemplate method returns the non-interpolated error message</text> + </assertion> + <assertion id="c"> + <text>The getRootBean method returns the root object being validated that led to the + failing constraint</text> + </assertion> + <assertion id="d"> + <text>The getInvalidValue method returns the value (field, property or validated object) + being passed to isValid</text> + </assertion> + <assertion id="e"> + <text>getConstraintDescriptor provides access to the failing constraint metadata</text> + </assertion> + <assertion id="f"> + <text>getPropertyPath returns the Path object representing the navigation path from the + root object to the failing object</text> + </assertion> + <assertion id="g"> + <text>If the failing object is the root object, the property path consists of a single + Node with name set to null.</text> + </assertion> + <assertion id="h"> + <text>If failing object is traversed, a Node object whose name equals the name of the + association property (field name or Java Bean property name) is added to Path. + </text> + </assertion> + <assertion id="i"> + <text>If the traversed association is a List or an array, the added Node object contains + the index value in getIndex. </text> + </assertion> + <assertion id="j"> + <text>If the association is a Map, the added Node object (representing a given map + entry) contains the key value in getKey </text> + </assertion> + <assertion id="k"> + <text>For all Iterable or Map, the added Node object added is marked as inIterable + (isInIterable) </text> + </assertion> + <assertion id="l"> + <text>For a property level constraint (field and getter) a Node object is added to Path + whose name equals the name of the property. </text> + </assertion> + <assertion id="m"> + <text>For a class level constraint a Node object is added to Path whose name is null + </text> + </assertion> + <assertion id="n" testable="false"> + <text>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. </text> + </assertion> + + </section> + <section id="4.3.1" title="Default message interpolation"> + <assertion id="a"> + <text>A conforming implementation includes a default message interpolator</text> + </assertion> + <assertion id="b"> + <text>Each constraint defines a message descriptor via its message property</text> + </assertion> + <assertion id="c"> + <text>Every constraint definition shall define a default message descriptor for that + constraint.</text> + </assertion> + <assertion id="d"> + <text>Messages can be overridden at declaration time in constraints by setting the + property on the constraint.</text> + </assertion> + <assertion id="e"> + <text>The message descriptor is a string literal and may contain one or more message + parameters. Message parameters are string literals enclosed in braces</text> + </assertion> + <assertion id="f"> + <text>\{ is considered as the literal { instead of being considered as the beginning of + a message parameter</text> + </assertion> + <assertion id="g"> + <text>\} is considered as the literal } instead of being considered as the end of a + message parameter</text> + </assertion> + <assertion id="h"> + <text>\\ is considered as the literal \ instead of being considered as the escaping + character</text> + </assertion> + </section> + <section id="4.3.1.1" title="Default message interpolation algorithm"> + <assertion id="a"> + <text>Message parameters are extracted from the message string and used as keys to + search the ResourceBundle named ValidationMessages (step1)</text> + </assertion> + <assertion id="b"> + <text>Step 1 is applied recursively until no replacement is performed</text> + </assertion> + <assertion id="c"> + <text>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. If a property is found, the message parameter is replaced with the property + value in the message string (step 2)</text> + </assertion> + <assertion id="e" testable="false"> + <!-- in order to test one would have to make assumptions about the provider specific resource bundle --> + <text>Contrary to step 1, step 2 is not processed recursively</text> + </assertion> + <assertion id="f" testable="false"> + <!-- in order to test one would have to make assumptions about the provider specific resource bundle --> + <text>If step 2 triggers a replacement, then step 1 is applied again</text> + </assertion> + <assertion id="g"> + <text>As last step message parameters are extracted from the message string. Those + matching the name of an attribute of the constraint declaration are replaced by the + value of that attribute.</text> + </assertion> + <assertion id="h"> + <text>If the locale is passed to the interpolator method interpolate(String, + CosntraintDescriptor, Object, Locale), this Locale instance is used</text> + </assertion> + <assertion id="i"> + <text>If the locale is not specified, the default Locale as provided by + Locale.getDefault() is used.</text> + </assertion> + </section> + <section id="4.3.2" title="Custom message interpolation"> + <assertion id="a" testable="false"> + <text>A message interpolator implementation shall be thread-safe</text> + </assertion> + <assertion id="b"> + <text>It is possible to override the MessageInterpolator implementation for a given + Validator instance by invoking + ValidatorFactory.usingContext().messageInterpolator(messageInterpolator).getValidator()</text> + </assertion> + </section> + <section id="4.4" title="Bootstrapping"> + <assertion id="a"> + <text>A bootstrap implementation must be able to bootstrap any Bean Validation provider + implementation</text> + </assertion> + </section> + <section id="4.4.1" title="Examples"> + <assertion id="a" testable="false"> + <text>The ValidatorFactory object is thread-safe</text> + </assertion> + </section> + <section id="4.4.2" title="ValidatorFactory"> + <assertion id="a"> + <text>The MessageInterpolator or the TraversableResolver passed to the ValidatorContext + are used instead of the ValidatorFactory's MessageInterpolator or + TraversableResolver instances</text> + </assertion> + <assertion id="b"> + <text>getMessageInterpolator() returns the MessageInterpolator instance configured + during the initialization of the ValidatorFactory</text> + </assertion> + </section> + <section id="4.4.3" title="Configuration"> + <assertion id="a"> + <text>A Bean Validation provider must define a sub interface of Configuration uniquely + identifying the provider.</text> + </assertion> + <assertion id="b" testable="false"> + <text>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)</text> + </assertion> + <assertion id="c" testable="false"> + <text>If no ValidationProviderResolver instance has been specified, the default + ValidationProviderResolver is used</text> + </assertion> + </section> + <section id="4.4.4.1" title="ValidationProviderResolver"> + <assertion id="a"> + <text>ValidationProviderResolver returns the list of Bean Validation providers available + at runtime and more specifically a ValidationProvider instance for each provider + available in the context</text> + </assertion> + <assertion id="b" testable="false"> + <text>Implementations must be thread-safe</text> + </assertion> + <assertion id="c"> + <text>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</text> + </assertion> + </section> + <section id="4.4.4.2" title="ValidationProvider"> + <assertion id="a"> + <text>A client can request a specific Bean Validation provider by using + Validation.byProvider() or by defining the provider in the XML configuration + file</text> + </assertion> + <assertion id="b"> + <text>The provider discovery mechanism retrieve all available providers using + ValidationProviderResolver.getValidationProviders() and returns the first + ValidationProvider matching the requested provider</text> + </assertion> + <assertion id="c"> + <text>When the default Bean Validation provider is requested, the first + ValidationProvider returned by the ValidationProviderResolver strategy is + returned</text> + </assertion> + <assertion id="d"> + <text>Every Bean Validation provider must provide a ValidationProvider implementation + containing a public no-arg constructor</text> + </assertion> + <assertion id="e"> + <text>If a problem occurs while building the ValidatorFactory, a ValidationException is + raised</text> + </assertion> + </section> + <section id="4.4.5" title="Validation"> + <assertion id="a"> + <text> Validation.buildDefaultValidatorFactory(), is considered to be the default + ValidatorFactory and is equivalent to the ValidatorFactory returned by + Validation.byDefaultProvider().configure().buildValidatorFactory() </text> + </assertion> + <assertion id="b"> + <text>ValidationProvider.createGenericConfiguration(BootstrapState state) is the second + bootstrapping entry point and let the client provide a custom + ValidationProviderResolution instance</text> + </assertion> + <assertion id="c"> + <text>ValidationProvider.createGenericConfiguration(BootstrapState state) is the third + bootstrapping entry point and let the client define the specific Bean Validation + provider requested as well as a custom ValidationProviderResolver implementation if + needed</text> + </assertion> + <assertion id="d"> + <text>The Validation implementation provided by the Bean Validation provider must not + contain any non private attribute or method aside from the three public static + bootstrap methods</text> + </assertion> + <assertion id="e"> + <text>The bootstrap implementation must ensure it can bootstrap third party + providers</text> + </assertion> + <assertion id="f"> + <text>When building the Configuration object, if the ValidationProviderResolver fails or + if the expected provider is not found, a ValidationException is raised</text> + </assertion> + </section> + <section id="4.4.6" title="XML Configuration"> + <assertion id="a"> + <text>Unless explicitly ignored Configuration takes into account the configuration + available in META-INF/validation.xml</text> + </assertion> + <assertion id="b" implied="true"> + <text>META-INF/validation.xml will be ignored if Configuration.ignoreXMLConfiguration() + is called.</text> + </assertion> + <assertion id="c"> + <text>This configuration file is optional.</text> + </assertion> + <assertion id="d" testable="false"> + <text>If more than one META-INF/validation.xml file is found in the classpath, a + ValidationException is raised. </text> + </assertion> + <assertion id="e"> + <text>Unless stated otherwise, XML based configuration settings are overridden by values + explicitly set via the Configuration API</text> + </assertion> + <assertion id="f"> + <text>default-provider represents the class name of the provider specific Configuration + sub-interface. If defined, the provider suitable for this interface is used</text> + </assertion> + <assertion id="g"> + <text>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.</text> + </assertion> + <assertion id="h"> + <text>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.</text> + </assertion> + <assertion id="i"> + <text>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.</text> + </assertion> + <assertion id="j"> + <text>message-interpolator, traversable-resolver and constraint-validator-factory are + optional.</text> + </assertion> + <assertion id="k"> + <text>constraint-mapping represents the resource path of an XML mapping file</text> + </assertion> + <assertion id="l"> + <text>More than one constraint-mapping element can be present</text> + </assertion> + <assertion id="m"> + <text>Mappings provided via Configuration.addMapping(InputStream) are added to the list + of mappings described via constraint-mapping</text> + </assertion> + <assertion id="n" testable="false"> + <text>The namespace javax.validation for properties is reserved for use by this + specification</text> + </assertion> + <assertion id="o" testable="false"> + <text>Properties defined via Configuration.addProperty(String, String) are added to the + properties defined via property</text> + </assertion> + <assertion id="p" testable="false"> + <text>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</text> + </assertion> + <assertion id="q"> + <text>If a public no-arg constructor is missing, a ValidationException is raised during + the Configuration.buildValidatorFactory() call</text> + </assertion> + </section> + <section id="4.4.7" title="Usage"> + <assertion id="a" testable="false"> + <text>ValidatorFactory is a thread-safe object that should be built once per deployment + unit</text> + </assertion> + <assertion id="b" testable="false"> + <text>Validator is thread-safe too and should be considered a lightweight object</text> + </assertion> + </section> + + <section id="5" title="Constraint metadata request APIs"/> + <section id="5.1" title="Validator"> + <assertion id="a"> + <text>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</text> + </assertion> + <assertion id="b"> + <text>Validator.getConstraintsForClass returns a BeanDescriptor object describing the + bean level constraints and providing access to the property level constraints + metadata. </text> + </assertion> + <assertion id="c"> + <text>Validator.getConstraintsForClass throws an IllegalArgumentException if the clazz + parameter is null</text> + </assertion> + </section> + <section id="5.2" title="PropertyDescriptor"> + <assertion id="a"> + <text>getElementClass returns either the object type for a class, or the returned type + for a property</text> + </assertion> + <assertion id="b"> + <text>getConstraintDescriptors returns all the ConstraintDescriptors hosted on the given + element in the class hierarchy, each ConstraintDescriptor describing one of the + constraints declared on the given element.</text> + </assertion> + <assertion id="c"> + <text>hasConstraints returns true if the given element (class, field or property) in the + class hierarchy holds at least one constraint declaration.</text> + </assertion> + <assertion id="d"> + <text>unorderedAndMatchingGroups restricts to the ConstraintDescriptors matching the set + of groups passed as parameters and present on the element. Order is not respected + but group inheritance and inheritance via sequence (including the Default group + overriding at the class level) are honored.</text> + </assertion> + <assertion id="e"> + <text>declaredOn lets you restrict the list of element types constraints are hosted + on.</text> + </assertion> + <assertion id="f"> + <text>lookingAt lets you restrict which constraints are considered. Either constraints + belonging to the element but hosted on the class represented by BeanDescritptor + (Scope.LOCAL_ELEMENT), or constraints belonging to the element but hosted anywhere + in the class hierarchy (Scope.HIERARCHY).</text> + </assertion> + </section> + <section id="5.3" title="BeanDescriptor"> + <assertion id="a"> + <text>isBeanConstrained returns true if the given class (and superclasses and + interfaces) host at least one validation declaration (either constraint or @Valid + annotation)</text> + </assertion> + <assertion id="b"> + <text>getConstraintsForProperty returns a PropertyDescriptor object describing the + property level constraints (See Section 3.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</text> + </assertion> + <assertion id="c"> + <text>getConstraintsForProperty throws an IllegalArgumentException if the propertyName + parameter is null</text> + </assertion> + </section> + <section id="5.4" title="PropertyDescriptor"> + <assertion id="a"> + <text>The isCascaded method returns true if the property is marked with @Valid</text> + </assertion> + <assertion id="b"> + <text>getPropertyName returns the property name</text> + </assertion> + </section> + <section id="5.5" title="ConstraintDescriptor"> + <assertion id="a"> + <text>If ConstraintDescriptor represents a composing annotation (see Section 2.3), the + returned annotation must reflect parameter overriding</text> + </assertion> + <assertion id="b"> + <text>getAttributes returns a map containing the annotation attribute names as a key, + and the annotation attribute values as a value</text> + </assertion> + <assertion id="c"> + <text>If ConstraintDescriptor represents a composing annotation (see Section 2.3), the + returned Map must reflect attribute overriding</text> + </assertion> + <assertion id="d"> + <text>getGroups returns the groups the constraint is supposed to be applied upon</text> + </assertion> + <assertion id="e"> + <text>If no group is set on the constraint declaration, the Default group is + returned</text> + </assertion> + <assertion id="f"> + <text>The groups of a composing constraint are the groups of the composed + constraint</text> + </assertion> + <assertion id="g"> + <text>getPayload returns the payloads the constraint hosts or an empty set if + none</text> + </assertion> + <assertion id="h"> + <text>Likewise, payload from the main constraint annotation is inherited by the + composing annotations.</text> + </assertion> + <assertion id="i"> + <text>Any payload definition on a composing annotation is ignored</text> + </assertion> + <assertion id="k"> + <text>isReportAsSingleViolation() returns true if the constraint is annotated with + @ReportAsSingleViolation </text> + </assertion> + <assertion id="l"> + <text>getComposingConstraints return a set of composing ConstraintDescriptors where each + descriptor describes a composing constraint.</text> + </assertion> + </section> + + <section id="6" title="Built-in Constraint definitions"> + <assertion id="a"> + <text>Each Bean Validation provider must recognize built-in constraint annotations as + valid constraint definitions and provide compliant constraint implementations for + each</text> + </assertion> + <assertion id="b"> + <text>The built-in constraint validation implementation is having a lower priority than + an XML mapping definition</text> + </assertion> + <assertion id="c"> + <text>@Null constraint</text> + </assertion> + <assertion id="d"> + <text>@NotNull constraint</text> + </assertion> + <assertion id="e"> + <text>@AssertTrue constraint</text> + </assertion> + <assertion id="f"> + <text>@AssertFalse constraint</text> + </assertion> + <assertion id="g"> + <text>@Min constraint</text> + </assertion> + <assertion id="h"> + <text>@Max constraint</text> + </assertion> + <assertion id="i"> + <text>@DecimalMin constraint</text> + </assertion> + <assertion id="j"> + <text>@DecimalMax constraint</text> + </assertion> + <assertion id="k"> + <text>@Size constraint</text> + </assertion> + <assertion id="l"> + <text>@Digits constraint</text> + </assertion> + <assertion id="m"> + <text>@Past constraint</text> + </assertion> + <assertion id="n"> + <text>@Future constraint</text> + </assertion> + <assertion id="o"> + <text>@Pattern constraint</text> + </assertion> + </section> + + <section id="7" title="XML deployment descriptor"> + <assertion id="a" testable="true"> + <text>If the xml configuration file does not validate against the given xsd files a + ValidationException is raised. </text> + </assertion> + </section> + <section id="7.1" title="Constraint definition and declaration"> + <assertion id="a"> + <text>Specifically when exploring metadata, the Bean Validation provider must ensure + that an annotation instance corresponding to the XML declaration is provided via + ConstraintDescriptor.getAnnnotation()</text> + </assertion> + <assertion id="b"> + <text>A given class must not be described more than once amongst all the XML mapping + descriptors</text> + </assertion> + <assertion id="c"> + <text>A given field or getter must not be described more than once on a given class + description</text> + </assertion> + <assertion id="d"> + <text>A given constraint definition must not be overridden more than once amongst all + the XML mapping descriptors</text> + </assertion> + <assertion id="e"> + <text>If any of these rule is violated in a given validation deployment, a + ValidationException is raised during the creation of the ValidatorFactory</text> + </assertion> + </section> + <section id="7.1.1" title="Constraint declaration in XML"> + <assertion id="a"> + <text>If default-package is set, all unqualified class names (including annotations) are + considered part of the package described by default-package.</text> + </assertion> + <assertion id="b"> + <text>A given JavaBean is described by the bean element.</text> + </assertion> + <assertion id="c"> + <text>The name of the class in the bean node is mandatory</text> + </assertion> + <assertion id="d"> + <text>By default, all constraint declarations expressed via annotation are ignored for + classes described in XML</text> + </assertion> + <assertion id="e"> + <text>You can force Bean Validation to consider both annotations and XML constraint + declarations by using ignore-annotation="false" on bean</text> + </assertion> + <assertion id="f"> + <text>If the name of the class does refer to a class not present in in the classpath, a + ValidationException is raised</text> + </assertion> + </section> + <section id="7.1.1.1" title="Class-level overriding"> + <assertion id="a"> + <text>If ignore-annotations is declared, Bean Validation must honor the explicit value + for this element</text> + </assertion> + <assertion id="b"> + <text>If not declared, the default value defined in the encapsulating bean element is + considered</text> + </assertion> + <assertion id="c"> + <text>When ignore-annotations is true, class-level Bean Validation annotations are + ignored for this class</text> + </assertion> + <assertion id="d"> + <text>When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of class-level declared + constraints</text> + </assertion> + <assertion id="e"> + <text>@GroupSequence is considered unless group-sequence element is explicitly + used</text> + </assertion> + </section> + <section id="7.1.1.2" title="Field-level overriding"> + <assertion id="a"> + <text>If ignore-annotations is declared, Bean Validation must honor the explicit value + for this element</text> + </assertion> + <assertion id="b"> + <text>If not declared, the default value defined in the encapsulating bean element is + considered</text> + </assertion> + <assertion id="c"> + <text>When ignore-annotations is true, field-level Bean Validation annotations on the + targeted field are ignored</text> + </assertion> + <assertion id="d"> + <text>When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of field-level declared + constraints</text> + </assertion> + <assertion id="e"> + <text>The only way to disable cascading on a field marked as @Valid is to use + ignore-annotations=true</text> + </assertion> + <assertion id="f"> + <text>If the name of the field does not correspond to a field in the given bean a + ValidationException is raised</text> + </assertion> + </section> + <section id="7.1.1.3" title="Property-level overriding"> + <assertion id="a"> + <text>The name attribute correspond to the name of the property considered as defined in + Section 3.1.2. If ignore-annotations is declared, Bean Validation must honor the + explicit value for this element</text> + </assertion> + <assertion id="b"> + <text>If not declared, the default value defined in the encapsulating bean element is + considered</text> + </assertion> + <assertion id="c"> + <text>When ignore-annotations is true, property-level Bean Validation annotations on the + targeted property are ignored (including the @Valid)</text> + </assertion> + <assertion id="d"> + <text>When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of property-level declared + constraints.</text> + </assertion> + <assertion id="e"> + <text>The only way to disable cascading on a property marked as @Valid is to use + ignore-annotations=true</text> + </assertion> + <assertion id="f"> + <text>If the name of the property does not correspond to a property in the given bean a + ValidationException is raised</text> + </assertion> + </section> + <section id="7.1.1.4" title="Constraint declaration"> + <assertion id="a"> + <text>The name attribute is mandatory and represents the name of the element in the + constraint declaration</text> + </assertion> + <assertion id="b"> + <text>"message" or "groups" are not permitted names, use the message or groups elements + instead. Otherwise a ValidationException is raised</text> + </assertion> + <assertion id="c"> + <text>If the element represents a primitive type, a class or an enum, the string + representation of its value is placed in the element itself</text> + </assertion> + <assertion id="d"> + <text>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 element placed under the + element itself</text> + </assertion> + <assertion id="e"> + <text>If the element represents an annotation, the annotation element is used to + represent the annotation and placed under element</text> + </assertion> + <assertion id="f"> + <text>If the element represents an array of annotations, one or more annotation elements + are placed under element</text> + </assertion> + <assertion id="g"> + <text>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</text> + </assertion> + <assertion id="h"> + <text>If an XML constraint declaration is missing mandatory elements, or if it contains + elements not part of the constraint definition, a ValidationException is + raised</text> + </assertion> + </section> + <section id="7.1.2" title="Overriding constraint definitions in XML"> + <assertion id="a"> + <text>A constraint definition is represented by a constraint-definition element</text> + </assertion> + <assertion id="b"> + <text>If include-existing-validator is set to false, ConstraintValidator defined on the + constraint annotation are ignored</text> + </assertion> + <assertion id="c"> + <text>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</text> + </assertion> + <assertion id="d"> + <text>Annotation based ConstraintValidator come before XML based ConstraintValidator in + the array</text> + </assertion> + <assertion id="e"> + <text>The validator list is returned by + ConstraintDescriptor.getConstraintValidatorClasses()</text> + </assertion> + </section> + <section id="8" title="Exception model"> + <assertion id="a"> + <text>Every (runtime) exception raised either at initialization time or execution time + by any of the extension interfaces (ConstraintValidator, ConstraintValidatorFactory, + MessageInterpolator, TraversableResolver, ValidationProviderResolver) is wrapped in + a ValidationException</text> + </assertion> + </section> + <section id="8.2" title="ConstraintDefinitionException"> + <assertion id="a"> + <text>If a constraint definition does not respect the Bean Validation rules or is + inconsistent, a ConstraintDefinitionException is raised.</text> + </assertion> + </section> + <section id="8.3" title="ConstraintDeclarationException and UnexpectedTypeException"> + <assertion id="a" testable="false"> + <text>When a constraint declaration is illegal, ConstraintDeclarationException is + raised</text> + </assertion> + <assertion id="b"> + <text>When the return type of a property cannot be processed for a given constraint, an + UnexpectedTypeException is raised</text> + </assertion> + </section> + <section id="8.4" title="GroupDefinitionException"> + <assertion id="a"> + <text>When a group definition is illegal, GroupDefinitionException is raised</text> + </assertion> + </section> +</specification> Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +1c8d9fc1c3229bda57776d2d2d41e931 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-audit.xml.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +4e4e5adee8ba941223159967ebd8d12195f1d17a \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1,2858 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" +"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> +<html> +<head><title>JSR-299 TCK Coverage Report</title> +<style type="text/css"> + body { + font-family: verdana, arial, sans-serif; + font-size: 11px; } + .code { + float: left; + font-weight: bold; + width: 50px; + margin-top: 0px; + height: 100%; } + a.external, a.external:visited, a.external:hover { + color: #0000ff; + font-size: 9px; + font-style: normal; + padding-left: 2px; + margin-left: 6px; + margin-right: 6px; + padding-right: 2px; } + .results { + margin-left: 50px; } + .description { + margin-top: 2px; + margin-bottom: 2px; } + .sectionHeader { + border-bottom: 1px solid #cccccc; + margin-top: 8px; + font-weight: bold; } + .packageName { + color: #999999; + font-size: 9px; + font-weight: bold; } + .embeddedImage { + margin: 6px; + border: 1px solid black; + float: right; } + .coverage { + clear: both; } + .noCoverage { + margin-top: 2px; + margin-bottom: 2px; + font-weight: bold; + font-style: italic; + color: #ff0000; } + .coverageHeader { + font-weight: bold; + text-decoration: underline; + margin-top: 2px; + margin-bottom: 2px; } + .coverageMethod { + font-style: italic; } + .highlight { + background-color: #ffff00; } + .literal { + font-family: courier new; } + .implied { + color: #fff; + font-weight: bold; + background-color: #000; } + .pass { + border-top: 1px solid #488c41; + border-bottom: 1px solid #488c41; + padding-bottom: 1px; + margin-bottom: 2px; + min-height: 36px; + background-color: #ddffdd; } + .fail { + border-top: 1px solid #ab2020; + border-bottom: 1px solid #ab2020; + padding-bottom: 1px; + margin-bottom: 2px; + min-height: 36px; + background-color: #ffdddd; } + .skip { + border-top: 1px solid #ff9900; + border-bottom: 1px solid #ff9900; + padding-bottom: 1px; + margin-bottom: 2px; + min-height: 36px; + background-color: #ffcc33; } + .untestable { + padding-bottom: 16px; + margin-bottom: 2px; + border-top: 1px solid #317ba6; + border-bottom: 1px solid #317ba6; + min-height: 36px; + background-color: #80d1ff; } + .stickynote { + background: url(images/stickynote.png) left top no-repeat; + position: absolute; + left: 16px; + width: 30px; + height: 30px; + margin-top:16px; } +</style> +</head><body><h1>JSR-299 TCK Coverage</h1><h2>Revised Public Review Draft</h2> +<h3>Contents</h3><div><a href="#chapterSummary">Chapter Summary</a></div><div><a href="#sectionSummary">Section Summary</a></div><div><a href="#coverageDetail">Coverage Detail</a></div><div><a href="#unmatched">Unmatched Tests</a></div><h3 id="chapterSummary">Chapter Summary</h3> +<table width="100%"><tr style="background-color:#dddddd"><th align="left">Chapter</th><th>Assertions</th><th>Testable</th><th>Total Tested</th><th>Tested<br /> (unimplemented)</th><th>Tested<br /> (implemented)</th><th>Coverage %</th></tr><tr style="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#2">2 Constraint Definition</a></td><td align="center">51</td><td align="center">44</td><td align="center">44</td><td align="center">0</td><td align="center">44</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#3">3 Constraint declaration and validation process</a></td><td align="center">69</td><td align="center">59</td><td align="center">59</td><td align="center">0</td><td align="center">59</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#4">4 Validation APIs</a></td><td align="center">87</td><td align! ="center">71</td><td align="center">71</td><td align="center">0</td><td align="center">71</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#5">5 Constraint metadata request APIs</a></td><td align="center">25</td><td align="center">25</td><td align="center">25</td><td align="center">0</td><td align="center">25</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#6">6 Built-in Constraint definitions</a></td><td align="center">15</td><td align="center">15</td><td align="center">15</td><td align="center">0</td><td align="center">15</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#7">7 XML deployment descriptor</a></td><td align="center">42</td><td align="center">42</td><td align="center">42</td><td align="center">0</td><td align="center">42</td><td alig! n="center" style="background-color:#aaffaa">100.00%</td></tr><! tr style ="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#8">8 Exception model</a></td><td align="center">5</td><td align="center">4</td><td align="center">4</td><td align="center">0</td><td align="center">4</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="font-weight: bold;background-color:#dddddd"><td>Total</td><td align="center">294</td><td align="center">260</td><td align="center">260</td><td align="center">0</td><td align="center">260</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr></table><h3 id="sectionSummary">Section Summary</h3> +<table width="100%"><tr style="background-color:#dddddd"><th align="left">Section</th><th>Assertions</th><th>Testable</th><th>Total Tested</th><th>Tested<br /> (unimplemented)</th><th>Tested<br /> (implemented)</th><th>Coverage %</th></tr><tr style="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#2">2 Constraint Definition</a></td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr><td style="padding-left:16px"><a href="#2.1">2.1 Constraint Annotation</a></td><td align="center">4</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#2.1.1">2.1.1 Constraint definition properties</a></td><td align="center">10</td><td align="center">10</td><td align="center">10</td><td align="cente! r">0</td><td align="center">10</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#2.2">2.2 Applying multiple constraints of the same type</a></td><td align="center">1</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#2.3">2.3 Constraint composition</a></td><td align="center">16</td><td align="center">16</td><td align="center">16</td><td align="center">0</td><td align="center">16</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#2.4">2.4 Constraint validation implementation</a></td><td align="center">17</td><td align="center">12</td><td align="center">12</td><td align="center">0</td><td align="center">12</td><td align="center" style="background-col! or:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7! f7"><td style="padding-left:16px"><a href="#2.5">2.5 The ConstraintValidatorFactory</a></td><td align="center">3</td><td align="center">3</td><td align="center">3</td><td align="center">0</td><td align="center">3</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#3">3 Constraint declaration and validation process</a></td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#3.1">3.1 Requirements on classes to be validated</a></td><td align="center">4</td><td align="center">3</td><td align="center">3</td><td align="center">0</td><td align="center">3</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#3.1.1">3.1.1 Object validation</a></td><td align="center">1</td><td align="center">1</td><td align="c! enter">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.1.2">3.1.2 Field and property validation</a></td><td align="center">6</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#3.1.3">3.1.3 Graph validation</a></td><td align="center">11</td><td align="center">11</td><td align="center">11</td><td align="center">0</td><td align="center">11</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#3.3">3.3 Inheritance</a></td><td align="center">2</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" styl! e="background-color:#aaffaa">100.00%</td></tr><tr><td style="p! adding-l eft:16px"><a href="#3.4">3.4 Group and group sequence</a></td><td align="center">4</td><td align="center">4</td><td align="center">4</td><td align="center">0</td><td align="center">4</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.4.1">3.4.1 Group inheritance</a></td><td align="center">2</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#3.4.2">3.4.2 Group sequence </a></td><td align="center">10</td><td align="center">7</td><td align="center">7</td><td align="center">0</td><td align="center">7</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.4.3">3.4.3 Redefining the Default group for a class</a></td><td alig! n="center">4</td><td align="center">3</td><td align="center">3</td><td align="center">0</td><td align="center">3</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#3.4.4">3.4.4 Implicit grouping</a></td><td align="center">1</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.4.5">3.4.5 Formal group definitions</a></td><td align="center">2</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#3.5">3.5 Validation routine</a></td><td align="center">3</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td! align="center" style="background-color:#aaffaa">100.00%</td><! /tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.5.1">3.5.1 Object graph validation </a></td><td align="center">5</td><td align="center">5</td><td align="center">5</td><td align="center">0</td><td align="center">5</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#3.5.2">3.5.2 Traversable property</a></td><td align="center">8</td><td align="center">5</td><td align="center">5</td><td align="center">0</td><td align="center">5</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#3.5.3">3.5.3 ConstraintValidator resolution algorithm</a></td><td align="center">6</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#4">4 Validation APIs! </a></td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#4.1">4.1 Validator API </a></td><td align="center">1</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr><td style="padding-left:32px"><a href="#4.1.1">4.1.1 Validation methods</a></td><td align="center">11</td><td align="center">11</td><td align="center">11</td><td align="center">0</td><td align="center">11</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#4.1.2">4.1.2 groups</a></td><td align="center">3</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="pa! dding-left:16px"><a href="#4.2">4.2 ConstraintViolation</a></t! d><td al ign="center">14</td><td align="center">13</td><td align="center">13</td><td align="center">0</td><td align="center">13</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#4.3.1">4.3.1 Default message interpolation</a></td><td align="center">8</td><td align="center">8</td><td align="center">8</td><td align="center">0</td><td align="center">8</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:48px"><a href="#4.3.1.1">4.3.1.1 Default message interpolation algorithm</a></td><td align="center">8</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#4.3.2">4.3.2 Custom message interpolation</a></td><td align="center">2</td><td align="center">1! </td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#4.4">4.4 Bootstrapping</a></td><td align="center">1</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#4.4.1">4.4.1 Examples</a></td><td align="center">1</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr><td style="padding-left:32px"><a href="#4.4.2">4.4.2 ValidatorFactory</a></td><td align="center">2</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="pad! ding-left:32px"><a href="#4.4.3">4.4.3 Configuration</a></td><! td align ="center">3</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:48px"><a href="#4.4.4.1">4.4.4.1 ValidationProviderResolver</a></td><td align="center">3</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:48px"><a href="#4.4.4.2">4.4.4.2 ValidationProvider</a></td><td align="center">5</td><td align="center">5</td><td align="center">5</td><td align="center">0</td><td align="center">5</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#4.4.5">4.4.5 Validation</a></td><td align="center">6</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</t! d><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#4.4.6">4.4.6 XML Configuration</a></td><td align="center">17</td><td align="center">13</td><td align="center">13</td><td align="center">0</td><td align="center">13</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:32px"><a href="#4.4.7">4.4.7 Usage</a></td><td align="center">2</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr style="background-color:#f7f7f7"><td style="padding-left:0px"><a href="#5">5 Constraint metadata request APIs</a></td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td align="center">0</td><td /></tr><tr><td style="padding-left:16px"><a href="#5.1">5.1 Validator</a></td><td align="center">3</td><td align="center">3</td><td align="center! ">3</td><td align="center">0</td><td align="center">3</td><td ! align="c enter" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#5.2">5.2 PropertyDescriptor</a></td><td align="center">6</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#5.3">5.3 BeanDescriptor</a></td><td align="center">3</td><td align="center">3</td><td align="center">3</td><td align="center">0</td><td align="center">3</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#5.4">5.4 PropertyDescriptor</a></td><td align="center">2</td><td align="center">2</td><td align="center">2</td><td align="center">0</td><td align="center">2</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#5.5"! align="center">5</td><td align="center">5</td><td align="cente! r">0</td <tr style="background-color:#f7f7f7"><td style="padding-left:48px"><a href="#7.1.1.3">7.1.1.3 Property-level overriding</a></td><td align="center">6</td><td align="center">6</td><td align="center">6</td><td align="center">0</td><td align="center">6</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:48px"><a href="#7.1.1.4">7.1.1.4 Constraint declaration</a></td><td align="center">8</td><td align="center">8</td><td align="center">8</td><td align="center">0</td><td align="center">8</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:32px"><a href="#7.1.2">7.1.2 Overriding constraint definitions in XML</a></td><td align="center">5</td><td align="center">5</td><td align="center">5</td><td align="center">0</td><td align="center">5</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:0px"><a href="#8">8! Exception model</a></td><td align="center">1</td><td align="c! enter">1 </td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#8.2">8.2 ConstraintDefinitionException</a></td><td align="center">1</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr><td style="padding-left:16px"><a href="#8.3">8.3 ConstraintDeclarationException and UnexpectedTypeException</a></td><td align="center">2</td><td align="center">1</td><td align="center">1</td><td align="center">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr><tr style="background-color:#f7f7f7"><td style="padding-left:16px"><a href="#8.4">8.4 GroupDefinitionException</a></td><td align="center">1</td><td align="center">1</td><td align="center">1</td><td align="cen! ter">0</td><td align="center">1</td><td align="center" style="background-color:#aaffaa">100.00%</td></tr></table><h3 id="coverageDetail">Coverage Detail</h3> +<table><tr><th style="background-color:#dddddd">Colour Key</th></tr><tr><td style="background-color:#ddffdd;text-align:center">Assertion is covered</td></tr><tr><td style="background-color:#ffdddd;text-align:center">Assertion is not covered</td></tr><tr><td style="background-color:#ffcc33;text-align:center">Assertion test is unimplemented</td></tr><tr><td style="background-color:#80d1ff;text-align:center">Assertion is untestable</td></tr></table><div style="visibility:hidden" id="2"></div> +<h4 class="sectionHeader" id="2.1">Section 2.1 - Constraint Annotation</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">An annotation is considered a constraint definition if its retention policy + contains RUNTIME and if the annotation itself is annotated with + javax.validation.Constraint</p> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">Constraint annotations can target any of the following ElementTypes: FIELD, + METHOD, TYPE, ANNOTATION_TYPE</p> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">If a constraint definition is not valid, a ConstraintDefinitionException is raised + either at validation time or when the metadata is requested</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Applying a constraint annotation to an incompatible type will raise a + UnexpectedTypeException</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()</div> + </div> +</div></div><h4 class="sectionHeader" id="2.1.1">Section 2.1.1 - Constraint definition properties</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A constraint definition may have attributes that are specified at the time the + constraint is applied to a JavaBean.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintdefinition </div> + <div class="coverageMethod">ConstraintDefinitionsTest.testConstraintWithCustomAttributes()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Annotation elements starting with valid are not allowed</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Every constraint annotation must define a message element of type String</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Every constraint annotation must define a groups element that specifies which + processing groups the constraint definition is associated with.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The default value for the groups element must be an empty array.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If no group is specified when declaring the constraint on an element, the Default + group is considered declared.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintdefinition </div> + <div class="coverageMethod">ConstraintDefinitionsTest.testDefaultGroupAssumedWhenNoGroupsSpecified()</div> + </div> +</div></div> <div class="pass"> +<span class="implied">The following assertion is not made explicitly by the spec, however it is implied</span> <span class="code">g)</span> + <div class="results"><p class="description">The type of the groups parameter is Class&lt;?&gt;[].</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">Every constraint annotation must define a payload element that specifies which + payload the constraint declaration is associated with. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">The default value for the payload parameter must be an empty array. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">Each attachable payload extends Payload. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()</div> + </div> +</div></div><h4 class="sectionHeader" id="2.2">Section 2.2 - Applying multiple constraints of the same type</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintdefinition </div> + <div class="coverageMethod">ConstraintDefinitionsTest.testConstraintWithCustomAttributes()</div> + </div> +</div></div><h4 class="sectionHeader" id="2.3">Section 2.3 - Constraint composition</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Each constraint annotation hosted on a constraint annotation is applied to the + target element and this recursively</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testComposedConstraints()</div> + <div class="coverageMethod">ConstraintCompositionTest.testComposedConstraintsAreRecursive()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Note that the main annotation and its constraint validation implementation is also + applied</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testValidationOfMainAnnotationIsAlsoApplied()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">By default, each failing constraint generates an error report</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Groups from the main constraint annotation are inherited by the composing + annotations</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testGroupsDefinedOnMainAnnotationAreInherited()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">Any groups definition on a composing annotation is ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testGroupsDefinedOnMainAnnotationAreInherited()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">The property type a composed constraint is placed on must be compatible with all + constraints (composing and composed)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testAllComposingConstraintsMustBeApplicableToAnnotatedType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description"> If a composed constraint is marked as @ReportAsSingleViolation, and if any of its + composing constraint reports one or more violations, all reports from composing + constraints are ignored and the error report corresponding to the composed + constraint is generated</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testOnlySingleConstraintViolation()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition.nestedconstraintcomposition </div> + <div class="coverageMethod">NestedConstraintCompositionTest.testCompositeConstraint1WithNestedConstraintSingleViolation()</div> + <div class="coverageMethod">NestedConstraintCompositionTest.testCompositeConstraint2WithNestedConstraintSingleViolation()</div> + <div class="coverageMethod">NestedConstraintCompositionTest.testCompositeConstraint3WithNestedConstraint()</div> + <div class="coverageMethod">NestedConstraintCompositionTest.testCompositeConstraint4WithNestedConstraintSingleViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">Composing annotations can define the value of message and custom attributes + (excluding groups) but these are fixed in the composed constraint definition</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testAttributesDefinedOnComposingConstraints()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description"> The types of the overridden and overriding attributes must be identical</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testOverriddenAttributesMustMatchInType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">A composing constraint can itself be a composed constraint. In this case, + attribute values are overridden recursively according to the described rules</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testComposedConstraints()</div> + <div class="coverageMethod">ConstraintCompositionTest.testComposedConstraintsAreRecursive()</div> + </div> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">If a constraint is used more than once as a composing constraint, the multi value + constraints model as described in Section 2.2 is used</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">m)</span> + <div class="results"><p class="description">To select the appropriate composing constraint targeted, OverridesAttrib- + ute.constraintIndex is used. It represents the constraint index in the value + array</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">n)</span> + <div class="results"><p class="description">If index is undefined, the single constraint declaration is targeted</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testEachFailingConstraintCreatesConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">o)</span> + <div class="results"><p class="description">If the composition is invalid (infinite composition, wrong attribute overriding, a + single attribute mapped to more than one source attribute etc), a + ConstraintDefinitionException is raised either at validation time or when the + metadata is requested</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testOverriddenAttributesMustMatchInType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">p)</span> + <div class="results"><p class="description">Any payload definition on a composing annotation is ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testPayloadPropagationInComposedConstraints()</div> + </div> +</div></div><h4 class="sectionHeader" id="2.4">Section 2.4 - Constraint validation implementation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A constraint validation implementation performs the validation of a given + constraint annotation for a given type</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()</div> + <div class="coverageMethod">CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">The implementation classes are specified by the validatedBy element of the + @Contraint annotation that decorates the constraint definition</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()</div> + <div class="coverageMethod">CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">c)</span> + <div class="results"><p class="description">The constraint validation implementation implements the ConstraintValidator + interface</p> +</div></div> <div class="untestable"> + <span class="code">d)</span> + <div class="results"><p class="description">T must resolve in a non parameterized type or generic parameters of T must be + unbounded wildcard types</p> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The initialize method is called by the Bean validation provider prior to any use + of the constraint implementation.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRightValidatorIsSelectedAndInitializedCalled()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">The isValid method is evaluated by the Bean Validation provider each time a given + value is validated</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testIsValidIsCalledForEachValidation()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">g)</span> + <div class="results"><p class="description">It returns false if the value is not valid, true otherwise</p> +</div></div> <div class="untestable"> + <span class="code">h)</span> + <div class="results"><p class="description">isValid implementations must be thread-safe</p> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">If the property is of an unanticipated type, an UnexpectedTypeException is + raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testUnexpectedTypeExceptionIsRaisedForInvalidType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">If an exception occurs either in the initialize or isValid method, the runtime + exception is wrapped into a ValidationException by the Bean Validation engine + </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRuntimeExceptionFromIsValidIsWrapped()</div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRuntimeExceptionFromInitializeIsWrapped()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">k)</span> + <div class="results"><p class="description">The constraint validation implementation is not allowed to change the state of the + value passed to isValid. </p> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">By default, each invalid constraint leads to the generation of one error object + represented by a ConstraintViolation object. This object is build from the default + error message as defined by the constraint declaration and the context in which the + constraint declaration is placed on (bean, property, attribute)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testOneConstraintViolationPerFailingConstraint()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.validatorcontext </div> + <div class="coverageMethod">ConstraintValidatorContextTest.testDefaultError()</div> + </div> +</div></div> <div class="pass"> + <span class="code">m)</span> + <div class="results"><p class="description">The ConstraintValidatorContext methods let the constraint implementation disable + the default error object generation and create one or more custom ones</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.constraintcomposition </div> + <div class="coverageMethod">ConstraintCompositionTest.testValidationOfMainAnnotationIsAlsoApplied()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.validatorcontext </div> + <div class="coverageMethod">ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorNoSubNode()</div> + <div class="coverageMethod">ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorWithSubNode()</div> + <div class="coverageMethod">ConstraintValidatorContextTest.propertyPathInIterable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">n)</span> + <div class="results"><p class="description">The non-interpolated message passed as a parameter is used to build the + ConstraintViolation object (the message interpolation operation is applied to + it)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testNonInterpolatedMessageParameterIsUsed()</div> + </div> +</div></div> <div class="pass"> + <span class="code">o)</span> + <div class="results"><p class="description">By default, the propertyPath exposed on the ConstraintViolation represents the + path to the bean or property hosting the constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testGraphValidationWithList()</div> + <div class="coverageMethod">ValidateTest.testGraphValidationWithArray()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.customconstraint </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testDefaultPropertyPath()</div> + </div> +</div></div> <div class="pass"> + <span class="code">q)</span> + <div class="results"><p class="description">You can point an error to a subpath of this default path by using the error + builder fluent API.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.validatorcontext </div> + <div class="coverageMethod">ConstraintValidatorContextTest.testDisableDefaultErrorWithCustomErrorWithSubNode()</div> + <div class="coverageMethod">ConstraintValidatorContextTest.propertyPathInIterable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">r)</span> + <div class="results"><p class="description">If disableDefaultError is called, no custom error is added (using the error + builder) and if the constraint is not valid, a ValidationException is raised.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.validatorcontext </div> + <div class="coverageMethod">ConstraintValidatorContextTest.testDisableDefaultErrorWithoutAddingCustomError()</div> + </div> +</div></div><h4 class="sectionHeader" id="2.5">Section 2.5 - The ConstraintValidatorFactory</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The default ConstraintValidatorFactory provided by the Bean Validation provider + implementation uses the public constraint no-arg constructor</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validatorfactory </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testDefaultConstructorInValidatorCalled()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If an exception occurs in the factory while retrieving the ConstraintValidator + instance, the runtime exception is wrapped in a ValidationException</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validatorfactory </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testRuntimeExceptionInValidatorCreationIsWrapped()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">If the instance returned by the factory is null, a ValidationException is + raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validatorfactory </div> + <div class="coverageMethod">CustomConstraintValidatorTest.testValidationExceptionIsThrownInCaseFactoryReturnsNull()</div> + </div> +</div></div><div style="visibility:hidden" id="3"></div> +<h4 class="sectionHeader" id="3.1">Section 3.1 - Requirements on classes to be validated</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Properties to be validated must follow the method signature conventions for + JavaBeans read properties, as defined by the JavaBeans specification</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testValidatedPropertyDoesNotFollowJavaBeansConvention()</div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">Static fields and static methods are excluded from validation</p> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Constraints can be applied to interfaces and superclasses</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testClassLevelConstraints()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">The target of an annotation definition can be a field, property, or type, provided + that the constraint definition supports the specified target and the constraint + supports the declared type of the target. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testClassLevelConstraints()</div> + <div class="coverageMethod">ValidationRequirementTest.testFieldAccess()</div> + <div class="coverageMethod">ValidationRequirementTest.testPropertyAccess()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.1.1">Section 3.1.1 - Object validation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Constraint declarations can be applied to a class or an interface</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testClassLevelConstraints()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.1.2">Section 3.1.2 - Field and property validation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Constraint declarations can be applied on both fields and properties for the same + object type</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testFieldAccess()</div> + <div class="coverageMethod">ValidationRequirementTest.testPropertyAccess()</div> + <div class="coverageMethod">ValidationRequirementTest.testConstraintAppliedOnFieldAndProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">The same constraint should however not be duplicated between a field and its + associated property (the constraint validation would be applied twice)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testConstraintAppliedOnFieldAndProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">When a field is annotated with a constraint declaration, field access strategy is + used to access the state validated by such constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testFieldAccess()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">When a property is annotated with a constraint declaration, property access + strategy is used to access the state validated by such constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testPropertyAccess()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The fields or methods visibility are not constrained</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.application </div> + <div class="coverageMethod">ValidationRequirementTest.testFieldAndPropertyVisibilityIsNotConstrained()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">Constraints on non getter methods are not supported</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testValidatedPropertyDoesNotFollowJavaBeansConvention()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.1.3">Section 3.1.3 - Graph validation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testGraphNavigationDeterminism()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description"> 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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testTypeOfContainedValueIsDeterminedAtRuntime()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Array of objects is supported by @Valid. The content of the array is + validated.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testGraphValidationWithArray()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">java.util.Collection is supported by @Valid. The content of the collection is + validated.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testTypeOfContainedValuesIsDeterminedAtRuntime()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">java.util.Set is supported by @Valid. The content of the Set is validated.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testContainedSet()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">java.util.List is supported by @Valid. The content of the list is + validated.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testNoEndlessLoop()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">java.util.Map is supported by @Valid</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testContainedMap()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">java.lang.Iterable is supported by @Valid. The elements of the iterable are + validated</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testContainedIterable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">For Map, the value of each entry is validated (the key is not validated)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testContainedMap()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">Like regular references, the type of the collection, array or Iterable element is + determined at runtime and the constraint definitions for this particular type are + used</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testTypeOfContainedValuesIsDeterminedAtRuntime()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">The @Valid annotation is applied recursively</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testGraphNavigationDeterminism()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.3">Section 3.3 - Inheritance</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A constraint declaration can be placed on an interface</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.inheritance </div> + <div class="coverageMethod">ConstraintInheritanceTest.testConstraintsOnInterfaceAreInherited()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">For a given class, constraint declarations held on superclasses as well as + interfaces are evaluated by the Bean Validation provider</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.inheritance </div> + <div class="coverageMethod">ConstraintInheritanceTest.testConstraintsOnInterfaceAreInherited()</div> + <div class="coverageMethod">ConstraintInheritanceTest.testConstraintsOnSuperClassAreInherited()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4">Section 3.4 - Group and group sequence</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If no group is explicitly declared, a constraint belongs to the Default + group</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testConstraintWithNoExplicitlySpecifiedGroupBelongsToDefault()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Groups are represented by interfaces</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testValidateAgainstDifferentGroups()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">A constraint can belong to one or more groups</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testValidationFailureInMultipleGroups()</div> + <div class="coverageMethod">GroupTest.testConstraintCanBelongToMoreThanOneGroup()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testValidateAgainstDifferentGroups()</div> + <div class="coverageMethod">GroupTest.testGroups()</div> + <div class="coverageMethod">GroupTest.testGroupSequenceFollowedByGroup()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4.1">Section 3.4.1 - Group inheritance</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A group can inherit one or more groups by using interface inheritance</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.inheritance </div> + <div class="coverageMethod">GroupInheritanceTest.testGroupCanInheritGroupsViaInterfaceInheritance()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">For a given interface Z, constraints marked as belonging to the group Z (ie where + the annotation groups property contains the interface Z) or any of the super + interfaces of Z (inherited groups) are considered part of the group Z</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.inheritance </div> + <div class="coverageMethod">GroupInheritanceTest.testGroupMembership()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4.2">Section 3.4.2 - Group sequence </h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">By default, constraints are evaluated in no particular order and this regardless + of which groups they belong to</p> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testFullGraphValidationBeforeNextGroupInSequence()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testGroupSequenceContainerOtherGroupSequences()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">If one of the groups processed in the sequence generates one or more constraint + violation, the groups following in the sequence must not be processed</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testFullGraphValidationBeforeNextGroupInSequence()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">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 + definition or group inheritance</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testCyclicGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If a group containing such a circularity is evaluated, a GroupDefinitionException + is raised.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testCyclicGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">g)</span> + <div class="results"><p class="description">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.</p> +</div></div> <div class="untestable"> + <span class="code">h)</span> + <div class="results"><p class="description">Groups defining a sequence should not be used directly in constraint + declarations</p> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">To define a group as a sequence, the interface must be annotated with the + @GroupSequence annotation</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testCyclicGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">A given constraint can belong to two 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)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testOnlyFirstGroupInSequenceGetEvaluated()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4.3">Section 3.4.3 - Redefining the Default group for a class</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequenceisolation </div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()</div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testRedefiningDefaultGroup()</div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testValidatingAgainstRedefinedDefaultGroup()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">Constraints hosted on a class A and belonging to the Default group (by default or + explicitly) implicitly belong to the group A</p> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">A sequence defined on a class A (ie. redefining the Default groups for the class) + must contain the group A</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testGroupSequenceContainingDefault()</div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testGroupSequenceWithNoImplicitDefaultGroup()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequenceisolation </div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()</div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testGroupSequenceContainingDefault()</div> + <div class="coverageMethod">DefaultGroupRedefinitionTest.testGroupSequenceWithNoImplicitDefaultGroup()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4.4">Section 3.4.4 - Implicit grouping</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Every constraint hosted on an interface Z and part of the Default group + (implicitly or explicitly) belongs to the group Z</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testImplicitGrouping()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.4.5">Section 3.4.5 - Formal group definitions</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If a class does have a @GroupSequence annotation, the group Default contains every + constraint belonging to every group declared by the @GroupSequence + annotation.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequenceisolation </div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance()</div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance2()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If class X has no @GroupSequence annotation, the group Default contains every + constraint in the group X and if X has a direct superclass Y, every constraint in + the group Default of Y this rule</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequenceisolation </div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceInheritance3()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.5">Section 3.5 - Validation routine</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">For a given group to validate, the validation routine applied on a given bean + instance is expected to execute the constraint validations in no particular + order</p> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Note that this implies that a given validation constraint will not be processed + more than once per validation</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testValidationFailureInMultipleGroups()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testOnlyFirstGroupInSequenceGetEvaluated()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">c)</span> + <div class="results"><p class="description">Unless ordered by group sequences, groups can be validated in no particular + order</p> +</div></div><h4 class="sectionHeader" id="3.5.1">Section 3.5.1 - Object graph validation </h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">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)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testGraphNavigationDeterminism()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">This mechanism is recursive</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testGraphNavigationDeterminism()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Null references are ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testNullReferencesGetIgnored()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">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)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation.graphnavigation </div> + <div class="coverageMethod">GraphNavigationTest.testNoEndlessLoop()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">@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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequenceisolation </div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceContainedCaseWithoutGroupRedefinitionOnContainedEntity()</div> + <div class="coverageMethod">GroupSequenceIsolationTest.testCorrectDefaultSequenceContainedCaseWithGroupRedefinitionOnContainedEntity()</div> + </div> +</div></div><h4 class="sectionHeader" id="3.5.2">Section 3.5.2 - Traversable property</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">isReachable is called for every property about to be accessed either for + validation or for cascading</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.traversableresolver </div> + <div class="coverageMethod">TraversableResolverTest.testCorrectNumberOfCallsToIsReachableAndIsCascadable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">isCascadable is called for every property about to be cascaded (ie. marked as + @Valid)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.traversableresolver </div> + <div class="coverageMethod">TraversableResolverTest.testCorrectNumberOfCallsToIsReachableAndIsCascadable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.traversableresolver </div> + <div class="coverageMethod">TraversableResolverTest.testCorrectNumberOfCallsToIsReachableAndIsCascadable()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.traversableresolver </div> + <div class="coverageMethod">TraversableResolverTest.testCustomTraversableResolverViaConfiguration()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If an exception occurs when the TraversableResolver is called, the exception is + wrapped into a ValidationException</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.traversableresolver </div> + <div class="coverageMethod">TraversableResolverTest.testResolverExceptionsGetWrappedInValidationException()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">f)</span> + <div class="results"><p class="description">If Java Persistence is available in the runtime environment, a property is + considered reachable if Java Persistence considers the property as loaded</p> +</div></div> <div class="untestable"> + <span class="code">g)</span> + <div class="results"><p class="description">If Java Persistence is not available in the runtime environment, all properties + are considered reachable</p> +</div></div> <div class="untestable"> + <span class="code">h)</span> + <div class="results"><p class="description">If Java Persistence is not available in the runtime environment, all properties + are considered cascadable</p> +</div></div><h4 class="sectionHeader" id="3.5.3">Section 3.5.3 - ConstraintValidator resolution algorithm</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If the constraint declaration is hosted on a class or an interface, the targeted + type is the class or the interface</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testTargetTypeIsInterface()</div> + <div class="coverageMethod">ValidatorResolutionTest.testTargetTypeIsClass()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If the constraint is hosted on a class attribute, the type of the attribute is the + targeted type</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testTargetedTypeIsField()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">If the constraint is hosted on a getter, the return type of the getter is the + targeted type</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testTargetedTypeIsGetter()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">the ConstraintValidator chosen to validate a declared type T is the one 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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testResolutionOfMultipleSizeValidators()</div> + <div class="coverageMethod">ValidatorResolutionTest.testResolutionOfMinMaxForDifferentTypes()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If no ConstraintValidator compliant with T is found amongst the + ConstraintValidators listed by the constraint A, a UnexpectedTypeException is + raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testUnexpectedTypeInValidatorResolution()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If more than one maximally specific ConstraintValidator is found, a + UnexpectedTypeException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testAmbiguousValidatorResolution()</div> + </div> +</div></div><div style="visibility:hidden" id="4"></div> +<h4 class="sectionHeader" id="4.1">Section 4.1 - Validator API </h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">Validator implementations are thread-safe</p> +</div></div><h4 class="sectionHeader" id="4.1.1">Section 4.1.1 - Validation methods</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">validate(T object, Class... groups) is used to validate a given object</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testMultipleViolationOfTheSameType()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">An IllegalArgumentException is thrown when validateProperty is called and object + is null or null is passed to the varargs groups.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testValidateWithNullValue()</div> + <div class="coverageMethod">ValidateTest.testValidateWithNullGroup()</div> + <div class="coverageMethod">ValidateTest.testPassingNullAsGroup()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">A Set containing all ConstraintViolation objects representing the failing + constraints is returned, an empty Set is returned otherwise</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testValidateProperty()</div> + <div class="coverageMethod">ValidateTest.testMultipleViolationOfTheSameType()</div> + <div class="coverageMethod">ValidateTest.testMultipleConstraintViolationOfDifferentTypes()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">validateProperty(T object, String propertyName, Class... groups) validates a given + field or property of an object</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testValidateProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testValidatePropertyWithInvalidPropertyPath()</div> + <div class="coverageMethod">ValidatePropertyTest.testPassingNullAsGroup()</div> + <div class="coverageMethod">ValidatePropertyTest.testIllegalArgumentExceptionIsThrownForNullValue()</div> + <div class="coverageMethod">ValidatePropertyTest.testValidatePropertyWithNullProperty()</div> + <div class="coverageMethod">ValidatePropertyTest.testValidatePropertyWithEmptyProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">The property name in validateProperty is the JavaBeans property name (as defined + by the JavaBeans Introspector class)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testValidatePropertyWithInvalidPropertyPath()</div> + <div class="coverageMethod">ValidatePropertyTest.testValidateProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">@Valid is not honored by a call to validateProperty.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testValidIsNotHonoredValidateProperty()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">validateValue(Class 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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateValueTest.testValidateValueSuccess()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValueFailure()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateValueTest.testValidateValueWithInvalidPropertyPath()</div> + <div class="coverageMethod">ValidateValueTest.testExistingPropertyWoConstraintsNorCascaded()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValuePassingNullAsGroup()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValueWithEmptyPropertyPath()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValueWithNullObject()</div> + <div class="coverageMethod">ValidateValueTest.testValidateValueWithNullPropertyName()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">@Valid is not honored by validateValue.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateValueTest.testValidIsNotHonoredValidateValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">If some unrecoverable failure happens during validation, a ValidationException is + raised.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidatePropertyTest.testUnexpectedExceptionsInValidatePropertyGetWrappedInValidationExceptions()</div> + <div class="coverageMethod">ValidateTest.testUnexpectedExceptionsInValidateGetWrappedInValidationExceptions()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.1.2">Section 4.1.2 - groups</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">All constraints belonging to the targeted group are applied during the validation + routine.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidate()</div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateProperty()</div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If no group is passed, the Default group is assumed</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidate()</div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateProperty()</div> + <div class="coverageMethod">ValidateWithGroupsTest.testCorrectGroupsAreAppliedForValidateValue()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">c)</span> + <div class="results"><p class="description">When more than one group is evaluated and passed to the various validate methods, + order is not constrained</p> +</div></div><h4 class="sectionHeader" id="4.2">Section 4.2 - ConstraintViolation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The getMessage method returns the interpolated (localized) message for the failing + constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">The getMessageTemplate method returns the non-interpolated error message</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">The getRootBean method returns the root object being validated that led to the + failing constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">The getInvalidValue method returns the value (field, property or validated object) + being passed to isValid</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">getConstraintDescriptor provides access to the failing constraint metadata</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">getPropertyPath returns the Path object representing the navigation path from the + root object to the failing object</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathTraversedObject()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithList()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithArray()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithMap()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathSet()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">If the failing object is the root object, the property path consists of a single + Node with name set to null.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">If failing object is traversed, a Node object whose name equals the name of the + association property (field name or Java Bean property name) is added to Path. + </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathTraversedObject()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">If the traversed association is a List or an array, the added Node object contains + the index value in getIndex. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithList()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithArray()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">If the association is a Map, the added Node object (representing a given map + entry) contains the key value in getKey </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithMap()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">For all Iterable or Map, the added Node object added is marked as inIterable + (isInIterable) </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithList()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithArray()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithMap()</div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathSet()</div> + </div> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">For a property level constraint (field and getter) a Node object is added to Path + whose name equals the name of the property. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathTraversedObject()</div> + </div> +</div></div> <div class="pass"> + <span class="code">m)</span> + <div class="results"><p class="description">For a class level constraint a Node object is added to Path whose name is null + </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">PropertyPathTest.testPropertyPathWithConstraintViolationForRootObject()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">n)</span> + <div class="results"><p class="description">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. </p> +</div></div><h4 class="sectionHeader" id="4.3.1">Section 4.3.1 - Default message interpolation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A conforming implementation includes a default message interpolator</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testDefaultMessageInterpolatorIsNotNull()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Each constraint defines a message descriptor via its message property</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Every constraint definition shall define a default message descriptor for that + constraint.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Messages can be overridden at declaration time in constraints by setting the + property on the constraint.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testMessagesCanBeOverriddenAtConstraintLevel()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The message descriptor is a string literal and may contain one or more message + parameters. Message parameters are string literals enclosed in braces</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">\{ is considered as the literal { instead of being considered as the beginning of + a message parameter</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testLiteralCurlyBraces()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">\} is considered as the literal } instead of being considered as the end of a + message parameter</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testLiteralCurlyBraces()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">\\ is considered as the literal \ instead of being considered as the escaping + character</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testLiteralCurlyBraces()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.3.1.1">Section 4.3.1.1 - Default message interpolation algorithm</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Message parameters are extracted from the message string and used as keys to + search the ResourceBundle named ValidationMessages (step1)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testSuccessfulInterpolationOfValidationMessagesValue()</div> + <div class="coverageMethod">MessageInterpolationTest.testUnSuccessfulInterpolation()</div> + <div class="coverageMethod">MessageInterpolationTest.testUnknownTokenInterpolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Step 1 is applied recursively until no replacement is performed</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testRecursiveMessageInterpolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">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. If a property is found, the message parameter is replaced with the property + value in the message string (step 2)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testParametersAreExtractedFromBeanValidationProviderBundle()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">e)</span> + <div class="results"><p class="description">Contrary to step 1, step 2 is not processed recursively</p> +</div></div> <div class="untestable"> + <span class="code">f)</span> + <div class="results"><p class="description">If step 2 triggers a replacement, then step 1 is applied again</p> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">As last step message parameters are extracted from the message string. Those + matching the name of an attribute of the constraint declaration are replaced by the + value of that attribute.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testConstraintAttributeValuesAreInterpolated()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">If the locale is passed to the interpolator method interpolate(String, + CosntraintDescriptor, Object, Locale), this Locale instance is used</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testMessageInterpolationWithLocale()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">If the locale is not specified, the default Locale as provided by + Locale.getDefault() is used.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.messageinterpolation </div> + <div class="coverageMethod">MessageInterpolationTest.testIfNoLocaleIsSpecifiedTheDefaultLocaleIsAssumed()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.3.2">Section 4.3.2 - Custom message interpolation</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">A message interpolator implementation shall be thread-safe</p> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">It is possible to override the MessageInterpolator implementation for a given + Validator instance by invoking + ValidatorFactory.usingContext().messageInterpolator(messageInterpolator).getValidator()</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()</div> + <div class="coverageMethod">CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaConfiguration()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4">Section 4.4 - Bootstrapping</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A bootstrap implementation must be able to bootstrap any Bean Validation provider + implementation</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap.customprovider </div> + <div class="coverageMethod">BootstrapCustomProviderDefinedInServiceFileTest.testGetFactoryByProviderSpecifiedProgrammatically()</div> + <div class="coverageMethod">BootstrapCustomProviderDefinedInValidationXmlTest.testGetFactoryByProviderSpecifiedInValidationXml()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.1">Section 4.4.1 - Examples</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">The ValidatorFactory object is thread-safe</p> +</div></div><h4 class="sectionHeader" id="4.4.2">Section 4.4.2 - ValidatorFactory</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The MessageInterpolator or the TraversableResolver passed to the ValidatorContext + are used instead of the ValidatorFactory's MessageInterpolator or + TraversableResolver instances</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">getMessageInterpolator() returns the MessageInterpolator instance configured + during the initialization of the ValidatorFactory</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">CustomMessageInterpolatorTest.testCustomMessageInterpolatorViaValidatorContext()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.3">Section 4.4.3 - Configuration</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A Bean Validation provider must define a sub interface of Configuration uniquely + identifying the provider.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ConfigurationTest.testProviderUnderTestDefinesSubInterfaceOfConfiguration()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">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)</p> +</div></div> <div class="untestable"> + <span class="code">c)</span> + <div class="results"><p class="description">If no ValidationProviderResolver instance has been specified, the default + ValidationProviderResolver is used</p> +</div></div><h4 class="sectionHeader" id="4.4.4.1">Section 4.4.4.1 - ValidationProviderResolver</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">ValidationProviderResolver returns the list of Bean Validation providers available + at runtime and more specifically a ValidationProvider instance for each provider + available in the context</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap.customprovider </div> + <div class="coverageMethod">BootstrapCustomProviderDefinedInServiceFileTest.testProviderResolverReturnsListOfAvailableProviders()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">Implementations must be thread-safe</p> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderResolverTest.testServiceFileExists()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.4.2">Section 4.4.4.2 - ValidationProvider</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A client can request a specific Bean Validation provider by using + Validation.byProvider() or by defining the provider in the XML configuration + file</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap.customprovider </div> + <div class="coverageMethod">BootstrapCustomProviderDefinedInServiceFileTest.testGetFactoryByProviderSpecifiedProgrammatically()</div> + <div class="coverageMethod">BootstrapCustomProviderDefinedInValidationXmlTest.testGetFactoryByProviderSpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">The provider discovery mechanism retrieve all available providers using + ValidationProviderResolver.getValidationProviders() and returns the first + ValidationProvider matching the requested provider</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderTest.testFirstMatchingValidationProviderResolverIsReturned()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">When the default Bean Validation provider is requested, the first + ValidationProvider returned by the ValidationProviderResolver strategy is + returned</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderTest.testByDefaultProviderUsesTheFirstProviderReturnedByValidationProviderResolver()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Every Bean Validation provider must provide a ValidationProvider implementation + containing a public no-arg constructor</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderTest.testValidationProviderContainsNoArgConstructor()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If a problem occurs while building the ValidatorFactory, a ValidationException is + raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderTest.testValidationExceptionIsThrownInCaseValidatorFactoryCreationFails()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.5">Section 4.4.5 - Validation</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description"> Validation.buildDefaultValidatorFactory(), is considered to be the default + ValidatorFactory and is equivalent to the ValidatorFactory returned by + Validation.byDefaultProvider().configure().buildValidatorFactory() </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidationTest.testBuildDefaultValidatorFactory()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">ValidationProvider.createGenericConfiguration(BootstrapState state) is the second + bootstrapping entry point and let the client provide a custom + ValidationProviderResolution instance</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidationTest.testCustomValidationProviderResolution()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">ValidationProvider.createGenericConfiguration(BootstrapState state) is the third + bootstrapping entry point and let the client define the specific Bean Validation + provider requested as well as a custom ValidationProviderResolver implementation if + needed</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidationTest.testSpecificValidationProvider()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">The Validation implementation provided by the Bean Validation provider must not + contain any non private attribute or method aside from the three public static + bootstrap methods</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidationTest.testVerifyMethodsOfValidationObjects()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The bootstrap implementation must ensure it can bootstrap third party + providers</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidationTest.testCustomValidationProviderResolution()</div> + <div class="coverageMethod">ValidationTest.testSpecificValidationProvider()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">When building the Configuration object, if the ValidationProviderResolver fails or + if the expected provider is not found, a ValidationException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap </div> + <div class="coverageMethod">ValidationProviderTest.testValidationExceptionIsThrownInCaseValidatorFactoryCreationFails()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">UnknownProviderBootstrapTest.testUnknownProviderThrowsValidationException()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.6">Section 4.4.6 - XML Configuration</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Unless explicitly ignored Configuration takes into account the configuration + available in META-INF/validation.xml</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + </div> +</div></div> <div class="pass"> +<span class="implied">The following assertion is not made explicitly by the spec, however it is implied</span> <span class="code">b)</span> + <div class="results"><p class="description">META-INF/validation.xml will be ignored if Configuration.ignoreXMLConfiguration() + is called.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">This configuration file is optional.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">OptionalValidationXmlTest.testIgnoreValidationXml()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">d)</span> + <div class="results"><p class="description">If more than one META-INF/validation.xml file is found in the classpath, a + ValidationException is raised. </p> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">Unless stated otherwise, XML based configuration settings are overridden by values + explicitly set via the Configuration API</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()</div> + <div class="coverageMethod">TraversableResolverSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">default-provider represents the class name of the provider specific Configuration + sub-interface. If defined, the provider suitable for this interface is used</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DefaultProviderSpecifiedInValidationXmlTest.testProviderSpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">MessageInterpolatorSpecifiedInValidationXmlNoDefaultConstructorTest.testMessageInterpolatorSpecifiedInValidationXmlHasNoDefaultConstructor()</div> + <div class="coverageMethod">MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()</div> + <div class="coverageMethod">MessageInterpolatorSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXmlCanBeOverridden()</div> + <div class="coverageMethod">TraversableResolverSpecifiedInValidationXmlNoDefaultConstructorTest.testTraversableResolverSpecifiedInValidationXmlHasNoDefaultConstructor()</div> + <div class="coverageMethod">TraversableResolverSpecifiedInValidationXmlTest.testMessageInterpolatorSpecifiedInValidationXmlCanBeOverridden()</div> + <div class="coverageMethod">TraversableResolverSpecifiedInValidationXmlTest.testTraversableResolverSpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">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.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXmlCanBeOverridden()</div> + <div class="coverageMethod">ConstraintValidatorFactorySpecifiedInValidationXmlTest.testConstraintValidatorFactorySpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">message-interpolator, traversable-resolver and constraint-validator-factory are + optional.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DefaultProviderSpecifiedInValidationXmlTest.testProviderSpecifiedInValidationXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">constraint-mapping represents the resource path of an XML mapping file</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">More than one constraint-mapping element can be present</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">m)</span> + <div class="results"><p class="description">Mappings provided via Configuration.addMapping(InputStream) are added to the list + of mappings described via constraint-mapping</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testMappingFilesAddedViaConfigurationGetAddedToXmlConfiguredMappings()</div> + </div> +</div></div> <div class="untestable"> + <span class="code">n)</span> + <div class="results"><p class="description">The namespace javax.validation for properties is reserved for use by this + specification</p> +</div></div> <div class="untestable"> + <span class="code">o)</span> + <div class="results"><p class="description">Properties defined via Configuration.addProperty(String, String) are added to the + properties defined via property</p> +</div></div> <div class="untestable"> + <span class="code">p)</span> + <div class="results"><p class="description">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</p> +</div></div> <div class="pass"> + <span class="code">q)</span> + <div class="results"><p class="description">If a public no-arg constructor is missing, a ValidationException is raised during + the Configuration.buildValidatorFactory() call</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">MessageInterpolatorSpecifiedInValidationXmlNoDefaultConstructorTest.testMessageInterpolatorSpecifiedInValidationXmlHasNoDefaultConstructor()</div> + <div class="coverageMethod">TraversableResolverSpecifiedInValidationXmlNoDefaultConstructorTest.testTraversableResolverSpecifiedInValidationXmlHasNoDefaultConstructor()</div> + </div> +</div></div><h4 class="sectionHeader" id="4.4.7">Section 4.4.7 - Usage</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">ValidatorFactory is a thread-safe object that should be built once per deployment + unit</p> +</div></div> <div class="untestable"> + <span class="code">b)</span> + <div class="results"><p class="description">Validator is thread-safe too and should be considered a lightweight object</p> +</div></div><div style="visibility:hidden" id="5"></div> +<h4 class="sectionHeader" id="5.1">Section 5.1 - Validator</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testValidatedPropertyDoesNotFollowJavaBeansConvention()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">Validator.getConstraintsForClass returns a BeanDescriptor object describing the + bean level constraints and providing access to the property level constraints + metadata. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToValidAnnotation()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnEntity()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnInterface()</div> + <div class="coverageMethod">BeanDescriptorTest.testUnconstrainedClass()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintForConstrainedProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintsForNonExistingProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstrainedProperties()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstrainedPropertiesForUnconstrainedEntity()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testConstraintDescriptorWithoutExplicitGroup()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">Validator.getConstraintsForClass throws an IllegalArgumentException if the clazz + parameter is null</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.validation </div> + <div class="coverageMethod">ValidateTest.testNullParameterToGetConstraintsForClass()</div> + </div> +</div></div><h4 class="sectionHeader" id="5.2">Section 5.2 - PropertyDescriptor</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">getElementClass returns either the object type for a class, or the returned type + for a property</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testGetElementClass()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">getConstraintDescriptors returns all the ConstraintDescriptors hosted on the given + element in the class hierarchy, each ConstraintDescriptor describing one of the + constraints declared on the given element.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testGetConstraintDescriptors()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">hasConstraints returns true if the given element (class, field or property) in the + class hierarchy holds at least one constraint declaration.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testHasConstraints()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">unorderedAndMatchingGroups restricts to the ConstraintDescriptors matching the set + of groups passed as parameters and present on the element. Order is not respected + but group inheritance and inheritance via sequence (including the Default group + overriding at the class level) are honored.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testUnorderedAndMatchingGroups()</div> + <div class="coverageMethod">ElementDescriptorTest.testUnorderedAndMatchingGroupsWithInheritance()</div> + <div class="coverageMethod">ElementDescriptorTest.testUnorderedAndMatchingGroupsWithDefaultGroupOverriding()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">declaredOn lets you restrict the list of element types constraints are hosted + on.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testDeclaredOn()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">lookingAt lets you restrict which constraints are considered. Either constraints + belonging to the element but hosted on the class represented by BeanDescritptor + (Scope.LOCAL_ELEMENT), or constraints belonging to the element but hosted anywhere + in the class hierarchy (Scope.HIERARCHY).</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ElementDescriptorTest.testLookingAt()</div> + </div> +</div></div><h4 class="sectionHeader" id="5.3">Section 5.3 - BeanDescriptor</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">isBeanConstrained returns true if the given class (and superclasses and + interfaces) host at least one validation declaration (either constraint or @Valid + annotation)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToValidAnnotation()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnEntity()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testIsBeanConstrainedDueToConstraintOnInterface()</div> + <div class="coverageMethod">BeanDescriptorTest.testUnconstrainedClass()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">getConstraintsForProperty returns a PropertyDescriptor object describing the + property level constraints (See Section 3.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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintForConstrainedProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintForUnConstrainedProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintForUnConstrainedProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintsForNonExistingProperty()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstrainedProperties()</div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstrainedPropertiesForUnconstrainedEntity()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">getConstraintsForProperty throws an IllegalArgumentException if the propertyName + parameter is null</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintsForNullProperty()</div> + </div> +</div></div><h4 class="sectionHeader" id="5.4">Section 5.4 - PropertyDescriptor</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The isCascaded method returns true if the property is marked with @Valid</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">BeanDescriptorTest.testGetConstraintForUnConstrainedProperty()</div> + <div class="coverageMethod">PropertyDescriptorTest.testIsNotCascaded()</div> + <div class="coverageMethod">PropertyDescriptorTest.testIsCascaded()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">getPropertyName returns the property name</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">PropertyDescriptorTest.testPropertyName()</div> + </div> +</div></div><h4 class="sectionHeader" id="5.5">Section 5.5 - ConstraintDescriptor</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If ConstraintDescriptor represents a composing annotation (see Section 2.3), the + returned annotation must reflect parameter overriding</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testAnnotationAndMapParametersReflectParameterOverriding()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">getAttributes returns a map containing the annotation attribute names as a key, + and the annotation attribute values as a value</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testGetAttributesFromConstraintDescriptor()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">If ConstraintDescriptor represents a composing annotation (see Section 2.3), the + returned Map must reflect attribute overriding</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testAnnotationAndMapParametersReflectParameterOverriding()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">getGroups returns the groups the constraint is supposed to be applied upon</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testGetGroups()</div> + <div class="coverageMethod">ConstraintDescriptorTest.testGetGroupsOnInterface()</div> + <div class="coverageMethod">ConstraintDescriptorTest.testGetGroupsWithImplicitGroup()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If no group is set on the constraint declaration, the Default group is + returned</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testDefaultGroupIsReturnedIfNoGroupSpecifiedInDeclaration()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">The groups of a composing constraint are the groups of the composed + constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testComposingConstraints()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">getPayload returns the payloads the constraint hosts or an empty set if + none</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testPayload()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">Likewise, payload from the main constraint annotation is inherited by the + composing annotations.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testComposingConstraintsPayload()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">Any payload definition on a composing annotation is ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testComposingConstraintsPayload()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">isReportAsSingleViolation() returns true if the constraint is annotated with + @ReportAsSingleViolation </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testReportAsSingleViolation()</div> + </div> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">getComposingConstraints return a set of composing ConstraintDescriptors where each + descriptor describes a composing constraint.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.metadata </div> + <div class="coverageMethod">ConstraintDescriptorTest.testComposingConstraints()</div> + <div class="coverageMethod">ConstraintDescriptorTest.testEmptyComposingConstraints()</div> + </div> +</div></div><h4 class="sectionHeader" id="6">Section 6 - Built-in Constraint definitions</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Each Bean Validation provider must recognize built-in constraint annotations as + valid constraint definitions and provide compliant constraint implementations for + each</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testNullConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testNotNullConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testAssertTrueConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testAssertFalseConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testMinConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testMaxConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testDecimalMinConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testDecimalMaxConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testSizeConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testDigitsConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testPastConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testFutureConstraint()</div> + <div class="coverageMethod">BuiltinConstraintsTest.testPatternConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">The built-in constraint validation implementation is having a lower priority than + an XML mapping definition</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinValidatorOverrideTest.testXmlConfiguredValidatorConfigurationHasPrecedence()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">@Null constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testNullConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">@NotNull constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testNotNullConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">@AssertTrue constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testAssertTrueConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">@AssertFalse constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testAssertFalseConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">@Min constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testMinConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">@Max constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testMaxConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">i)</span> + <div class="results"><p class="description">@DecimalMin constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testDecimalMinConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">j)</span> + <div class="results"><p class="description">@DecimalMax constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testDecimalMaxConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">k)</span> + <div class="results"><p class="description">@Size constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testSizeConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">l)</span> + <div class="results"><p class="description">@Digits constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testDigitsConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">m)</span> + <div class="results"><p class="description">@Past constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testPastConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">n)</span> + <div class="results"><p class="description">@Future constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testFutureConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">o)</span> + <div class="results"><p class="description">@Pattern constraint</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.builtinconstraints </div> + <div class="coverageMethod">BuiltinConstraintsTest.testPatternConstraint()</div> + </div> +</div></div><h4 class="sectionHeader" id="7">Section 7 - XML deployment descriptor</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If the xml configuration file does not validate against the given xsd files a + ValidationException is raised. </p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">InvalidXmlConfigurationTest.testInvalidValidationXml()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1">Section 7.1 - Constraint definition and declaration</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Specifically when exploring metadata, the Bean Validation provider must ensure + that an annotation instance corresponding to the XML declaration is provided via + ConstraintDescriptor.getAnnnotation()</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DuplicateConfigurationTest.testXmlConfiguredConstraintExposesCorrespondingAnnotationViaMetadata()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">A given class must not be described more than once amongst all the XML mapping + descriptors</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DuplicateConfigurationTest.testBeanCannotBeDescribedMoreThanOnce()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">A given field or getter must not be described more than once on a given class + description</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DuplicateConfigurationTest.testFieldMappingCannotOccurMoreThanOnce()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">A given constraint definition must not be overridden more than once amongst all + the XML mapping descriptors</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DuplicateConfigurationTest.testGetterMappingCannotOccurMoreThanOnce()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If any of these rule is violated in a given validation deployment, a + ValidationException is raised during the creation of the ValidatorFactory</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">DuplicateConfigurationTest.testBeanCannotBeDescribedMoreThanOnce()</div> + <div class="coverageMethod">DuplicateConfigurationTest.testFieldMappingCannotOccurMoreThanOnce()</div> + <div class="coverageMethod">DuplicateConfigurationTest.testGetterMappingCannotOccurMoreThanOnce()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.1">Section 7.1.1 - Constraint declaration in XML</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If default-package is set, all unqualified class names (including annotations) are + considered part of the package described by default-package.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ConfigurationViaXmlAndAnnotationsTest.testEntityConfiguredViaAnnotationsAndXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">A given JavaBean is described by the bean element.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">The name of the class in the bean node is mandatory</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">MissingClassNameOnBeanNodeTest.testClassNameIsMandatory()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">By default, all constraint declarations expressed via annotation are ignored for + classes described in XML</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ConstraintDeclarationTest.testConstraintAnnotationsArePerDefaultIgnoredForXmlConfiguredEntities()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">You can force Bean Validation to consider both annotations and XML constraint + declarations by using ignore-annotation="false" on bean</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ConfigurationViaXmlAndAnnotationsTest.testEntityConfiguredViaAnnotationsAndXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If the name of the class does refer to a class not present in in the classpath, a + ValidationException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ConfiguredBeanNotInClassPathTest.testExceptionIsThrownForUnknownBeanNameInXml()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.1.1">Section 7.1.1.1 - Class-level overriding</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If ignore-annotations is declared, Bean Validation must honor the explicit value + for this element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel </div> + <div class="coverageMethod">ClassLevelOverridingTest.testIgnoreClassLevelAnnotations()</div> + <div class="coverageMethod">ClassLevelOverridingTest.testClassLevelAnnotationsApplied()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If not declared, the default value defined in the encapsulating bean element is + considered</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel </div> + <div class="coverageMethod">ClassLevelOverridingTest.testIgnoreAnnotationsFromEnclosingBeanIsApplied()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">When ignore-annotations is true, class-level Bean Validation annotations are + ignored for this class</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel </div> + <div class="coverageMethod">ClassLevelOverridingTest.testIgnoreClassLevelAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of class-level declared + constraints</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.clazzlevel </div> + <div class="coverageMethod">ClassLevelOverridingTest.testClassLevelAnnotationsApplied()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">@GroupSequence is considered unless group-sequence element is explicitly + used</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ConfigurationViaXmlAndAnnotationsTest.testDefaultGroupDefinitionDefinedInEntityApplies()</div> + <div class="coverageMethod">DefaultSequenceDefinedInXmlTest.testDefaultGroupDefinitionDefinedInEntityApplies()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.1.2">Section 7.1.1.2 - Field-level overriding</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If ignore-annotations is declared, Bean Validation must honor the explicit value + for this element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">FieldLevelOverridingTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">FieldLevelOverridingTest.testIncludeAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If not declared, the default value defined in the encapsulating bean element is + considered</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">ExcludeFieldLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">IncludeFieldLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">When ignore-annotations is true, field-level Bean Validation annotations on the + targeted field are ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">ExcludeFieldLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">FieldLevelOverridingTest.testIgnoreAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of field-level declared + constraints</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">FieldLevelOverridingTest.testIncludeAnnotations()</div> + <div class="coverageMethod">IncludeFieldLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The only way to disable cascading on a field marked as @Valid is to use + ignore-annotations=true</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">FieldLevelOverridingTest.testCascadedConfiguration()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If the name of the field does not correspond to a field in the given bean a + ValidationException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.fieldlevel </div> + <div class="coverageMethod">WrongFieldNameTest.testWrongFieldNameThrowsException()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.1.3">Section 7.1.1.3 - Property-level overriding</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The name attribute correspond to the name of the property considered as defined in + Section 3.1.2. If ignore-annotations is declared, Bean Validation must honor the + explicit value for this element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">PropertyLevelOverridingTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">PropertyLevelOverridingTest.testIncludeAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If not declared, the default value defined in the encapsulating bean element is + considered</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">ExcludePropertyLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">IncludePropertyLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">When ignore-annotations is true, property-level Bean Validation annotations on the + targeted property are ignored (including the @Valid)</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">ExcludePropertyLevelAnnotationsDueToBeanDefaultsTest.testIgnoreAnnotations()</div> + <div class="coverageMethod">PropertyLevelOverridingTest.testIgnoreAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">When ignore-annotations is false, constraints declared in XML and constraints + declared in annotations are added and form the list of property-level declared + constraints.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">IncludePropertyLevelAnnotationsDueToBeanDefaultsTest.testAnnotationsIncluded()</div> + <div class="coverageMethod">PropertyLevelOverridingTest.testIncludeAnnotations()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The only way to disable cascading on a property marked as @Valid is to use + ignore-annotations=true</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">PropertyLevelOverridingTest.testCascadedConfiguration()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If the name of the property does not correspond to a property in the given bean a + ValidationException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration.propertylevel </div> + <div class="coverageMethod">WrongPropertyNameTest.testWrongPropertyNameThrowsException()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.1.4">Section 7.1.1.4 - Constraint declaration</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">The name attribute is mandatory and represents the name of the element in the + constraint declaration</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">MandatoryNameAttributeTest.testNameAttributeIsMandatory()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">"message" or "groups" are not permitted names, use the message or groups elements + instead. Otherwise a ValidationException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">ReservedElementNameTest.testGroupIsNotAllowedAsElementName()</div> + <div class="coverageMethod">ReservedElementNameTest.testMessageIsNotAllowedAsElementName()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">If the element represents a primitive type, a class or an enum, the string + representation of its value is placed in the element itself</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">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 element placed under the + element itself</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">If the element represents an annotation, the annotation element is used to + represent the annotation and placed under element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">f)</span> + <div class="results"><p class="description">If the element represents an array of annotations, one or more annotation elements + are placed under element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">g)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testElementConversionInXmlConfiguredConstraint()</div> + </div> +</div></div> <div class="pass"> + <span class="code">h)</span> + <div class="results"><p class="description">If an XML constraint declaration is missing mandatory elements, or if it contains + elements not part of the constraint definition, a ValidationException is + raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdeclaration </div> + <div class="coverageMethod">MissingMandatoryElementTest.testMissingMandatoryElementInConstraintDeclaration()</div> + </div> +</div></div><h4 class="sectionHeader" id="7.1.2">Section 7.1.2 - Overriding constraint definitions in XML</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">A constraint definition is represented by a constraint-definition element</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration </div> + <div class="coverageMethod">XmlConfigurationTest.testClassConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testIgnoreValidationXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testPropertyConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testFieldConstraintDefinedInXml()</div> + <div class="coverageMethod">XmlConfigurationTest.testAnnotationDefinedConstraintApplies()</div> + <div class="coverageMethod">XmlConfigurationTest.testCascadingConfiguredInXml()</div> + </div> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">If include-existing-validator is set to false, ConstraintValidator defined on the + constraint annotation are ignored</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdefinition </div> + <div class="coverageMethod">XmlConfiguredConstraintValidatorTest.testExcludeExistingValidators()</div> + </div> +</div></div> <div class="pass"> + <span class="code">c)</span> + <div class="results"><p class="description">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</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdefinition </div> + <div class="coverageMethod">XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()</div> + </div> +</div></div> <div class="pass"> + <span class="code">d)</span> + <div class="results"><p class="description">Annotation based ConstraintValidator come before XML based ConstraintValidator in + the array</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdefinition </div> + <div class="coverageMethod">XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()</div> + </div> +</div></div> <div class="pass"> + <span class="code">e)</span> + <div class="results"><p class="description">The validator list is returned by + ConstraintDescriptor.getConstraintValidatorClasses()</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.xmlconfiguration.constraintdefinition </div> + <div class="coverageMethod">XmlConfiguredConstraintValidatorTest.testExcludeExistingValidators()</div> + <div class="coverageMethod">XmlConfiguredConstraintValidatorTest.testIncludeExistingValidators()</div> + </div> +</div></div><h4 class="sectionHeader" id="8">Section 8 - Exception model</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">Every (runtime) exception raised either at initialization time or execution time + by any of the extension interfaces (ConstraintValidator, ConstraintValidatorFactory, + MessageInterpolator, TraversableResolver, ValidationProviderResolver) is wrapped in + a ValidationException</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.bootstrap.customprovider </div> + <div class="coverageMethod">BootstrapUnknownCustomProviderTest.testWrongProviderConfiguredInValidationXml()</div> + </div> +</div></div><h4 class="sectionHeader" id="8.2">Section 8.2 - ConstraintDefinitionException</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">If a constraint definition does not respect the Bean Validation rules or is + inconsistent, a ConstraintDefinitionException is raised.</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.invalidconstraintdefinitions </div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithParameterStartingWithValid()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutMessageParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutGroupParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithoutPayloadParameter()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultGroupValue()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongDefaultPayloadValue()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongPayloadClass()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongMessageType()</div> + <div class="coverageMethod">InvalidConstraintDefinitionsTest.testConstraintDefinitionWithWrongGroupType()</div> + </div> +</div></div><h4 class="sectionHeader" id="8.3">Section 8.3 - ConstraintDeclarationException and UnexpectedTypeException</h4> + <div class="untestable"> + <span class="code">a)</span> + <div class="results"><p class="description">When a constraint declaration is illegal, ConstraintDeclarationException is + raised</p> +</div></div> <div class="pass"> + <span class="code">b)</span> + <div class="results"><p class="description">When the return type of a property cannot be processed for a given constraint, an + UnexpectedTypeException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.validatorresolution </div> + <div class="coverageMethod">ValidatorResolutionTest.testAmbiguousValidatorResolution()</div> + </div> +</div></div><h4 class="sectionHeader" id="8.4">Section 8.4 - GroupDefinitionException</h4> + <div class="pass"> + <span class="code">a)</span> + <div class="results"><p class="description">When a group definition is illegal, GroupDefinitionException is raised</p> + <div class="coverage"> + <p class="coverageHeader">Coverage</p> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups </div> + <div class="coverageMethod">GroupTest.testCyclicGroupSequence()</div> + <div class="packageName">org.hibernate.jsr303.tck.tests.constraints.groups.groupsequence </div> + <div class="coverageMethod">SequenceResolutionTest.testInvalidDefinitionOfDefaultSequenceInEntity()</div> + </div> +</div></div></table></body></html> \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +4818e42f887c2488baacf7f99a6e3983 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-coverage.html.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +62443c30be91be788f9708548e75386fb7d121e2 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar =================================================================== (Binary files differ) Property changes on: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +a8b10a31e942148c35cc1327a2195984 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-javadoc.jar.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +7acedde2a5156e0f3b6bf16cc367162b5123f2e6 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar =================================================================== (Binary files differ) Property changes on: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +3a768bb2c3fca93b4d8d56353f1d069f \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-sources.jar.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +2600361c5f76c5b57f749629ea05fb241761cac8 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1,25 @@ +<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" > + +<suite name="JSR-303-TCK" verbose="1"> + <test name="JSR-303-TCK"> + <method-selectors> + <method-selector> + <selector-class name="org.jboss.testharness.impl.testng.DisableIntegrationTestsMethodSelector"/> + </method-selector> + <method-selector> + <selector-class name="org.jboss.testharness.impl.testng.ExcludeIncontainerUnderInvestigationMethodSelector"/> + </method-selector> + </method-selectors> + <groups> + <run> + <exclude name="underInvestigation"/> + <exclude name="ri-broken"/> + <exclude name="jboss-as-broken"/> + <exclude name="broken"/> + </run> + </groups> + <packages> + <package name="org.hibernate.jsr303.tck.tests"/> + </packages> + </test> +</suite> Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +0a4eb16729e3c2ff1d64efd9a78451e4 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA-suite.xml.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +b45b765aa2f20cc5a0d424cb7f0577c15c1deb4c \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar =================================================================== (Binary files differ) Property changes on: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +791dea6000e5c42cb2e3a4c2858a8d11 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.jar.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +abd784725b49691a1966a34b1ab78207108fc29d \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1,485 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + <groupId>org.hibernate.jsr303.tck</groupId> + <artifactId>jsr303-tck</artifactId> + <packaging>jar</packaging> + <version>1.0.3.GA</version> + <name>JSR-303 TCK</name> + <url>http://validator.hibernate.org</url> + + <description>JSR-303 TCK</description> + + <developers> + <developer> + <id>epbernard</id> + <name>Emmanuel Bernard</name> + <email&gt;emmanuel(a)hibernate.org&lt;/email&gt; + <organization>JBoss, a division of Red Hat</organization> + <url>http://in.relation.to/Bloggers/Emmanuel</url> + </developer> + <developer> + <id>hardy.ferentschik</id> + <name>Hardy Ferentschik</name> + <email&gt;hferents(a)redhat.com&lt;/email&gt; + <organization>JBoss, a division of Red Hat</organization> + <url>http://in.relation.to/Bloggers/Hardy</url> + </developer> + </developers> + + <mailingLists> + <mailingList> + <name>hibernate-dev</name> + <post&gt;hibernate-dev(a)lists.jboss.org&lt;/post&gt; + </mailingList> + </mailingLists> + + <dependencies> + <dependency> + <groupId>org.testng</groupId> + <artifactId>testng</artifactId> + <version>5.8</version> + <classifier>jdk15</classifier> + </dependency> + <dependency> + <groupId>javax.validation</groupId> + <artifactId>validation-api</artifactId> + <version>1.0.0.GA</version> + </dependency> + <dependency> + <groupId>org.jboss.test-audit</groupId> + <artifactId>jboss-test-audit-api</artifactId> + <version>1.0.0</version> + </dependency> + <dependency> + <groupId>org.jboss.test-harness</groupId> + <artifactId>jboss-test-harness-api</artifactId> + <version>1.0.0</version> + <exclusions> + <exclusion> + <groupId>log4j</groupId> + <artifactId>log4j</artifactId> + </exclusion> + </exclusions> + </dependency> + <dependency> + <groupId>org.jboss.test-harness</groupId> + <artifactId>jboss-test-harness</artifactId> + <version>1.0.0</version> + <exclusions> + <exclusion> + <groupId>log4j</groupId> + <artifactId>log4j</artifactId> + </exclusion> + </exclusions> + </dependency> + </dependencies> + + <build> + <defaultGoal>install</defaultGoal> + <extensions> + <extension> + <groupId>org.apache.maven.wagon</groupId> + <artifactId>wagon-webdav</artifactId> + <version>1.0-beta-2</version> + </extension> + </extensions> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-compiler-plugin</artifactId> + <version>2.0.2</version> + <configuration> + <source>1.5</source> + <target>1.5</target> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jar-plugin</artifactId> + <configuration> + <archive> + <manifest> + <addDefaultImplementationEntries>true</addDefaultImplementationEntries> + <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries> + </manifest> + </archive> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-enforcer-plugin</artifactId> + <version>1.0-alpha-4</version> + <executions> + <execution> + <id>enforce</id> + <goals> + <goal>enforce</goal> + </goals> + <configuration> + <rules> + <requireMavenVersion> + <version>2.0.9</version> + </requireMavenVersion> + </rules> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.jboss.maven.plugins</groupId> + <artifactId>maven-jdocbook-plugin</artifactId> + <version>2.2.0</version> + <extensions>true</extensions> + <dependencies> + <dependency> + <groupId>org.hibernate</groupId> + <artifactId>hibernate-jdocbook-style</artifactId> + <version>2.0.0</version> + <type>jdocbook-style</type> + </dependency> + </dependencies> + <configuration> + <sourceDocumentName>master.xml</sourceDocumentName> + <sourceDirectory>${basedir}/src/main/docbook</sourceDirectory> + <masterTranslation>en-US</masterTranslation> + <imageResource> + <directory>${basedir}/src/main/docbook/en-US/harness</directory> + </imageResource> + <formats> + <format> + <formatName>pdf</formatName> + <stylesheetResource>classpath:/xslt/org/hibernate/jdocbook/xslt/pdf.xsl</stylesheetResource> + <finalName>beanvalidation-tck.pdf</finalName> + </format> + <format> + <formatName>html_single</formatName> + <stylesheetResource>classpath:/xslt/org/hibernate/jdocbook/xslt/xhtml-single.xsl + </stylesheetResource> + <finalName>index.html</finalName> + </format> + <format> + <formatName>html</formatName> + <stylesheetResource>classpath:/xslt/org/hibernate/jdocbook/xslt/xhtml.xsl + </stylesheetResource> + <finalName>index.html</finalName> + </format> + </formats> + <options> + <xincludeSupported>true</xincludeSupported> + <xmlTransformerType>saxon</xmlTransformerType> + <!-- needed for uri-resolvers; can be ommitted if using 'current' uri scheme --> + <!-- could also locate the docbook dependency and inspect its version... --> + <docbookVersion>1.72.0</docbookVersion> + <localeSeparator>-</localeSeparator> + </options> + </configuration> + <executions> + <execution> + <id>make-doc</id> + <phase>site</phase> + <goals> + <goal>resources</goal> + <goal>generate</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.jboss.maven.plugins</groupId> + <artifactId>maven-jdocbook-style-plugin</artifactId> + <version>2.0.0</version> + </plugin> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>build-helper-maven-plugin</artifactId> + <version>1.2</version> + <executions> + <execution> + <id>attach-artifacts</id> + <phase>package</phase> + <goals> + <goal>attach-artifact</goal> + </goals> + <configuration> + <artifacts> + <artifact> + <file>${basedir}/src/main/resources/tck-tests.xml</file> + <type>xml</type> + <classifier>suite</classifier> + </artifact> + <artifact> + <file>${basedir}/src/main/resources/tck-audit.xml</file> + <type>xml</type> + <classifier>audit</classifier> + </artifact> + </artifacts> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-dependency-plugin</artifactId> + <executions> + <execution> + <id>copy-in-container-dependencies</id> + <phase>compile</phase> + <goals> + <goal>copy</goal> + </goals> + <configuration> + <outputDirectory>${project.build.outputDirectory}/lib</outputDirectory> + <stripVersion>true</stripVersion> + <artifactItems> + <artifactItem> + <groupId>org.jboss.test-harness</groupId> + <artifactId>jboss-test-harness</artifactId> + <overWrite>true</overWrite> + </artifactItem> + </artifactItems> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-source-plugin</artifactId> + <executions> + <execution> + <id>attach-sources</id> + <phase>verify</phase> + <goals> + <goal>jar</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-release-plugin</artifactId> + <version>2.0-beta-9</version> + <configuration> + <allowTimestampedSnapshots>true</allowTimestampedSnapshots> + <remoteTagging>true</remoteTagging> + <goals>deploy org.jboss.maven.plugins:maven-jdocbook-plugin:2.2.0:resources + org.jboss.maven.plugins:maven-jdocbook-plugin:2.2.0:generate assembly:assembly + </goals> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-assembly-plugin</artifactId> + <configuration> + <descriptors> + <descriptor>src/main/assembly/assembly.xml</descriptor> + </descriptors> + </configuration> + </plugin> + </plugins> + </build> + + <ciManagement> + <system>Hudson</system> + <url /> + </ciManagement> + + <issueManagement> + <system>JIRA</system> + <url>http://opensource.atlassian.com/projects/hibernate/browse/BVTCK<... + </issueManagement> + + <inceptionYear>2008</inceptionYear> + + <licenses> + <license> + <name>Apache License, Version 2.0</name> + <url>http://www.apache.org/licenses/LICENSE-2.0</url> + </license> + </licenses> + + <scm> + <connection>scm:svn:http://anonsvn.jboss.org/repos/hibernate/beanvalida... + <developerConnection>scm:svn:https://svn.jboss.org/repos/hibernate/bean... + </developerConnection> + </scm> + + <distributionManagement> + <repository> + <!-- Copy the dist to the local checkout of the JBoss maven2 repo ${maven.repository.root} --> + <!-- It is anticipated that ${maven.repository.root} be set in user's settings.xml --> + <!-- todo : replace this with direct svn access once the svnkit providers are available --> + <id>repository.jboss.org</id> + <url>file://${maven.repository.root}</url> + </repository> + <snapshotRepository> + <id>snapshots.jboss.org</id> + <name>JBoss Snapshot Repository</name> + <url>dav:https://snapshots.jboss.org/maven2</url> + </snapshotRepository> + </distributionManagement> + + <profiles> + <profile> + <id>tck-audit</id> + <activation> + <property> + <name>tck-audit</name> + </property> + </activation> + <dependencies> + <dependency> + <groupId>org.jboss.test-audit</groupId> + <artifactId>jboss-test-audit-impl</artifactId> + <version>1.0.0.BETA1</version> + </dependency> + </dependencies> + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-antrun-plugin</artifactId> + <executions> + <execution> + <id>process_annotations</id> + <phase>process-resources</phase> + <configuration> + <tasks> + <javac srcdir="${basedir}/src/main/java" destdir="${basedir}/target/classes" failonerror="true"> + <compilerarg value="-proc:only" /> + <compilerarg value="-AauditXml=${basedir}/src/main/resources/tck-audit.xml" /> + <classpath> + <path refid="maven.compile.classpath" /> + </classpath> + </javac> + </tasks> + </configuration> + <goals> + <goal>run</goal> + </goals> + </execution> + </executions> + <dependencies> + <dependency> + <groupId>org.apache.ant</groupId> + <artifactId>ant</artifactId> + <version>1.7.0</version> + </dependency> + </dependencies> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-compiler-plugin</artifactId> + <configuration> + <source>1.5</source> + <target>1.5</target> + <compilerArgument>-proc:none</compilerArgument> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-enforcer-plugin</artifactId> + <executions> + <execution> + <id>enforce-versions</id> + <goals> + <goal>enforce</goal> + </goals> + <configuration> + <rules> + <requireJavaVersion> + <version>1.6</version> + </requireJavaVersion> + </rules> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>build-helper-maven-plugin</artifactId> + <version>1.2</version> + <executions> + <execution> + <id>attach-artifacts</id> + <phase>package</phase> + <goals> + <goal>attach-artifact</goal> + </goals> + <configuration> + <artifacts> + <artifact> + <file>${basedir}/src/main/resources/tck-tests.xml</file> + <type>xml</type> + <classifier>suite</classifier> + </artifact> + <artifact> + <file>${basedir}/src/main/resources/tck-audit.xml</file> + <type>xml</type> + <classifier>audit</classifier> + </artifact> + <artifact> + <file>${basedir}/target/coverage.html</file> + <type>html</type> + <classifier>coverage</classifier> + </artifact> + </artifacts> + </configuration> + </execution> + </executions> + </plugin> + </plugins> + <defaultGoal>compile</defaultGoal> + </build> + </profile> + <profile> + <id>write-artifacts-to-disk</id> + <activation> + <property> + <name>dumpArtifacts</name> + </property> + </activation> + <build> + <plugins> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>exec-maven-plugin</artifactId> + <executions> + <execution> + <id>generate-jsr-303-artifacts</id> + <phase>package</phase> + <goals> + <goal>java</goal> + </goals> + </execution> + </executions> + <configuration> + <classpathScope>test</classpathScope> + <mainClass>org.jboss.testharness.api.TCK</mainClass> + <systemProperties> + <systemProperty> + <key>dumpArtifacts</key> + <value>true</value> + </systemProperty> + <systemProperty> + <key>org.jboss.testharness.outputDirectory</key> + <value>target/jsr303-artifacts</value> + </systemProperty> + <systemProperty> + <key>org.jboss.testharness.libraryDirectory</key> + <value>target/jsr303-artifacts/dependencies</value> + </systemProperty> + </systemProperties> + </configuration> + </plugin> + </plugins> + </build> + </profile> + <profile> + <id>release</id> + <properties> + <createChecksum>true</createChecksum> + </properties> + </profile> + </profiles> +</project> Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.md5 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +04cf1aff776c5c9cd2ab1781cb37d173 \ No newline at end of file Added: maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.sha1 (rev 0) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/1.0.3.GA/jsr303-tck-1.0.3.GA.pom.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -0,0 +1 @@ +c5245d6c6b0e1eb7c21ead01ca880776eb0b209e \ No newline at end of file Modified: maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml 2009-11-25 02:47:33 UTC (rev 31758) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml 2009-11-25 14:51:19 UTC (rev 31759) @@ -4,7 +4,7 @@ <artifactId>jsr303-tck</artifactId> <version>1.0.0.Alpha2</version> <versioning> - <release>1.0.2.GA</release> + <release>1.0.3.GA</release> <versions> <version>1.0.0.Alpha2</version> <version>1.0.0.Alpha3</version> @@ -14,7 +14,8 @@ <version>1.0.0.GA</version> <version>1.0.1.GA</version> <version>1.0.2.GA</version> + <version>1.0.3.GA</version> </versions> - <lastUpdated>20091124215653</lastUpdated> + <lastUpdated>20091125144829</lastUpdated> </versioning> </metadata> Modified: maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.md5 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.md5 2009-11-25 02:47:33 UTC (rev 31758) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.md5 2009-11-25 14:51:19 UTC (rev 31759) @@ -1 +1 @@ -9bec0d6857ee87f151f9baf4b4b0493c \ No newline at end of file +28f09a5c8e35c452d378cb7283f87988 \ No newline at end of file Modified: maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.sha1 =================================================================== --- maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.sha1 2009-11-25 02:47:33 UTC (rev 31758) +++ maven2/org/hibernate/jsr303/tck/jsr303-tck/maven-metadata.xml.sha1 2009-11-25 14:51:19 UTC (rev 31759) @@ -1 +1 @@ -98b92e5798b979abbb7a965bd5b535da2120a669 \ No newline at end of file +9194ac165e94bfe1efdb46e8c389b448a3b2b5fb \ No newline at end of file