[webbeans-commits] Webbeans SVN: r2744 - tck/trunk/impl/src/main/resources.
webbeans-commits at lists.jboss.org
webbeans-commits at lists.jboss.org
Wed Jun 3 03:36:29 EDT 2009
Author: shane.bryzak at jboss.com
Date: 2009-06-03 03:36:29 -0400 (Wed, 03 Jun 2009)
New Revision: 2744
Modified:
tck/trunk/impl/src/main/resources/tck-audit.xml
Log:
section 5 assertions updated
Modified: tck/trunk/impl/src/main/resources/tck-audit.xml
===================================================================
--- tck/trunk/impl/src/main/resources/tck-audit.xml 2009-06-02 15:19:20 UTC (rev 2743)
+++ tck/trunk/impl/src/main/resources/tck-audit.xml 2009-06-03 07:36:29 UTC (rev 2744)
@@ -1984,9 +1984,6 @@
</section>
<section id="5" title="Lookup, dependency injection and EL resolution">
- <assertion id="a">
- <text>The container is required to ensure that any injected reference to a contextual instance of a bean may be cast to any bean type of the bean.</text>
- </assertion>
<assertion id="b">
<text>The container is required to support circularities in the bean dependency graph</text>
@@ -1994,630 +1991,534 @@
</assertion>
</section>
- <section id="5.1" title="Unsatisfied and ambiguous dependencies">
- <assertion id="a">
- <text>The container must validate all injection points of all enabled beans at deployment time to ensure that there are no unsatisfied or ambiguous dependencies. If an unsatisfied or ambiguous dependency exists, an |UnsatisfiedDependencyException| or |AmbiguousDependencyException| is thrown by the container at deployment time, as defined in Section 5.7.1, "Resolving dependencies".</text>
- <note>These need expanding out - one for each assertion that results in an exception in 5.7.1</note>
+ <section id="5.1" title="Typesafe resolution algorithm">
+
+ <assertion id="faa">
+ <text>When the container is resolving a bean by type, it identifies the set of matching enabled beans which have a bean type that matches the required type.</text>
</assertion>
- </section>
-
- <section id="5.2" title="Primitive types and null values">
-
-
- <assertion id="aa">
- <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>
+
+ <assertion id="fb">
+ <text>Primitive types are considered to be identical to their corresponding wrapper types in |java.lang|.</text>
</assertion>
- <assertion id="ab">
- <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>
- </assertion>
-
- <assertion id="a">
- <text>If an injection point of primitive type resolves to a bean that may be null, such as a producer method with a nonprimitive return type or a producer field with a non-primitive type, a |NullableDependencyException| is thrown by the container at deployment time</text>
+
+ <assertion id="fc">
+ <text>Array types are considered identical only if their element types are identical.</text>
</assertion>
- <assertion id="b">
- <text>The method |Bean.isNullable()| may be used to detect if a bean has null values</text>
+ <assertion id="fd">
+ <text>Parameterized types are considered identical only if both the type and all type parameters are identical.</text>
</assertion>
- </section>
-
- <section id="5.3" title="Injected reference validity">
- <assertion id="a">
- <text>Any reference to a bean with a normal scope is valid as long as the application maintains a hard reference to it. However, it may only be invoked when the context associated with the normal scope is active. If it is invoked when the context is inactive, a |ContextNotActiveException| is thrown by the container</text>
+
+ <assertion id="gaa">
+ <text>_If no bindings were explicitly specified, the container assumes the binding |@Current|_. </text>
</assertion>
- <assertion id="b">
- <text>Any reference to a bean with a pseudo-scope (such as |@Dependent|) is valid until the bean instance to which it refers is destroyed. It may be invoked even if the context associated with the pseudo-scope is not active. If the application invokes a method of a reference to an instance that has already been destroyed, the behavior is undefined</text>
+ <assertion id="gba">
+ <text>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|.</text>
</assertion>
+
+ <assertion id="gca">
+ <text>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. at NonBinding|.</text>
+ </assertion>
+
+ <assertion id="ha">
+ <text>When the container is resolving a bean by type, it examines the deployment types of the matching beans, as defined in Section 2.5.6, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set.</text>
+ </assertion>
+
+ <assertion id="hb">
+ <text>When the container is resolving a bean by type, it examines the deployment types of the matching beans, as defined in Section 2.5.6, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set. _If there are no matching beans, an empty set is returned_</text>
+ </assertion>
</section>
- <section id="5.4" title="Client proxies">
+ <section id="5.1.1" title="Assignability of raw and parameterized types">
+
<assertion id="a">
- <text>Client proxies are never required for a bean whose scope is a pseudo-scope such as |@Dependent|</text>
- </assertion>
+ <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>
<assertion id="b">
- <text>Client proxies are used for normal scoped beans</text>
+ <text>A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter the required type parameter and the bean type parameter are actual types with identical raw type, and, if the type is parameterized, the bean type is assignable to the required type according to these rules.</text>
</assertion>
<assertion id="c">
- <text>All client proxies must be serializable</text>
+ <text>A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter the required type parameter is a wildcard, the bean type parameter is an actual type and the actual type is a subtype of the upper bound, if any, of the wildcard and a supertype of the upper bound, if any, or the wildcard.
+ </text>
</assertion>
-
+
<assertion id="d">
- <text>The container must guarantee that when any valid injected reference to a bean of normal scope is invoked, the invocation is always processed by the current instance of the injected bean.</text>
+ <text>A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter the required type parameter is a wildcard with no lower bound, the bean type parameter is a type variable and the upper bound of the type variable is aa subtype of the upper bound, if any, of the wildcard.</text>
</assertion>
- </section>
-
- <section id="5.4.1" title="Unproxyable bean types">
- <assertion id="a">
- <text>Classes without 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, an |UnproxyableDependencyException| is thrown by the container at deployment time.</text>
+
+ <assertion id="e">
+ <text>A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter the required type parameter is an actual type, the bean type parameter is a type variable and the actual type is a subtype of the upper bound, if any, of the type variable.</text>
</assertion>
-
- <assertion id="ba">
- <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, an |UnproxyableDependencyException| is thrown by the container at deployment time</text>
+
+ <assertion id="f">
+ <text>A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter the required type parameter and the bean type parameter are both type variables and the upper bound of the required type parameter is a subtype of the upper bound, if any, of the bean type parameter</text>
</assertion>
- <assertion id="bb">
- <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, an |UnproxyableDependencyException| is thrown by the container at deployment time</text>
+ <assertion id="g">
+ <text>If the injection point is declared by a parameterized superclass, and the type declaration of the injection point contains type parameters declared by the superclass, the required type is the declared type, after substitution of actual type arguments declared by subclasses.</text>
</assertion>
-
- <assertion id="c">
- <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, an |UnproxyableDependencyException| is thrown by the container at deployment time</text>
- </assertion>
-
- <assertion id="d">
- <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, an |UnproxyableDependencyException| is thrown by the container at deployment time</text>
- </assertion>
+
</section>
- <section id="5.4.2" title="Client proxy invocation">
- <assertion id="a">
- <text>Every time a method of the bean is invoked upon a client proxy, the client proxy must obtain the context object by calling |Manager.getContext()|, passing the bean scope, then obtain an instance of the bean by calling |Context.get()|, passing the Bean instance representing the bean and an instance of |CreationalContext|, and invoke the method upon the bean</text>
- </assertion>
+ <section id="5.1.2" 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>The behavior of all methods declared by |java.lang.Object|, except for |toString()|, is undefined for a client proxy</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 injection points of the bean.</text>
</assertion>
-
- </section>
+
+ </section>
- <section id="5.5" title="The default binding at injection points">
- <assertion id="a">
- <text>If an injection point declares no binding, the default binding |@Current| is assumed</text>
- </assertion>
- </section>
+ <section id="5.1.3" title="Primitive types and null values">
- <section id="5.6" title="Injection point metadata">
- <assertion id="a">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getBean()| method returns the Bean object representing the bean that defines the injection point</text>
+ <assertion id="aa">
+ <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>
</assertion>
+ <assertion id="ab">
+ <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>
+ </assertion>
+
+ <assertion id="aa">
+ <text>If an injection point of primitive type resolves to a bean that may have null values, such as a producer method with a nonprimitive return type or a producer field with a non-primitive type, 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="ba">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getType()| method returns the declared type of the injection point.</text>
+ <text>For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls |isNullable()| to determine whether the bean may have null values.</text>
</assertion>
-
- <assertion id="bb">
- <text>An injection point declared in XML has it's type determined according to Section 9.10, "Specifying bean types and bindings"</text>
+ </section>
+
+ <section id="5.1.4" title="Binding annotations with members">
+ <assertion id="a" testable="false">
+ <text>Binding types with members are supported</text>
+ <note>A statement of intent</note>
</assertion>
- <assertion id="bc">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getBindings()| method returns the declared bindings of the injection point.</text>
+ <assertion id="b">
+ <text>An annotation member may be excluded from consideration using the |@NonBinding| annotation</text>
</assertion>
<assertion id="ca">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Field| object in the case of field injection</text>
+ <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>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Method| object in the case of method parameter injection</text>
+ <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="cc">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Constructor| object in the case of constructor parameter injection</text>
+ </section>
+
+ <section id="5.1.5" title="Multiple bindings">
+ <assertion id="a">
+ <text>A bean class may declare multiple bindings</text>
</assertion>
- <assertion id="da">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotation()| method returns annotations of the field in the case of field injection</text>
+ <assertion id="b">
+ <text>A producer method may declare multiple bindings</text>
</assertion>
- <assertion id="db">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotation()| method returns annotations of the parameter in the case of method parameter</text>
- </assertion>
+ <assertion id="c">
+ <text>A producer field may declare multiple bindings</text>
+ </assertion>
- <assertion id="dc">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotation()| method returns annotations annotations of the parameter in the case of constructor parameter injection.</text>
+ <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>
</assertion>
+ </section>
+
+ <section id="5.2" title="EL Name resolution algorithm">
- <assertion id="dd">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotations()| method returns annotations of the field in the case of field injection</text>
+ <assertion id="b">
+ <text>When resolving a bean by name, the container must identify the set of matching enabled beans which have the given EL name</text>
</assertion>
- <assertion id="de">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotations()| method returns annotations of the parameter in the case of method parameter</text>
+ <assertion id="c">
+ <text>After the container identifies the set of matching beans, it examines the deployment types of the matching beans, as defined in Section 2.5.6, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set.</text>
</assertion>
- <assertion id="df">
- <text>The |javax.enterprise.inject.spi.InjectionPoint.getAnnotations()| method returns annotations annotations of the parameter in the case of constructor parameter injection.</text>
+ <assertion id="d">
+ <text>If there are no matching beans, an empty set is returned.</text>
</assertion>
-
- <assertion id="dg">
- <text>|getAnnotation()| returns a null value if no annotation of the given type exists at the field injection point</text>
+ </section>
+
+ <section id="5.2.1" title="Ambiguous EL names">
+ <assertion id="a">
+ <text>If, in a particular deployment two enabled beans have the same EL name and the same deployment type, 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="dh">
- <text>|getAnnotation()| returns a null value if no annotation of the given type exists at the method parameter injection point</text>
+ <assertion id="b">
+ <text>If, in a particular deployment, the EL name of an enabled bean is of the form |x.y|, where |y| is a valid bean EL name, and |x| is the EL name of some other enabled 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="di">
- <text>|getAnnotation()| returns a null value if no annotation of the given type exists at the constructor injection point</text>
- </assertion>
-
</section>
- <section id="5.6.1" title="Injecting InjectionPoint">
-
- <assertion id="za">
- <text>The container must provide a bean with deployment type |@Standard|.</text>
+ <section id="5.3" title="Client proxies">
+ <assertion id="a">
+ <text>Client proxies are never required for a bean whose scope is a pseudo-scope such as |@Dependent|</text>
</assertion>
- <assertion id="zb">
- <text>The container must provide a bean with scope |@Dependent|.</text>
+ <assertion id="b">
+ <text>Client proxies are used for normal scoped beans</text>
</assertion>
- <assertion id="zc">
- <text>The container must provide a bean with bean type |InjectionPoint|.</text>
+ <assertion id="d">
+ <text>The container must guarantee that when any valid injected reference to a bean of normal scope is invoked, the invocation is always processed by the current instance of the injected bean.</text>
</assertion>
-
- <assertion id="zd">
- <text>The container must provide a bean with binding |@Current|.</text>
- </assertion>
+ </section>
- <assertion id="a">
- <text>Whenever a |@Dependent| scoped object is instantiated by the container for injection into a second bean, any injection point of type |InjectionPoint| and binding |@Current| receives an instance of |InjectionPoint| that represents the injection point of the second bean</text>
+ <section id="5.3.1" title="Unproxyable bean types">
+ <assertion id="aa">
+ <text>Classes without 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>
</assertion>
- <assertion id="b">
- <text>When a |@Dependent| scoped object is instantiated by the container to receive a producer method, any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ <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>
- <assertion id="c">
- <text>When a |@Dependent| scoped object is instantiated by the container to receive a producer field, any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ <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="d">
- <text>When a |@Dependent| scoped object is instantiated by the container to receive an observer , any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ <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>
</assertion>
- <assertion id="e">
- <text>When a |@Dependent| scoped object is instantiated by the container to receive a disposal method invocation, any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ <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>
</assertion>
-
- <assertion id="f">
- <text>When a |@Dependent| scoped object is instantiated by the container during EL expression evaluation, any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ </section>
+
+ <section id="5.3.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>
- <assertion id="g">
- <text>When a |@Dependent| scoped object is instantiated by the container as a result of a direct call to the Manager API, any injection point of type |InjectionPoint| and binding |@Current| receives a null value</text>
+ <assertion id="b">
+ <text>The behavior of all methods declared by |java.lang.Object|, except for |toString()|, is undefined for a client proxy</text>
</assertion>
-
- <assertion id="h">
- <text>If a bean that declares any scope other than |@Dependent| has an injection point of type |InjectionPoint| and binding |@Current|, a |DefinitionException| is thrown by the container at deployment time</text>
- </assertion>
-
- <assertion id="i">
- <text>If an object that is not a bean has an injection point of type |InjectionPoint| and binding |@Current|, a |DefinitionException| is thrown by the container at deployment time</text>
- </assertion>
- </section>
+
+ </section>
- <section id="5.7" title="The Manager object">
-
- </section>
-
- <section id="5.7.1" title="Resolving dependencies">
- <assertion id="a" testable="false">
- <text>Implementations of Bean maintain a reference to an instance of |Manager|</text>
+ <section id="5.4" 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>
<assertion id="b">
- <text>When the |Bean| implementation performs dependency injection, it must obtain the contextual instances to inject by calling |Manager.getInstanceToInject()|, passing an instance of |InjectionPoint| that represents the injection point and the instance of |CreationalContext| that was passed to |Bean.create()|</text>
+ <text>The container is required to perform dependency injection whenever it creates a contextual instance of a managed bean.</text>
</assertion>
<assertion id="c">
- <text>|Manager.getInstanceToInject()| returns a contextual instance or client proxy to be injected to the given injection point</text>
+ <text>The container is required to perform dependency injection whenever it instantiates non-contextual instances of session beans (for example, session beans obtained by the application from JNDI or injected using |@EJB|).</text>
</assertion>
<assertion id="d">
- <text>The |Manager.getInstanceToInject()| method must Identify the bean by calling |Manager.resolveByType()|, passing the type and bindings of the injection point</text>
+ <text>The container is required to perform dependency injection whenever it instantiates non-contextual instances of managed beans.</text>
</assertion>
-
+
<assertion id="e">
- <text>The |Manager.getInstanceToInject()| method must throw an |UnsatisfiedDependencyException| if |resolveByType()| did not return a bean</text>
+ <text>The container is required to perform dependency injection whenever it instantiates instances of any other Java EE component class supporting injection.</text>
</assertion>
<assertion id="f">
- <text>The |Manager.getInstanceToInject()| method must throw an |AmbiguousDependencyException| if |resolveByType()| returned more than one bean</text>
+ <text>In a Java EE 5 environment, the container is not required to support injection for non-contextual objects.</text>
</assertion>
<assertion id="g">
- <text>The |Manager.getInstanceToInject()| method must throw an |UnproxyableDependencyException| if the bean has a normal scope and the type cannot be proxied by the container, as defined in Section 5.4.1, "Unproxyable bean types"</text>
+ <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>
-
- <assertion id="h">
- <text>The |Manager.getInstanceToInject()| method must obtain an instance of the bean (or a client proxy) by calling |Manager.getInstance()|, passing the |Bean| object representing the bean, and return it. Alternatively, return an incompletely initialized instance of the bean that was registered by calling |CreationalContext.push()|, as defined in Section 6.1, "The Contextual interface"</text>
- </assertion>
</section>
- <section id="5.7.2" title="Obtaining contextual instances">
+ <section id="5.4.1" title="Injectable references">
<assertion id="a">
- <text>Any bean may obtain an instance of |Manager| by injecting it</text>
+ <text>To obtain an injectable reference for an injection point, the container must identify a bean according to the rules defined in Section 5.1, "Typesafe resolution algorithm".</text>
</assertion>
- <assertion id="aa">
- <text>The container provides a built-in bean with bean type |Manager|</text>
- </assertion>
-
- <assertion id="ab">
- <text>The container-provided |Manager| bean has a scope type of |@Dependent|</text>
- </assertion>
-
- <assertion id="ac">
- <text>The container-provided |Manager| bean has a deployment type of |@Standard|</text>
- </assertion>
-
- <assertion id="ad">
- <text>The container-provided |Manager| bean has a binding of |@Current|.</text>
- </assertion>
-
<assertion id="b">
- <text>The application may obtain the |Manager| object from JNDI. The container must register an instance of |Manager| with name |java:app/Manager| in JNDI at deployment time</text>
+ <text>If typesafe resolution resulted in an empty set, throw an |UnsatisfiedResolutionException|.</text>
</assertion>
<assertion id="c">
- <text>A contextual instance of a bean may be obtained by calling |Manager.getInstance()|, passing the |Bean| object representing the bean</text>
+ <text>If typesafe resolution resulted in more than one bean, throw an |AmbiguousResolutionException|.</text>
</assertion>
<assertion id="d">
- <text>|Manager.getInstance()| returns a contextual instance or client proxy for the given bean</text>
+ <text>Otherwise, obtain a contextual reference for this bean for the type of the injection point according to Section 6.5.3, "Contextual reference for a bean".</text>
</assertion>
<assertion id="e">
- <text>If the given Bean instance represents a bean with a normal scope, as defined in Section 8.2, "Normal scopes and pseudo-scopes", |Manager.getInstance()| must return a client proxy</text>
+ <text>The container is permitted to directly inject a contextual instance of the bean, as defined in Section 6.5.2, "Contextual instance of a bean".</text>
</assertion>
<assertion id="f">
- <text>If the Bean instance represents a bean with a pseudo-scope, as defined in Section 8.2, "Normal scopes and pseudo-scopes", |Manager.getInstance()| must obtain the context object by calling |Manager.getContext()|, passing the bean scope, then obtain an instance of the bean by calling |Context.get()|, passing the Bean instance representing the bean and an instance of |CreationalContext|</text>
+ <text>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.</text>
</assertion>
- <assertion id="g" testable="false">
- <text>The |Manager.getInstanceByType()| methods obtain a contextual instance of a bean</text>
- <note>A statement of intent</note>
+ </section>
+
+ <section id="5.4.2" title="Injected reference validity">
+ <assertion id="c">
+ <text>Injected references to a bean are valid until the object into which they were injected is destroyed. The application should not invoke a method of an invalid reference. If the application invokes a method of an injected reference after the object into which it was injected has been destroyed, the behavior is undefined.</text>
</assertion>
-
- <assertion id="h">
- <text>If no bindings are passed to |Manager.getInstanceByType()|, the default binding |@Current| is assumed</text>
+ </section>
+
+ <section id="5.4.3" title="Injection using the bean constructor">
+ <assertion id="a">
+ <text>When the container instantiates a managed bean with a constructor annotated |@Initializer|, the container calls this constructor, passing an injectable reference to each parameter. If there is no constructor annotated |@Initializer|, the container calls the constructor with no parameters.</text>
+ </assertion>
+ </section>
+
+ <section id="5.4.4" title="Injection of fields and initializer methods">
+ <assertion id="a">
+ <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 after injection of Java EE component environment resources has been performed and before the |@PostConstruct| callback occurs and before the servlet |init()| method is called. The container sets the value of each injected field to an injectable reference.</text>
</assertion>
- <assertion id="ia">
- <text>If a parameterized type with a type parameter ~or wildcard~ is passed to |resolveByType()|, an |IllegalArgumentException| is thrown</text>
+ <assertion id="b">
+ <text>After the container initializes the values of the injected fields, it must call all initializer methods, passing an injectable reference to each parameter.</text>
</assertion>
- <assertion id="ib">
- <text>If a parameterized type with a ~type parameter or~ wildcard is passed to |resolveByType()|, an |IllegalArgumentException| is thrown</text>
+ <assertion id="c">
+ <text>After the container calls initializer methods, it must build the interceptor and decorator stacks for the instance (if the component has interceptors or decorators).</text>
+ </assertion>
+ </section>
+
+ <section id="5.4.5" title="Destruction of dependent objects">
+ <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.3, "Dependent object destruction", after the |@PreDestroy| callback completes and after the servlet |destroy()| method is called.</text>
+ </section>
+
+ <section id="5.4.6" 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>
- <assertion id="j">
- <text>If two instances of the same binding type are passed to |getInstanceByType()|, a |DuplicateBindingTypeException| is thrown</text>
+ <assertion id="b">
+ <text>When the container calls a disposal method, if the method is static, the container must invoke the method.</text>
</assertion>
- <assertion id="k">
- <text>If an instance of an annotation that is not a binding type is passed to |getInstanceByType()|, an |IllegalArgumentException| is thrown</text>
+ <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>
</assertion>
- <assertion id="l">
- <text>The |getInstanceByType()| method must identify the bean by calling |Manager.resolveByType()|, passing the given type and bindings</text>
+ <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>
</assertion>
- <assertion id="m">
- <text>The |getInstanceByType()| method must throw an |UnsatisfiedDependencyException| if |resolveByType()| did not return a bean</text>
+ <assertion id="e">
+ <text>The container passes an injectable reference to each injected method parameter. The container is also responsible for destroying dependent objects created during this invocation, as defined in Section 6.4.3 "Dependent object destruction".</text>
+ </assertion>
+ </section>
+
+ <section id="5.4.7" 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>
- <assertion id="n">
- <text>The |getInstanceByType()| method must throw an |AmbiguousDependencyException| if |resolveByType()| returned more than one bean</text>
+ <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>
</assertion>
-
- <assertion id="o">
- <text>The |getInstanceByType()| method must obtain an instance of the bean (or a client proxy) by calling |Manager.getInstance()|, passing the Bean object representing the bean, and return it</text>
- </assertion>
</section>
- <section id="5.8" title="Dynamic lookup">
-
+ <section id="5.4.8" title="Invocation of observer methods">
<assertion id="a">
- <text>An instance of the |javax.inject.Instance| interface may be injected via use of the
-|@javax.inject.Obtains| binding</text>
+ <text>When the container calls an observer method (defined in Section 10.5 "Observer methods"), if the observer method is static, the container must invoke the method.</text>
</assertion>
<assertion id="b">
- <text>Additional bindings may be specified at the injection point</text>
+ <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.</text>
</assertion>
<assertion id="c">
- <text>The |Instance| interface provides a method for obtaining instances of beans of a specific type</text>
+ <text>The container must pass the event object to the event parameter and an injectable instance to each injected method parameter.</text>
</assertion>
<assertion id="d">
- <text>If two instances of the same binding type are passed to |Instance.get()|, a |DuplicateBindingTypeException| is thrown</text>
+ <text>The container is also responsible for destroying dependent objects created during this invocation, as defined in Section 6.4.3, "Dependent object destruction".</text>
+ </assertion>
+ </section>
+
+ <section id="5.4.9" 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>
- <assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to |Instance.get()|, an |IllegalArgumentException| is thrown</text>
+ <assertion id="ba">
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getType()| method returns the declared type of the injection point.</text>
</assertion>
- <assertion id="f">
- <text>The |@Obtains| annotation or |<Obtains>| element may be applied to any injection point of type |Instance| where an actual type parameter is specified</text>
+ <assertion id="bc">
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getBindings()| method returns the declared bindings of the injection point.</text>
</assertion>
- <assertion id="g">
- <text>If the type of the injection point is not of type |Instance| a |DefinitionException| is thrown by the container at deployment time</text>
+ <assertion id="ca">
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Field| object in the case of field injection.</text>
</assertion>
- <assertion id="h">
- <text>If no actual type parameter is specified a |DefinitionException| is thrown by the container at deployment time</text>
+ <assertion id="cb">
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Method| object in the case of method parameter injection.</text>
</assertion>
- <assertion id="i">
- <text>If the type parameter contains a type variable a |DefinitionException| is thrown by the container at deployment time</text>
+ <assertion id="cc">
+ <text>The |javax.enterprise.inject.spi.InjectionPoint.getMember()| method returns the |Constructor| object in the case of constructor parameter injection</text>
</assertion>
- <assertion id="j">
- <text>If the type parameter contains a wildcard a |DefinitionException| is thrown by the container at deployment time</text>
+ <assertion id="daa">
+ <text>The |getAnnotated()| method returns an instance of |javax.enterprise.inject.spi.AnnotatedField| or |javax.enterprise.inject.spi.AnnotatedParameter|, depending upon whether the injection point is an injected field or a constructor/method parameter.</text>
</assertion>
- <assertion id="k" testable="false">
- <text>Whenever the |@Obtains| annotation appears at an injection point, an implicit bean exists with exactly the bean type and bindings that appear at the injection point</text>
- <note>As the bean is implicit, it cannot be resolved</note>
+ <assertion id="dba">
+ <text>The |isDelegate()| method returns true if the injection point is a decorator delegate injection point, and false otherwise.</text>
</assertion>
- <assertion id="l" testable="false">
- <text>Whenever the |@Obtains| annotation appears at an injection point, an implicit bean exists with deployment type |@Standard|</text>
- <note>As the bean is implicit, it cannot be resolved</note>
+ <assertion id="dca">
+ <text>The |isTransient()| method returns true if the injection point is a transient field, and false otherwise.</text>
</assertion>
+
+ <assertion id="e">
+ <text>The container must provide a bean with deployment type |@Standard|, 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. The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".</text>
+ </assertion>
- <assertion id="m" testable="false">
- <text>Whenever the |@Obtains| annotation appears at an injection point, an implicit bean exists with |@Dependent| scope</text>
- <note>As the bean is implicit, it cannot be resolved</note>
+ <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>
</assertion>
- <assertion id="n" testable="false">
- <text>Whenever the |@Obtains| annotation appears at an injection point, an implicit bean exists with no bean name</text>
- <note>As the bean is implicit, it cannot be resolved</note>
+ <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>
+ </section>
+
+ <section id="5.5" title="Programmatic lookup">
+ <assertion id="aa">
+ <text>An instance of the |javax.enterprise.inject.Instance| interface may be injected.</text>
</assertion>
- <assertion id="o" testable="false">
- <text>Whenever the |@Obtains| annotation appears at an injection point, an implicit bean exists with an implementation provided automatically by the container</text>
- <note>As the bean is implicit, it cannot be resolved</note>
+ <assertion id="ba">
+ <text>The method |javax.enterprise.inject.Instance.get()| returns a contextual reference.</text>
</assertion>
- <assertion id="p">
- <text>The |get()| method of the provided implementation of Instance must call |Manager.getInstanceByType()|, passing all bindings declared at the injection point, except |@Obtains|, and all bindings passed to |Instance.get()|</text>
+ <assertion id="ca">
+ <text>Any combination of bindings may be specified at the injection point.</text>
</assertion>
- <assertion id="q">
- <text>The application may obtain a contextual instance by calling the |Instance.get()| method</text>
+ <assertion id="da">
+ <text>The |@Any| binding may be used to allow the application to specify bindings dynamically.</text>
</assertion>
+ </section>
- <assertion id="r">
- <text>When the application calls |Instance.get()| to obtain a contextual instance dynamically, it may need to pass instances of binding annotation types</text>
- </assertion>
- </section>
-
- <section id="5.9" title="Typesafe resolution algorithm">
+ <section id="5.5.1" title="The Instance interface">
<assertion id="a">
- <text>The |resolveByType()| method of the |Manager| interface returns the result of the typesafe resolution</text>
- <note>Here we just do a general test that resolveByType() is producing sensible results</note>
+ <text>The |Instance| interface provides a method for obtaining instances of beans of a specific type, and inherits the ability to iterate
+beans of a specific type from |java.lang.Iterable|.</text>
</assertion>
<assertion id="b">
- <text>If no bindings are passed to |Manager.resolveByType()|, the default binding |@Current| is assumed</text>
+ <text>The |select()| method of the provided implementation of |Instance| returns a child Instance for a subtype of the bean type and additional bindings. If no subtype is given, the bean type is the same as the parent.</text>
</assertion>
- <assertion id="ca">
- <text>If a parameterized type with a type parameter ~or wildcard~ is passed to |Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
+ <assertion id="c">
+ <text>If a parameterized type with a type parameter or wildcard is passed to |select()|, an |IllegalArgumentException| is thrown.</text>
</assertion>
- <assertion id="cb">
- <text>If a parameterized type with a ~type parameter or~ wildcard is passed to |Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
- </assertion>
-
<assertion id="d">
- <text>If two instances of the same binding type are passed to |Manager.resolveByType()|, a |DuplicateBindingTypeException| is thrown</text>
+ <text>If two instances of the same binding type are passed to |select()|, a |DuplicateBindingTypeException| is thrown.</text>
</assertion>
<assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to |Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to |select()|, an |IllegalArgumentException| is thrown.</text>
</assertion>
- <assertion id="fa">
- <text>When the container is resolving a bean by type, it identifies the set of matching enabled beans which have the given bean type.</text>
+ <assertion id="f">
+ <text>The |get()| method of the provided implementation of |Instance| must identify the bean by calling |BeanManager.getBeans()|, passing the type and bindings specified at the injection point. A child |Instance| passes the bean subtype and the additional bindings, along with the bindings of its parent.</text>
</assertion>
- <assertion id="fb">
- <text>When the container is resolving a bean by type~, it identifies the set of matching enabled beans which have the given bean type~. For this purpose, primitive types are considered to be identical to their corresponding wrapper types in |java.lang|~, array types are considered identical only if their element types are identical and parameterized types are considered identical only if both the type and all type parameters are identical~</text>
+ <assertion id="g">
+ <text>If |getBeans()| did not return a bean, throw an |UnsatisfiedResolutionException|.</text>
</assertion>
- <assertion id="fc">
- <text>When the container is resolving a bean by type~, it identifies the set of matching enabled beans which have the given bean type~. For this purpose, ~primitive types are considered to be identical to their corresponding wrapper types in |java.lang|,~ array types are considered identical only if their element types are identical~ and parameterized types are considered identical only if both the type and all type parameters are identical~</text>
+ <assertion id="h">
+ <text>If |getBeans()| returned more than one bean, throw an |AmbiguousResolutionException|.</text>
</assertion>
- <assertion id="fd">
- <text>When the container is resolving a bean by type~, it identifies the set of matching enabled beans which have the given bean type~. For this purpose, ~primitive types are considered to be identical to their corresponding wrapper types in |java.lang|, array types are considered identical only if their element types are identical and~ parameterized types are considered identical only if both the type and all type parameters are identical</text>
+ <assertion id="i">
+ <text>Otherwise, obtain a contextual reference for the bean by calling |BeanManager.getReference()|, passing the |Bean| object representing the bean and the bean type or subtype, and return it.</text>
</assertion>
-
- <assertion id="ga">
- <text>When the container is resolving a bean by type, it considers the given bindings. _If no bindings were passed to |resolveByType()|, the container assumes the binding |@Current|_. </text>
- </assertion>
- <assertion id="gb">
- <text>When the container is resolving a bean by type, it considers the given bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the binding |@Current|~. The container narrows the set of matching beans to just those where for each given binding, the bean declares a binding with _(a) the same type_ and (b) the same annotation member value for each member which is not annotated |@NonBinding| (see Section 5.9.1, "Binding annotations with members")</text>
+ <assertion id="j">
+ <text>The |iterator()| method of the provided implementation of |Instance| must identify the set of beans by calling |BeanManager.getBeans()|, passing the type and bindings specified at the injection point. A child Instance passes the subtype, the bindings specified at the injection point and the additional bindings.</text>
</assertion>
- <assertion id="gc">
- <text>When the container is resolving a bean by type, it considers the given bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the binding |@Current|~. The container narrows the set of matching beans to just those where for each given binding, the bean declares a binding with (a) the same type and _(b) the same annotation member value for each member_ which is not annotated |@NonBinding| (see Section 5.9.1, "Binding annotations with members")</text>
- </assertion>
-
- <assertion id="gd">
- <text>When the container is resolving a bean by type, it considers the given bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the binding |@Current|~. The container narrows the set of matching beans to just those where for each given binding, the bean declares a binding with (a) the same type and (b) the same annotation member value for each member which is _not annotated |@NonBinding|_ (see Section 5.9.1, "Binding annotations with members")</text>
- </assertion>
-
- <assertion id="ha">
- <text>When the container is resolving a bean by type, it examines the deployment types of the matching beans, as defined in Section 2.5.7, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set.</text>
- </assertion>
-
- <assertion id="hb">
- <text>When the container is resolving a bean by type, it examines the deployment types of the matching beans, as defined in Section 2.5.7, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set. _If there are no matching beans, an empty set is returned_</text>
- </assertion>
-
- </section>
+ <assertion id="k">
+ <text>The |iterator()| method of the provided implementation of |Instance| must return an |Iterator|, that iterates over the set of contextual references for the resulting beans by calling |BeanManager.getReference()|, passing the |Bean| object representing the current bean and the bean type or subtype.</text>
+ </assertion>
+ </section>
- <section id="5.9.1" title="Binding annotations with members">
- <assertion id="a" testable="false">
- <text>Binding 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>
- </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|, a |DefinitionException| is thrown by the container at deployment time</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|, a |DefinitionException| is thrown by the container at deployment time</text>
- </assertion>
- </section>
-
- <section id="5.9.2" title="Multiple bindings">
+ <section id="5.5.2" title="The built-in Instance">
<assertion id="a">
- <text>A bean class may declare multiple bindings</text>
+ <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>
</assertion>
<assertion id="b">
- <text>A producer method may declare multiple bindings</text>
+ <text>The container must provide a built-in bean with every binding type in its set of binding types.</text>
</assertion>
<assertion id="c">
- <text>A producer field may declare multiple bindings</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>The container must provide a built-in bean with deployment type @Standard.</text>
</assertion>
- </section>
-
- <section id="5.10" title="EL name resolution">
-
- <assertion id="aa">
- <text>The container must provide a Unified EL ELResolver to the servlet engine ~and JSF implementation~ that resolves bean names</text>
- <note>This is testable implicitly by trying to resolve using EL from a servlet</note>
- </assertion>
- <assertion id="ab">
- <text>The container must provide a Unified EL ELResolver to the ~servlet engine~ and JSF implementation that resolves bean names</text>
- <note>This is testable implicitly by trying to resolve using EL from a JSF view</note>
- </assertion>
-
- <assertion id="b">
- <text>When this resolver is called with a null base object, it calls the method |Manager.getInstanceByName()| to obtain an instance of the bean named in the EL expression</text>
- </assertion>
-
- <assertion id="c">
- <text>The |Manager.getInstanceByName()| method must identify the bean by calling |Manager.resolveByName()|, passing the name</text>
- </assertion>
-
<assertion id="d">
- <text>The |Manager.getInstanceByName()| method must return a null value, if |Manager.resolveByName()| returned an empty set</text>
+ <text>The container must provide a built-in bean with scope @Dependent.</text>
</assertion>
<assertion id="e">
- <text>The |Manager.getInstanceByName()| method must throw an |AmbiguousDependencyException| if |Manager.resolveByName()| returned more than one bean</text>
+ <text>The container must provide a built-in bean with no bean EL name.</text>
</assertion>
<assertion id="f">
- <text>The |Manager.getInstanceByName()| method must obtain an instance of the bean by calling |Manager.getInstance()|, passing the |Bean| instance representing the bean if exactly one bean was returned by |Manager.resolveByName()|. For each distinct name that appears in the EL expression, |getInstanceByName()| must be called at most once</text>
+ <text>The container must provide a built-in bean with an implementation provided automatically by the container. </text>
</assertion>
<assertion id="g">
- <text>Even if a name appears more than once in the same expression, the container may not call |getInstanceByName()| 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>
+ <text>The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".</text>
</assertion>
</section>
- <section id="5.11" title="Name resolution algorithm">
+ <section id="5.5.3" title="Using AnnotationLiteral">
<assertion id="a">
- <text>The |resolveByName()| method of the |Manager| interface performs name resolution</text>
+ <text>When the application calls select(), it may pass instances of binding annotation types.</text>
</assertion>
-
- <assertion id="b">
- <text>When resolving a bean by name, the container must identify the set of matching enabled beans which have the given name</text>
- </assertion>
-
- <assertion id="c">
- <text>After the container identifies the set of matching beans, it examines the deployment types of the matching beans, as defined in Section 2.5.7, "Deployment type precedence", and returns the set of beans with the highest precedence deployment type that occurs in the set</text>
- </assertion>
-
- <assertion id="d">
- <text>If there are no matching beans, an empty set is returned</text>
- </assertion>
</section>
- <section id="5.12" title="Injection into non-contextual objects">
- <assertion id="a" testable="false">
- <text>The container is required to perform dependency injection upon certain non-contextual objects</text>
- <note>This is a statement of intent</note>
+ <section id="5.6" 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 name resolution algorithm defined in Section 5.2 "EL name resolution algorithm".</text>
+ <note>This is testable implicitly by trying to resolve using EL from a servlet</note>
</assertion>
- </section>
-
- <section id="5.12.1" title="Non-contextual instances of session beans">
- <assertion id="a">
- <text>The container is required to perform dependency injection for session bean instances obtained directly from JNDI</text>
- </assertion>
- <assertion id="b">
- <text>The container is required to perform dependency injection for session bean instances injected using |@EJB|</text>
+ <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 name resolution algorithm defined in Section 5.2 "EL name resolution algorithm".</text>
+ <note>This is testable implicitly by trying to resolve using EL from a JSF view</note>
</assertion>
- <assertion id="c">
- <text>The container is required to perform dependency injection for session bean instances injected using |@Resource|</text>
+ <assertion id="ba">
+ <text>If a name used in an EL expression resolves to more than one bean, the |ELResolver| must throw an |AmbiguousResolutionException|.</text>
</assertion>
- <assertion id="d">
- <text>The container is required to perform dependency injection for session bean instances created by the container to receive remote method calls</text>
+ <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="e">
- <text>The container is required to perform dependency injection for session bean instances created by the container to receive timeouts</text>
+ <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="p">
- <text>For the purposes of dependency injection, the container must treat non-contextual instances of session beans as instances of the most specialized bean that specializes the bean with binding |@New| and deployment type |@Standard| defined in Section 3.3.6, "Session beans with the |@New| binding"</text>
+ <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="5.12.2" title="Message-driven beans">
-
- <assertion id="a">
- <text>The container performs dependency injection for message-driven bean instances according to the bean class annotations</text>
- </assertion>
- </section>
-
- <section id="5.12.3" title="Servlets">
- <assertion id="a">
- <text>The container performs dependency injection for servlets according to the servlet class annotations</text>
- </assertion>
- </section>
-
+
<section id="6" title="Bean lifecycle">
<assertion id="a">
<text>To create a contextual instance of a session bean, the container creates an EJB local object reference</text>
More information about the weld-commits
mailing list