[webbeans-commits] Webbeans SVN: r3711 - tck/trunk/impl/src/main/resources.
webbeans-commits at lists.jboss.org
webbeans-commits at lists.jboss.org
Sun Sep 20 23:43:31 EDT 2009
Author: shane.bryzak at jboss.com
Date: 2009-09-20 23:43:31 -0400 (Sun, 20 Sep 2009)
New Revision: 3711
Modified:
tck/trunk/impl/src/main/resources/tck-audit-cdi.xml
Log:
section 5 assertions
Modified: tck/trunk/impl/src/main/resources/tck-audit-cdi.xml
===================================================================
--- tck/trunk/impl/src/main/resources/tck-audit-cdi.xml 2009-09-21 02:47:18 UTC (rev 3710)
+++ tck/trunk/impl/src/main/resources/tck-audit-cdi.xml 2009-09-21 03:43:31 UTC (rev 3711)
@@ -1864,25 +1864,27 @@
</section>
- <section id="5.2" title="Policy enablement">
+ <section id="5.2" title="Alternative selection">
<assertion id="a">
- <text>A policy is never available for injection, lookup or EL resolution in a Java EE module or library that is not a bean deployment archive (a module or library with no beans.xml file).</text>
+ <text>An alternative is never available for injection, lookup or EL resolution in a Java EE module or library that is not a bean deployment archive (a module or library with no |beans.xml| file).</text>
</assertion>
<assertion id="b">
- <text>Nor is a policy available for injection, lookup or EL resolution in every bean deployment archive. A policy must be explicitly enabled in every bean deployment archive in which the policy should be available for injection, lookup and EL resolution.</text>
+ <text>Nor is an alternative available for injection, lookup or EL resolution in every bean deployment archive. An alternative must be explicitly selected in every bean deployment archive in which the alternative should be available for injection, lookup and EL resolution.</text>
</assertion>
-
+ </section>
+
+ <section id="5.2.1" title="Declaring selected alternatives for a bean deployment archive">
<assertion id="c">
- <text>By default, a bean deployment archive has no enabled policies. A policy must be explicitly declared using the <policies> element of the |beans.xml| file of the bean deployment archive.</text>
+ <text>By default, a bean deployment archive has no selected alternatives. An alternative must be explicitly declared using the <alternatives> element of the |beans.xml| file of the bean deployment archive.</text>
</assertion>
<assertion id="d" testable="false">
- <text>The <policies> element contains a list of bean classes and stereotypes. </text>
+ <text>The <alternatives> element contains a list of bean classes and stereotypes. </text>
</assertion>
<group>
- <text>A policy is enabled for the bean deployment archive if the policy is a managed bean or session bean and the bean class of the bean is listed.</text>
+ <text>An alternative is selected for the bean deployment archive if the alternative is a managed bean or session bean and the bean class of the bean is listed.</text>
<assertion id="ea">
<text>Test with a managed bean.</text>
@@ -1894,7 +1896,7 @@
</group>
<group>
- <text>A policy is enabled for the bean deployment archive if the policy is a producer method, field or resource, and the bean class that declares the method or field is listed.</text>
+ <text>An alternative is selected for the bean deployment archive if the policy is a producer method, field or resource, and the bean class that declares the method or field is listed.</text>
<assertion id="fa">
<text>Test for enablement of a producer method and field.</text>
@@ -1906,11 +1908,11 @@
</group>
<assertion id="g">
- <text>A policy is enabled for the bean deployment archive if any |@Alternative| stereotype of the policy is listed.</text>
+ <text>An alternative is selected for the bean deployment archive if any |@Alternative| stereotype of the alternative is listed.</text>
</assertion>
<assertion id="h">
- <text>Each child <class> element must specify the name of a policy bean class. If there is no class with the specified name, or if the class with the specified name is not a policy bean class, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <text>Each child <class> element must specify the name of a alternative bean class. If there is no class with the specified name, or if the class with the specified name is not an alternative bean class, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
<assertion id="i">
@@ -1918,33 +1920,45 @@
</assertion>
<assertion id="j">
- <text>If the same type is listed twice under the <policies> element, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <text>If the same type is listed twice under the <alternatives> element, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
<assertion id="k">
- <text>For a custom implementation of the |Bean| interface defined in Section 11.1, "The Bean interface", the container calls |isPolicy()| to determine whether the bean is a policy, and |getBeanClass()| and |getStereotypes()| to determine whether a policy is enabled in a certain bean deployment archive.</text>
+ <text>For a custom implementation of the |Bean| interface defined in Section 11.1, "The Bean interface", the container calls |isAlternative()| to determine whether the bean is an alternative, and |getBeanClass()| and |getStereotypes()| to determine whether an alternative is selected in a certain bean deployment archive.</text>
</assertion>
-
- <assertion id="l" testable="false">
- <text>A bean is said to be enabled if it is not a policy, or if it is enabled in at least one bean deployment archive.</text>
+ </section>
+
+ <section id="5.2.2" title="Enabled and disabled beans">
+ <assertion id="a">
+ <text>A bean is said to be enabled if it is not a producer method or field of a disabled bean, and it is not specialized by any other enabled bean, and either it is not an alternative, or it is a selected alternative of at least one bean deployment archive. Otherwise, the bean is said to be disabled.</text>
</assertion>
+ </section>
+
+ <section id="5.2.3" title="Inconsistent specialization">
+ <assertion id="a">
+ <text>Suppose an enabled bean X specializes a second bean Y. If there is another enabled bean that specializes Y we say that inconsistent specialization exists. The container automatically detects inconsistent specialization and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ </assertion>
</section>
- <section id="5.3" title="Typesafe resolution">
+ <section id="5.3" title="Typesafe resolution">
+ <assertion id="a">
+ <text>A bean is eligible for injection into a given class if the bean is enabled, and the bean is either not an alternative, or is a selected alternative of the bean deployment archive of the given class, and in a Java EE or servlet container, the bean class is required to be accessible to the given class, according to the class loading requirements of the Java EE platform and Java Servlet specifications.</text>
+ </assertion>
+
<assertion id="hq">
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not _interceptors_ or decorators and which have a bean type that matches the required type.</text>
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not _interceptors_ or decorators and which have a bean type that matches the required type.</text>
</assertion>
<assertion id="hb">
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or _decorators_ and which have a bean type that matches the required type.</text>
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or _decorators_ and which have a bean type that matches the required type.</text>
</assertion>
<assertion id="hc">
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have a _bean type that matches the required type_.</text>
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have a _bean type that matches the required type_.</text>
</assertion>
<group>
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have a bean type that matches the required type. For this purpose, primitive types are considered to match their corresponding wrapper types in |java.lang| and array types are considered to match only if their element types are identical. Parameterized and raw types are considered to match if they are identical or if the bean type is assignable to the required type, as defined in Section 5.3.3, "Assignability of raw and parameterized types".</text>
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have a bean type that matches the required type. For this purpose, primitive types are considered to match their corresponding wrapper types in |java.lang| and array types are considered to match only if their element types are identical. Parameterized and raw types are considered to match if they are identical or if the bean type is assignable to the required type, as defined in Section 5.3.3, "Assignability of raw and parameterized types".</text>
<assertion id="i">
<text>Test with a primitive type.</text>
@@ -1964,38 +1978,38 @@
</group>
<group>
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have the required bindings. If no required bindings were explicitly specified, the container assumes the required binding |@Current|. The container narrows the set of matching beans to just those where for each required binding, the bean declares a matching binding with (a) the same type and (b) the same annotation member value for each member which is not annotated |@javax.enterprise.inject.NonBinding| (see Section 5.3.5, "Binding annotations with members").</text>
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which have the required qualifiers. If no required qualifiers were explicitly specified, the container assumes the required binding |@Default|. The container narrows the set of matching beans to just those where for each required qualifier, the bean declares a matching qualifier with (a) the same type and (b) the same annotation member value for each member which is not annotated |@javax.enterprise.inject.NonBinding| (see Section 5.3.5, "Qualifier annotations with members").</text>
<assertion id="la">
- <text>Test with beans with required bindings.</text>
+ <text>Test with beans with required qualifiers.</text>
</assertion>
<assertion id="lb">
- <text>Test with beans without required bindings.</text>
+ <text>Test with beans without required qualifiers.</text>
</assertion>
<assertion id="lc">
- <text>Test with matching beans with matching binding with same type.</text>
+ <text>Test with matching beans with matching qualifier with same type.</text>
</assertion>
<assertion id="ld">
- <text>Test with matching beans with matching binding with same annotation member value for each member which is not annotated |@javax.enterprise.inject.NonBinding|.</text>
+ <text>Test with matching beans with matching qualifier with same annotation member value for each member which is not annotated |@javax.enterprise.inject.NonBinding|.</text>
</assertion>
</group>
- <assertion id="m">
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators. In a Java EE or servlet container, the bean class is required to be accessible to the class that declares the injection point, according to the class loading requirements of the Java EE platform and Java Servlet specifications.</text>
+ <assertion id="n">
+ <text>When determining the set of beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are eligible for injection into the class that declares the injection point.</text>
</assertion>
<group>
- <text>When resolving beans that are eligible for injection to an injection point, the container identifies the set of matching beans which are not interceptors or decorators and which are not a policy, or is an enabled policy of the bean deployment archive of the class that declares the injection point. For a custom implementation of the |Bean| interface defined in Section 11.1, "The Bean interface", the container calls |getTypes()| and |getQualifiers()| to determine the bean types and bindings.</text>
+ <text>For a custom implementation of the |Bean| interface defined in Section 11.1, "The Bean interface", the container calls |getTypes()| and |getQualifiers()| to determine the bean types and bindings.</text>
<assertion id="na">
<text>Test |getTypes()| determines bean types.</text>
</assertion>
<assertion id="nb">
- <text>Test |getQualifiers()| determines bindings.</text>
+ <text>Test |getQualifiers()| determines qualifiers.</text>
</assertion>
</group>
</section>
@@ -2073,47 +2087,51 @@
</assertion>
</section>
- <section id="5.3.5" title="Binding annotations with members">
+ <section id="5.3.5" title="Qualifier annotations with members">
<assertion id="a" testable="false">
- <text>Binding types with members are supported</text>
+ <text>Qualifier types with members are supported</text>
<note>A statement of intent</note>
</assertion>
<assertion id="b">
- <text>An annotation member may be excluded from consideration using the |@NonBinding| annotation</text>
+ <text>An annotation member may be excluded from consideration using the |@NonBinding| annotation.</text>
</assertion>
+
+ <group>
+ <text>Array-valued or annotation-valued members of a qualifier type must be annotated |@NonBinding| in a portable application. If an array-valued or annotation-valued member of a binding type is not annotated |@NonBinding|, non-portable behavior results.</text>
+
+ <assertion id="d">
+ <text>Test with an array-valued member.</text>
+ </assertion>
- <assertion id="ca">
- <text>Array-valued ~or annotation-valued~ members of a binding type must be annotated |@NonBinding|. If an array-valued ~or annotation-valued~ member of a binding type is not annotated |@NonBinding|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
- </assertion>
-
- <assertion id="cb">
- <text>~Array-valued or ~annotation-valued members of a binding type must be annotated |@NonBinding|. If an ~array-valued or ~annotation-valued member of a binding type is not annotated |@NonBinding|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
- </assertion>
+ <assertion id="e">
+ <text>Test with an annotation-valued member.</text>
+ </assertion>
+ </group>
</section>
- <section id="5.3.6" title="Multiple bindings">
+ <section id="5.3.6" title="Multiple qualifiers">
<assertion id="a">
- <text>A bean class may declare multiple bindings</text>
+ <text>A bean class may declare multiple qualifiers.</text>
</assertion>
<assertion id="b">
- <text>A producer method may declare multiple bindings</text>
+ <text>A producer method may declare multiple qualifiers.</text>
</assertion>
<assertion id="c">
- <text>A producer field may declare multiple bindings</text>
+ <text>A producer field may declare multiple qualifiers.</text>
</assertion>
<assertion id="d">
- <text>A bean must declare all of the bindings that are specified at the injection point to be considered a candidate for injection</text>
+ <text>A bean must declare all of the qualifiers that are specified at the injection point to be considered a candidate for injection.</text>
</assertion>
</section>
<section id="5.4" title="EL Name resolution">
- <assertion id="ba">
- <text>When resolving a bean by name, the container identifies the set of matching beans which have the given EL name, and are accessible to classes in the war containing the JSP or JSF page with the EL expression, according to the class loading requirements of the Java EE platform and Java Servlet specifications, and which are not a policy or an enabled policy of the war containing the JSP or JSF page with the EL expression.</text>
+ <assertion id="baa">
+ <text>When resolving a bean by name, the container identifies the set of matching beans which have the given EL name, and are enabled, and are either not an alternative, or is a selected alternative of the war containing the JSP or JSF page with the EL expression, and are accessible to classes in the war containing the JSP or JSF page with the EL expression, according to the class loading requirements of the Java EE platform and Java Servlet specifications, and which are not a policy or an enabled policy of the war containing the JSP or JSF page with the EL expression.</text>
</assertion>
<assertion id="e">
@@ -2122,16 +2140,16 @@
</section>
<section id="5.4.1" title="Ambiguous EL names">
- <assertion id="c">
- <text>An ambiguous EL name exists in an EL expression when there are multiple beans which match the given EL name. When an ambiguous EL name exists, the container attempts to resolve the ambiguity - if any matching beans are policies, the container eliminates all matching beans that are not policies. The container eliminates all matching beans that are specialized by some other matching bean. If there is exactly one bean remaining, the container will select this bean, and the ambiguous name is called resolvable.</text>
+ <assertion id="ca">
+ <text>An ambiguous EL name exists in an EL expression when there are multiple beans which match the given EL name. When an ambiguous EL name exists, the container attempts to resolve the ambiguity - if any matching beans are alternatives, the container eliminates all matching beans that are not alternatives.If there is exactly one bean remaining, the container will select this bean, and the ambiguous name is called resolvable.</text>
</assertion>
<assertion id="da">
- <text>All unresolvable ambiguous EL names are detected by the container when the application is initialized. Suppose two beans are both accessible to classes in a certain war, according to the class loading requirements of the Java EE platform and Java Servlet specifications. If each bean is either not a policy, or is an enabled policy of the war, and either _the two beans have the same EL name and the name is not resolvable_, or the EL name of one bean is of the form x.y, where y is a valid bean EL name, and x is the EL name of the other bean, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <text>All unresolvable ambiguous EL names are detected by the container when the application is initialized. Suppose two beans are both accessible to classes in a certain war, according to the class loading requirements of the Java EE platform and Java Servlet specifications. If each bean is either not an alternative, or is a selected alternative of the war, and either _the two beans have the same EL name and the name is not resolvable_, or the EL name of one bean is of the form x.y, where y is a valid bean EL name, and x is the EL name of the other bean, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
<assertion id="db">
- <text>All unresolvable ambiguous EL names are detected by the container when the application is initialized. Suppose two beans are both accessible to classes in a certain war, according to the class loading requirements of the Java EE platform and Java Servlet specifications. If each bean is either not a policy, or is an enabled policy of the war, and either the two beans have the same EL name and the name is not resolvable, _or the EL name of one bean is of the form x.y, where y is a valid bean EL name, and x is the EL name of the other bean_, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <text>All unresolvable ambiguous EL names are detected by the container when the application is initialized. Suppose two beans are both accessible to classes in a certain war, according to the class loading requirements of the Java EE platform and Java Servlet specifications. If each bean is either not an alternative, or is a selected alternative of the war, and either the two beans have the same EL name and the name is not resolvable, _or the EL name of one bean is of the form x.y, where y is a valid bean EL name, and x is the EL name of the other bean_, the container automatically detects the problem and treats it as a deployment problem, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
</section>
@@ -2303,11 +2321,11 @@
</assertion>
<assertion id="c">
- <text>When the container calls a producer method, if the method is non-static the container must determine the most specialized enabled bean that specializes the bean which declares the method, as defined in Section 4.3.2 "Most specializaed enabled bean for a bean", then obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.</text>
+ <text>When the container calls a producer method, if the method is non-static the container must obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.</text>
</assertion>
<assertion id="d">
- <text>When the container calls a disposal method, if the method is non-static the container must determine the most specialized enabled bean that specializes the bean which declares the method, as defined in Section 4.3.2 "Most specializaed enabled bean for a bean", then obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.</text>
+ <text>When the container calls a disposal method, if the method is non-static the container must obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.</text>
</assertion>
<assertion id="e">
@@ -2321,7 +2339,7 @@
</assertion>
<assertion id="b">
- <text>When the container accesses the value of a producer field, if the producer field is non-static, the container must determine the most specialized enabled bean that specializes the bean which declares the producer field, as defined in Section 4.3.2 "Most specialized enabled bean for a bean", then obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then access the field value of this instance.</text>
+ <text>When the container accesses the value of a producer field, if the producer field is non-static, the container must obtain a contextual instance of the most specialized bean, as defined by Section 6.5.2 "Contextual instance of a bean", then access the field value of this instance.</text>
</assertion>
</section>
@@ -2330,8 +2348,8 @@
<text>When the container calls an observer method (defined in Section 10.4 "Observer methods"), if the observer method is static, the container must invoke the method.</text>
</assertion>
- <assertion id="ba">
- <text>When the container calls an observer method (defined in Section 10.5 "Observer methods"), if the observer method is non-static, the container must determine the most specialized enabled bean that specializes the bean which declares the observer method, as defined in Section 4.3.2 "Most specialized enabled bean for a bean", then obtain a contextual instance of the bean according to Section 6.5.2 "Contextual instance of a bean". If this observer method is a conditional observer method, obtain the contextual instance that already exists, without creating a new contextual instance. Finally, the container must invoke the observer method on the resulting instance, if any, as a business method invocation, as defined in Section 7.2 "Container invocations and interception".</text>
+ <assertion id="baa">
+ <text>When the container calls an observer method (defined in Section 10.5 "Observer methods"), if the observer method is non-static, the container must obtain a contextual instance of the bean according to Section 6.5.2 "Contextual instance of a bean". If this observer method is a conditional observer method, obtain the contextual instance that already exists, only if the scope of the bean that declares the observer method is currently active, without creating a new contextual instance. Finally, the container must invoke the observer method on the resulting instance, if any, as a business method invocation, as defined in Section 7.2 "Container invocations and interception".</text>
</assertion>
<assertion id="c">
@@ -2353,7 +2371,7 @@
</assertion>
<assertion id="bc">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getQualifiers()| method returns the declared bindings of the injection point.</text>
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getQualifiers()| method returns the declared qualifiers of the injection point.</text>
</assertion>
<assertion id="ca">
@@ -2365,7 +2383,7 @@
</assertion>
<assertion id="cc">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Constructor| object in the case of constructor parameter injection</text>
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Constructor| object in the case of constructor parameter injection.</text>
</assertion>
<assertion id="daa">
@@ -2381,7 +2399,7 @@
</assertion>
<assertion id="ea">
- <text>The container must provide a bean with scope |@Dependent|, bean type |InjectionPoint| and binding |@Current|, allowing dependent objects, as defined in Section 6.4.2, "Dependent objects", to obtain information about the injection point to which they belong.</text>
+ <text>The container must provide a bean with scope |@Dependent|, bean type |InjectionPoint| and qualifier |@Default|, allowing dependent objects, as defined in Section 6.4.1, "Dependent objects", to obtain information about the injection point to which they belong.</text>
</assertion>
<assertion id="eb">
@@ -2389,11 +2407,11 @@
</assertion>
<assertion id="f">
- <text>If a bean that declares any scope other than |@Dependent| has an injection point of type |InjectionPoint| and binding |@Current|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <text>If a bean that declares any scope other than |@Dependent| has an injection point of type |InjectionPoint| and binding |@Default|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
- <assertion id="g">
- <text>If an object that is not a bean has an injection point of type |InjectionPoint| and binding |@Current|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
+ <assertion id="ga">
+ <text>If a Java EE component class supporting injection that is not a bean has an injection point of type |InjectionPoint| and binding |@Default|, the container automatically detects the problem and treats it as a definition error, as defined in Section 12.4, "Problems detected automatically by the container".</text>
</assertion>
</section>
@@ -2407,37 +2425,37 @@
</assertion>
<assertion id="ca">
- <text>Any combination of bindings may be specified at the injection point.</text>
+ <text>Any combination of qualifiers may be specified at the injection point.</text>
</assertion>
<assertion id="da">
- <text>The |@Any| binding may be used to allow the application to specify bindings dynamically.</text>
+ <text>The |@Any| qualifier may be used to allow the application to specify qualifiers dynamically.</text>
</assertion>
</section>
<section id="5.7.1" title="The Instance interface">
<assertion id="aa">
- <text>The |Instance| interface provides a method for obtaining instances of beans with a specified combination of required type and bindings, and inherites the ability to iterate beans with that combination of required type and bindings from |java.lang.Iterable|.</text>
+ <text>The |Instance| interface provides a method for obtaining instances of beans with a specified combination of required type and qualifiers, and inherites the ability to iterate beans with that combination of required type and qualifiers from |java.lang.Iterable|.</text>
</assertion>
<assertion id="ab">
- <text>For an injected |Instance|, the required type is the type parameter specified at the injection point, and the required bindings are the bindings specified at the injection point.</text>
+ <text>For an injected |Instance|, the required type is the type parameter specified at the injection point, and the required qualifiers are the qualifiers specified at the injection point.</text>
</assertion>
<assertion id="ba">
- <text>The |select()| method returns a child |Instance| for a given required type and additional required bindings. If no required type is given, the required type is the same as the parent.</text>
+ <text>The |select()| method returns a child |Instance| for a given required type and additional required qualifiers. If no required type is given, the required type is the same as the parent.</text>
</assertion>
<assertion id="da">
- <text>If two instances of the same binding type are passed to |select()|, an |IllegalArgumentException| is thrown.</text>
+ <text>If two instances of the same qualifier type are passed to |select()|, an |IllegalArgumentException| is thrown.</text>
</assertion>
<assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to |select()|, an |IllegalArgumentException| is thrown.</text>
+ <text>If an instance of an annotation that is not a qualifier type is passed to |select()|, an |IllegalArgumentException| is thrown.</text>
</assertion>
<assertion id="fa">
- <text>The |get()| method must identify a bean that matches the required type and required bindings and is accessible to the class into which the parent |Instance| was injected, according to the rules of typesafe resolution, as defined in Section 5.3, "Typesafe resolution" and resolving ambiguities according to Section 5.3.1, "Unsatisfied and ambiguous dependencies".</text>
+ <text>The |get()| method must identify a bean that matches the required type and required qualifiers and is accessible to the class into which the parent |Instance| was injected, according to the rules of typesafe resolution, as defined in Section 5.3, "Typesafe resolution" and resolving ambiguities according to Section 5.3.1, "Unsatisfied and ambiguous dependencies".</text>
</assertion>
<assertion id="fba">
@@ -2453,7 +2471,7 @@
</assertion>
<assertion id="ja">
- <text>The |iterator()| method must identify the set of beans that match the required type and required bindings and are accessible to the class into which the parent |Instance| was injected, according to the rules of typesafe resolution, as defined in Section 5.3, "Typesafe resolution".</text>
+ <text>The |iterator()| method must identify the set of beans that match the required type and required qualifiers and are accessible to the class into which the parent |Instance| was injected, according to the rules of typesafe resolution, as defined in Section 5.3, "Typesafe resolution".</text>
</assertion>
<assertion id="ka">
@@ -2461,21 +2479,21 @@
</assertion>
<assertion id="l">
- <text>The method |isUnsatisfied()| returns true if there is no bean that matches the required type and bindings, or false otherwise.</text>
+ <text>The method |isUnsatisfied()| returns true if there is no bean that matches the required type and qualifiers, or false otherwise.</text>
</assertion>
<assertion id="m">
- <text>The method |isAmbiguous()| returns true if there is more than one bean that matches the required type and bindings, or false otherwise.</text>
+ <text>The method |isAmbiguous()| returns true if there is more than one bean that matches the required type and qualifiers, or false otherwise.</text>
</assertion>
</section>
<section id="5.7.2" title="The built-in Instance">
<assertion id="a">
- <text>The container must provide a built-in bean with |Instance<X>| for every legal bean type X in its set of bean types</text>
+ <text>The container must provide a built-in bean with |Instance<X>| and |Provider<X>| for every legal bean type |x| in its set of bean types.</text>
</assertion>
<assertion id="b">
- <text>The container must provide a built-in bean with every binding type in its set of binding types.</text>
+ <text>The container must provide a built-in bean with every qualifier type in its set of qualifier types.</text>
</assertion>
<assertion id="d">
@@ -2517,10 +2535,6 @@
<assertion id="bc">
<text>Otherwise, if a name used in an EL expression resolves to exactly one bean, the |ELResolver| must return a contextual instance of the bean, as defined in Section 6.5.2, "Contextual instance of a bean".</text>
</assertion>
-
- <assertion id="c">
- <text>For each distinct name that appears in the EL expression, the resolver must be called at most once. Even if a name appears more than once in the same expression, the container may not call the resolver multiple times with that name. This restriction ensures that there is a unique instance of each bean with scope |@Dependent| in any EL evaluation.</text>
- </assertion>
</section>
<section id="6" title="Scopes and contexts">
More information about the weld-commits
mailing list