1:21 a.m.
Author: shane.bryzak(a)jboss.com
Date: 2009-11-03 02:21:39 -0500 (Tue, 03 Nov 2009)
New Revision: 4588
Modified:
cdi-tck/trunk/impl/src/main/resources/tck-audit-cdi.xml
Log:
updated chapter 5 assertions
Modified: cdi-tck/trunk/impl/src/main/resources/tck-audit-cdi.xml
===================================================================
--- cdi-tck/trunk/impl/src/main/resources/tck-audit-cdi.xml 2009-11-03 00:19:36 UTC (rev
4587)
+++ cdi-tck/trunk/impl/src/main/resources/tck-audit-cdi.xml 2009-11-03 07:21:39 UTC (rev
4588)
@@ -2030,7 +2030,7 @@
</assertion>
</section>
- <section id="5.1" title="Inter-module accessibility in Java
EE">
+ <section id="5.1" title="Modularity">
<group>
<text>Beans packaged in a certain Java EE module or library are available for
injection, lookup and EL resolution to classes and JSP/JSF pages packaged in some other
Java EE module or library if and only if the first module or library is required to be
accessible to the other module or library by the Java EE platform
specification.</text>
@@ -2046,32 +2046,17 @@
<text>Test with EL resolution.</text>
</assertion>
</group>
-
- <assertion id="b">
- <text>For a custom implementation of the |Bean| interface defined in Section
11.1, "The Bean interface", the container calls |getBeanClass()| to determine
the bean class of the bean.</text>
- </assertion>
- <assertion id="c">
- <text>For a custom implementation of |Bean|, defined in Section 11.2,
"The Producer and InjectionTarget interfaces", the container calls
|InjectionPoint.getMember()| and then |Member.getDeclaringClass()| to determine the class
that declares an injection point.</text>
- </assertion>
-
<assertion id="d">
- <text>For a custom implementation of |InjectionTarget|, defined in Section
11.2, "The Producer and InjectionTarget interfaces", the container calls
|InjectionPoint.getMember()| and then |Member.getDeclaringClass()| to determine the class
that declares an injection point.</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>
-
- </section>
-
- <section id="5.2" title="Alternative selection">
- <assertion id="a">
- <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">
+ <assertion id="e">
<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">
+ <section id="5.1.1" title="Declaring selected alternatives for a bean
deployment archive">
<assertion id="c">
<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>
@@ -2125,37 +2110,35 @@
</assertion>
</section>
- <section id="5.2.2" title="Enabled and disabled beans">
+ <section id="5.1.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>
+ <text>A bean is said to be enabled if it is deployed in a bean deployment
archive, as defined by Section 12.1, "Bean deployment archives", and it is not a
producer method or field of a disabled bean, and it is not specialized by any other
enabled bean, as defined in Section 4.3, "Specialization", 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>
+
+ <assertion id="b">
+ <text>Section 3.12, "@New qualified beans" defines a special rule
that determines whether a |@New| qualified bean is enabled or disabled. This rule applies
as only to |@New| qualified beans, as an exception to the normal rule defined
here.</text>
+ </assertion>
</section>
- <section id="5.2.3" title="Inconsistent specialization">
+ <section id="5.1.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.1.4" title="Inter-module injection">
<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>
+ <text>A bean is available for injection in a certain Java EE module or
library if the bean is enabled, the bean is either not an alternative, or the module or
library is a bean deployment archive and the bean is a selected alternative of the bean
deployment archive, and the bean class is required to be accessible to classes in the
module or library, according to the class loading requirements of the Java EE platform and
Java Servlet specifications.</text>
</assertion>
-
- <assertion id="hq">
- <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 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 id="b">
+ <text>For a custom implementation of the |Bean| interface defined in Section
11.1, "The Bean interface, the container calls |getBeanClass()| to determine the bean
class of the bean and |InjectionPoint.getMember()| and then |Member.getDeclaringClass()|
to determine the class that declares an injection point.</text>
</assertion>
-
- <assertion id="hc">
- <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>
-
+ </section>
+
+ <section id="5.2" title="Typesafe resolution">
<group>
- <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>
+ <text>A bean is assignable to a given injection point if the bean has 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.2.3, "Assignability of raw and parameterized
types".</text>
<assertion id="i">
<text>Test with a primitive type.</text>
@@ -2179,7 +2162,7 @@
</group>
<group>
- <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
|(a)javax.enterprise.inject.NonBinding| (see Section 5.3.5, "Qualifier annotations with
members").</text>
+ <text>A bean is assignable to a given injection point if the bean has all the
required qualifiers. If no required qualifiers were explicitly specified, the container
assumes the required qualifier |@Default|. A bean has the required qualifier if it has a
qualifier with (a) the same type and (b) the same annotation member value for each member
which is not annotated |(a)javax.enterprise.inject.NonBinding|.</text>
<assertion id="la">
<text>Test with beans with required qualifiers.</text>
@@ -2199,11 +2182,11 @@
</group>
<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>
+ <text>A bean is eligible for injection to a certain injection point if it is
available for injection in the Java EE module or library that contains the class that
declares the injection point, and it is assignable to the injection point.</text>
</assertion>
<group>
- <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>
+ <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 qualifiers.</text>
<assertion id="na">
<text>Test |getTypes()| determines bean types.</text>
@@ -2215,18 +2198,18 @@
</group>
</section>
- <section id="5.3.1" title="Unsatisfied and ambiguous
dependencies">
+ <section id="5.2.1" title="Unsatisfied and ambiguous
dependencies">
<assertion id="aa">
<text>The container must validate all injection points of all enabled beans
when the application is initialized to ensure that there are no unsatisfied or ambiguous
dependencies. If an unsatisfied or ambiguous dependency exists, 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>
<note>These need expanding out - one for each assertion that results in an
exception in 5.7.1</note>
</assertion>
<assertion id="b">
- <text>For a custom implementation of the Bean interface defined in Section
11.1, "The Bean interface", the container calls |getInjectionPoints()| to
determine the injection points of the bean.</text>
+ <text>For a custom implementation of the |Bean| interface defined in Section
11.1, "The Bean interface", the container calls |getInjectionPoints()| to
determine the set of injection points.</text>
</assertion>
</section>
- <section id="5.3.2" title="Legal injection point types">
+ <section id="5.2.2" title="Legal injection point types">
<assertion id="a">
<text>Any legal bean type, as defined in Section 2.2.1, "Legal bean
types" may be the required type of an injection point.</text>
</assertion>
@@ -2236,11 +2219,11 @@
</assertion>
<assertion id="c">
- <text>If an injection point type is a type variable, 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 an injection point type is a type variable, the container
automatically detects the problem and treats it as a definition error.</text>
</assertion>
</section>
- <section id="5.3.3" title="Assignability of raw and parameterized
types">
+ <section id="5.2.3" title="Assignability of raw and parameterized
types">
<assertion id="a">
<text>A parameterized bean type is considered assignable to a raw required
type if the raw types are identical and all type parameters of the bean type are either
unbounded type variables or |java.lang.Object|.</text>
</assertion>
@@ -2266,7 +2249,7 @@
</assertion>
</section>
- <section id="5.3.4" title="Primitive types and null values">
+ <section id="5.2.4" title="Primitive types and null values">
<group>
<text>If necessary, the container performs boxing or unboxing when it injects
a value to a field or parameter of primitive or wrapper type.</text>
@@ -2288,7 +2271,7 @@
</assertion>
</section>
- <section id="5.3.5" title="Qualifier annotations with
members">
+ <section id="5.2.5" title="Qualifier annotations with
members">
<assertion id="a" testable="false">
<text>Qualifier types with members are supported</text>
<note>A statement of intent</note>
@@ -2303,7 +2286,7 @@
</assertion>
</section>
- <section id="5.3.6" title="Multiple qualifiers">
+ <section id="5.2.6" title="Multiple qualifiers">
<assertion id="a">
<text>A bean class may declare multiple qualifiers.</text>
</assertion>
@@ -2321,32 +2304,34 @@
</assertion>
</section>
- <section id="5.4" title="EL Name resolution">
-
- <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>
+ <section id="5.3" title="EL Name resolution">
+ <assertion id="d">
+ <text>An EL name resolves to a bean if the bean has the given EL name, and
the bean is available for injection in the war containing the JSP or JSF page with the EL
expression.</text>
</assertion>
<assertion id="e">
- <text>For a custom implementation of the Bean interface defined in Section
11.1, "The Bean interface", the container calls |getName()| to determine the
bean EL name.</text>
+ <text>For a custom implementation of the |Bean| interface defined in Section
11.1, "The Bean interface", the container calls |getName()| to determine the
bean EL name.</text>
</assertion>
</section>
- <section id="5.4.1" title="Ambiguous EL names">
+ <section id="5.3.1" title="Ambiguous EL names">
<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>
+ <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 of the beans are alternatives, the container
eliminates all beans that are not alternatives. If there is exactly one bean remaining,
the container will select this bean, and the ambiguous EL name is called
resolvable.</text>
</assertion>
+ <group>
+ <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.</text>
+
<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 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>
+ <text>Test with two beans with the same EL name.</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 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>
+ <text>Test with with an EL name in the form |x.y|.</text>
</assertion>
</section>
- <section id="5.5" title="Client proxies">
+ <section id="5.4" title="Client proxies">
<assertion id="a" testable="false">
<text>Client proxies are never required for a bean whose scope is a
pseudo-scope such as |@Dependent|</text>
</assertion>
@@ -2365,29 +2350,34 @@
</assertion>
</section>
- <section id="5.5.1" title="Unproxyable bean types">
+ <section id="5.4.1" title="Unproxyable bean types">
<assertion id="aa">
- <text>Classes which don't have a non-private constructor with no
parameters cannot be proxied by the container. If an injection point whose declared type
cannot be proxied by the container resolves to a bean with a normal scope, 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>Classes which don't have a non-private constructor with no
parameters cannot be proxied by the container. If an injection point whose declared type
cannot be proxied by the container resolves to a bean with a normal scope, the container
automatically detects the problem and treats it as a deployment problem.</text>
</assertion>
- <assertion id="baa">
- <text>Classes which are declared final ~or have final methods~ cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, 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>
+ <group>
+ <text>Classes which are declared final or have final methods cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, the container automatically detects
the problem and treats it as a deployment problem.</text>
+
+ <assertion id="baa">
+ <text>Test with a final class.</text>
+ </assertion>
- <assertion id="bba">
- <text>Classes which ~are declared final or ~have final methods cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, 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="bba">
+ <text>Test with a class that has final methods.</text>
+ </assertion>
+ </group>
<assertion id="ca">
- <text>Primitive types cannot be proxied by the container. If an injection
point whose declared type cannot be proxied by the container resolves to a bean with a
normal scope, 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>Primitive types cannot be proxied by the container. If an injection
point whose declared type cannot be proxied by the container resolves to a bean with a
normal scope, the container automatically detects the problem and treats it as a
deployment problem.</text>
</assertion>
<assertion id="da">
- <text>Array types cannot be proxied by the container. If an injection point
whose declared type cannot be proxied by the container resolves to a bean with a normal
scope, 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>Array types cannot be proxied by the container. If an injection point
whose declared type cannot be proxied by the container resolves to a bean with a normal
scope, the container automatically detects the problem and treats it as a deployment
problem.</text>
</assertion>
+
</section>
- <section id="5.5.2" title="Client proxy invocation">
+ <section id="5.4.2" title="Client proxy invocation">
<assertion id="aa">
<text>Every time a method of the bean is invoked upon a client proxy, the client
proxy must obtain a contextual instance of the bean, as defined in Section 6.5.2,
"Contextual instance of a bean", and invoke the method upon this
instance.</text>
</assertion>
@@ -2397,12 +2387,12 @@
</assertion>
<assertion id="b" testable="false">
- <text>The behavior of all methods declared by |java.lang.Object|, except for
|toString()|, is undefined for a client proxy</text>
+ <text>The behavior of all methods declared by |java.lang.Object|, except for
|toString()|, is undefined for a client proxy.</text>
</assertion>
</section>
- <section id="5.6" title="Dependency injection">
+ <section id="5.5" title="Dependency injection">
<assertion id="a">
<text>The container is required to perform dependency injection whenever it
creates a contextual instance of a session bean.</text>
</assertion>
@@ -2451,44 +2441,19 @@
<assertion id="g">
<text>The container interacts with instances of beans and other Java EE
component classes supporting injection by calling methods and getting and setting the
field values.</text>
</assertion>
- </section>
-
- <section id="5.6.1" title="Injectable references">
- <assertion id="aa">
- <text>To obtain an injectable reference for an injection point, the container
must identify a bean according to the rules defined in Section 5.3, "Typesafe
resolution" and resolving ambiguities according to Section 5.3.1, "Unsatisfied
and ambiguous dependencies", then obtain a contextual reference for this bean and the
type of the injection point according to Section 6.5.3, "Contextual reference for a
bean".</text>
+
+ <assertion id="h">
+ <text>The object injected by the container may not be a direct reference to a
contextual instance of the bean. Instead, it is an injectable reference, as defined by
Section 6.5.5, "Injectable references".</text>
</assertion>
-
- <assertion id="g">
- <text>For certain combinations of scopes, the container is permitted to
optimize the above procedure by directly injecting a contextual instance of the bean, as
defined in Section 6.5.2, "Contextual instance of a bean". If an incompletely
initialized instance of the bean is registered with the current |CreationalContext|, as
defined in Section
-6.1, "The Contextual interface", the container is permitted to directly inject
this instance. However, in performing these optimizations, the container must respect the
rules of injected reference validity.</text>
- </assertion>
</section>
-
- <section id="5.6.2" title="Injected reference validity">
- <assertion id="d">
- <text>A reference to a bean injected into a field, bean constructor or
initializer method is valid until the object into which it was injected is
destroyed.</text>
- </assertion>
-
- <assertion id="e">
- <text>A reference to a bean injected into a producer method is valid until
the producer method bean instance that is being produced is destroyed.</text>
- </assertion>
-
- <assertion id="f">
- <text>A reference to a bean injected into a disposer method or observer
method is valid until the invocation of the method completes.</text>
- </assertion>
-
- <assertion id="g" testable="false">
- <text>The application should not invoke a method of an invalid reference. If
the application invokes a method of an invalid injected reference, the behavior is
undefined.</text>
- </assertion>
- </section>
-
- <section id="5.6.3" title="Injection using the bean
constructor">
+
+ <section id="5.5.1" title="Injection using the bean
constructor">
<assertion id="a">
<text>When the container instantiates a managed bean with a constructor
annotated |@Inject|, the container calls this constructor, passing an injectable reference
to each parameter. If there is no constructor annotated |@Inject|, the container calls the
constructor with no parameters.</text>
</assertion>
</section>
- <section id="5.6.4" title="Injection of fields and initializer
methods">
+ <section id="5.5.2" title="Injection of fields and initializer
methods">
<group>
<text>When the container creates a new instance of a managed bean, session
bean, or of any other Java EE component class supporting injection, the container must:
Initialize the values of all injected fields. The container sets the value of each
injected field to an injectable reference. Call all initializer methods, passing an
injectable reference to each parameter.</text>
<assertion id="aa">
@@ -2618,13 +2583,13 @@
</group>
</section>
- <section id="5.6.5" title="Destruction of dependent
objects">
+ <section id="5.5.3" title="Destruction of dependent
objects">
<assertion id="a">
<text>When the container destroys an instance of a bean or of any Java EE
component class supporting injection, the container destroys all dependent objects, as
defined in Section 6.4.2, "Dependent object destruction", after the
|@PreDestroy| callback completes and after the servlet |destroy()| method is
called.</text>
</assertion>
</section>
- <section id="5.6.6" title="Invocation of producer or disposal
methods">
+ <section id="5.5.4" title="Invocation of producer or disposal
methods">
<assertion id="a">
<text>When the container calls a producer method, if the method is static,
the container must invoke the method.</text>
</assertion>
@@ -2646,7 +2611,7 @@
</assertion>
</section>
- <section id="5.6.7" title="Access to producer field values">
+ <section id="5.5.5" title="Access to producer field values">
<assertion id="a">
<text>When the container accesses the value of a producer field, if the
producer field is static, the container must access the field value.</text>
</assertion>
@@ -2656,7 +2621,7 @@
</assertion>
</section>
- <section id="5.6.8" title="Invocation of observer methods">
+ <section id="5.5.6" title="Invocation of observer methods">
<assertion id="a">
<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>
@@ -2674,7 +2639,7 @@
</assertion>
</section>
- <section id="5.6.9" title="Injection point metadata">
+ <section id="5.5.7" title="Injection point metadata">
<assertion id="aa">
<text>The |javax.enterprise.inject.spi.InjectionPoint.getBean()| method returns
the Bean object representing the bean that defines the injection point. If the injection
point does not belong to a bean, |getBean()| returns a null value.</text>
</assertion>
@@ -2720,15 +2685,15 @@
</assertion>
<assertion id="f">
- <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>
+ <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.</text>
</assertion>
<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>
+ <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.</text>
</assertion>
</section>
- <section id="5.7" title="Programmatic lookup">
+ <section id="5.6" title="Programmatic lookup">
<assertion id="aa">
<text>An instance of the |javax.enterprise.inject.Instance| interface may be
injected.</text>
</assertion>
@@ -2746,7 +2711,7 @@
</assertion>
</section>
- <section id="5.7.1" title="The Instance interface">
+ <section id="5.6.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 qualifiers, and inherites the
ability to iterate beans with that combination of required type and qualifiers from
|java.lang.Iterable|.</text>
</assertion>
@@ -2805,7 +2770,7 @@
</assertion>
</section>
- <section id="5.7.2" title="The built-in Instance">
+ <section id="5.6.2" title="The built-in Instance">
<assertion id="a">
<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>
@@ -2831,30 +2796,10 @@
</assertion>
</section>
- <section id="5.7.3" title="Using AnnotationLiteral and
TypeLiteral">
+ <section id="5.6.3" title="Using AnnotationLiteral and
TypeLiteral">
</section>
- <section id="5.8" title="Integration with Unified EL">
- <assertion id="aaa">
- <text>The container must provide a Unified EL ELResolver to the servlet engine
~and JSF implementation~ that resolves bean EL names using the rules of name resolution
algorithm defined in Section 5.4 "EL name resolution" and resolving ambiguities
according to Section 5.4.1, "Ambiguous EL names".</text>
- <note>This is testable implicitly by trying to resolve using EL from a
servlet</note>
- </assertion>
-
- <assertion id="aba">
- <text>The container must provide a Unified EL |ELResolver| to the ~servlet
engine~ and JSF implementation that resolves bean EL names using the rules of name
resolution algorithm defined in Section 5.4 "EL name resolution" and resolving
ambiguities according to Section 5.4.1, "Ambiguous EL names".</text>
- <note>This is testable implicitly by trying to resolve using EL from a JSF
view</note>
- </assertion>
-
- <assertion id="bb">
- <text>If a name used in an EL expression does not resolve to any bean, the
|ELResolver| must return a null value.</text>
- </assertion>
-
- <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>
- </section>
-
<section id="6" title="Scopes and contexts">
</section>