| Chapter | Assertions | Testable | Total Tested | Tested (unimplemented) | Tested (implemented) | Coverage % |
|---|---|---|---|---|---|---|
| 2 Bean definition | 143 | 130 | 111 | 25 | 86 | 66.15% |
| 3 Bean Implementation | 321 | 314 | 183 | 71 | 112 | 35.67% |
| 4 Inheritance, specialization and realization | 133 | 120 | 24 | 1 | 23 | 19.17% |
| 5 Lookup, dependency injection and EL resolution | 156 | 153 | 61 | 5 | 56 | 36.60% |
| 6 Bean lifecycle | 115 | 100 | 42 | 12 | 30 | 30.00% |
| 7 Events | 136 | 133 | 133 | 44 | 89 | 66.92% |
| 8 Scopes and contexts | 131 | 120 | 93 | 28 | 65 | 54.17% |
| Total | 1135 | 1070 | 647 | 186 | 461 | 43.08% |
| Colour Key |
|---|
| Assertion is covered |
| Assertion is not covered |
| Assertion test is unimplemented |
| Assertion is untestable |
A bean comprises of a set of interceptor bindings
Coverage
No tests exist for this assertion
For the purposes of the typesafe resolution algorithm defined in Section 5.9, "Typesafe resolution algorithm", parameterized bean types are considered identical by the container only if both the type and the type parameters (if any) are identical
Bean types may not declare a type variable. If the type of an injection point is a parameterized type with a type variable, a DefinitionException is thrown by the container at deployment time.
Bean types may not declare a wildcard. If the type of an injection point is a parameterized type with a wildcard, a DefinitionException is thrown by the container at deployment time.
A bean type may be an array type. Two array types are considered identical only if the element type is identical
All beans have the bean type java.lang.Object
Coverage
If a bean does not explicitly declare a binding, the bean has exactly one binding, of type @javax.inject.Current
Coverage
The @BindingType meta-annotation may be omitted, and the binding type may be declared in beans.xml
Coverage
No tests exist for this assertion
If a bean is declared in beans.xml, bindings may be specified using the binding type names
Binding types may be applied to injected fields (see Section 3.8, "Injected fields") to determine the bean that is injected, according to the typesafe resolution algorithm defined in Section 5.9, "Typesafe resolution algorithm".
Binding types may be applied to parameters of producer methods (see Chapter 3, Bean implementation) to determine the bean instance that is passed when the method is called by the container
Coverage
No tests exist for this assertion
Binding types may be applied to parameters of initializer methods (see Chapter 3, Bean implementation) to determine the bean instance that is passed when the method is called by the container
Binding types may be applied to parameters of disposal methods (see Chapter 3, Bean implementation) to determine the bean instance that is passed when the method is called by the container
Binding types may be applied to parameters of bean constructors (see Chapter 3, Bean implementation) to determine the bean instance that is passed when the method is called by the container
A bean class or producer method or field may specify at most one scope type annotation. If a bean class or producer method or field specifies multiple scope type annotations, a DefinitionException is thrown by the container at deployment time
If more than one scope type is specified in XML, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
A scope type may be specified using a stereotype declared in XML, as defined in Section 2.7.3, "Declaring the stereotypes for a bean using XML"
Coverage
No tests exist for this assertion
If all stereotypes declared by the bean that have some declared default scope have the same default scope, then that scope is the default scope for the bean
If there are two different stereotypes declared by the bean that declare different default scopes, then there is no default scope and the bean must explicitly declare a scope. If it does not explicitly declare a scope, a DefinitionException is thrown by the container at deployment time
An bean class may specify at most one deployment type. If multiple deployment type annotations are specified, a DefinitionException is thrown by the container at deployment time.
A producer method may specify at most one deployment type. If multiple deployment type annotations are specified, a DefinitionException is thrown by the container at deployment time.
A field may specify at most one deployment type. If multiple deployment type annotations are specified, a DefinitionException is thrown by the container at deployment time.
By default, if no deployment type annotation is explicitly specified, a producer method inherits the deployment type of the bean in which it is defined.
By default, if no deployment type annotation is explicitly specified, a producer field inherits the deployment type of the bean in which it is defined.
a deployment type may be specified using a stereotype annotation, as defined in Section 2.7.2, "Declaring the stereotypes for a bean using annotations".
Coverage
No tests exist for this assertion
A deployment type may be specified using a stereotype declared in XML, as defined in Section 2.7.3, "Declaring the stereotypes for a bean using XML".
Coverage
No tests exist for this assertion
The default deployment type for a bean which does not explicitly declare a deployment type depends upon its declared stereotypes - if a bean does not declare any stereotype with a declared default deployment type, then the default deployment type is@Production
Beans declared with a deployment type that is not enabled are not available to the resolution algorithms defined in Chapter 5, Lookup, dependency injection and EL resolution.
If the @Named annotation does not specify the value member, the default name is assumed
Coverage
A default name must be assigned by the container when a producer method of a bean defined using annotations declares a @Named annotation and no name is explicitly specified by the value member
Coverage
A default name must be assigned by the container when a producer field of a bean defined using annotations declares a @Named annotation and no name is explicitly specified by the value member
A default name must be assigned by the container when an empty
Coverage
No tests exist for this assertion
A default name must be assigned by the container when a bean declares a stereotype that declares an empty @Named annotation, and the bean does not explicitly specify a name.
A beans stereotype is a Java annotation defined as @Target({TYPE, METHOD, FIELD}), @Target(TYPE), @Target(METHOD), @Target(FIELD) or @Target({METHOD, FIELD}) and @Retention(RUNTIME)
Coverage
No tests exist for this assertion
A beans stereotype is a Java annotation defined as @Target({TYPE, METHOD, FIELD}), @Target(TYPE), @Target(METHOD), @Target(FIELD) or @Target({METHOD, FIELD}) and @Retention(RUNTIME)
Coverage
No tests exist for this assertion
A beans stereotype is a Java annotation defined as @Target({TYPE, METHOD, FIELD}), @Target(TYPE), @Target(METHOD), @Target(FIELD) or @Target({METHOD, FIELD}) and @Retention(RUNTIME)
Coverage
No tests exist for this assertion
The @Stereotype meta-annotation may be omitted, and the stereotype may be declared in beans.xml
Coverage
No tests exist for this assertion
A stereotype may not declare any binding annotation. If a stereotype declares a binding annotation, a DefinitionException is thrown by the container at deployment time
A stereotype may declare at most one scope. If a stereotype declares more than one scope, a DefinitionException is thrown by the container at deployment time
Coverage
A stereotype may declare at most one deployment type. If a stereotype declares more than one deployment type, a DefinitionException is thrown by the container at deployment time
A stereotype may declare an empty @Named annotation. If a stereotype declares a non-empty @Named annotation, a DefinitionException is thrown by the container at deployment time
Bean types may be restricted using a stereotype
Scope and type restrictions may not be specified when a stereotype is declared in XML
Coverage
No tests exist for this assertion
A stereotype may declare other stereotypes
Coverage
No tests exist for this assertion
Stereotype declarations are transitive - a stereotype declared by a second stereotype is inherited by all beans and other stereotypes that declare the second stereotype
Coverage
No tests exist for this assertion
Stereotypes declared @Target(TYPE) may not be applied to stereotypes declared @Target({TYPE, METHOD, FIELD})
Coverage
No tests exist for this assertion
Stereotypes declared @Target(TYPE) may not be applied to stereotypes declared @Target(METHOD)
Coverage
No tests exist for this assertion
Stereotypes declared @Target(TYPE) may not be applied to stereotypes declared @Target(FIELD)
Coverage
No tests exist for this assertion
Stereotypes declared @Target(TYPE) may not be applied to stereotypes declared @Target({METHOD, FIELD})
Coverage
No tests exist for this assertion
Stereotype annotations may be applied to a producer method
Coverage
Multiple stereotypes may be applied to the same bean
Coverage
If the bean is declared in beans.xml, stereotypes may be declared using the stereotype annotation type name
If a stereotype declares a requiredType, and the bean types do not include the type, a DefinitionException is thrown by the container at deployment time
If a stereotype explicitly declares a set of scope types using supportedScopes, and the bean scope is not in that set, a DefinitionException is thrown by the container at deployment time
Coverage
If a bean declares multiple stereotypes, it must satisfy every restriction declared by every declared stereotype
Coverage
If the application calls a producer method directly, instead of letting the container call it, the returned object is not a contextual instance and the capabilities listed in Section 2.1, "Functionality provided by the container to the bean" will not be available to the returned object.
If the bean class of a simple bean is annotated with both the @Interceptor and @Decorator stereotypes, a DefinitionException is thrown by the container at deployment time.
Multiple simple beans may share the same bean class. This occurs when beans are defined using XML. Only one simple bean per bean class may be defined using annotations.
Coverage
No tests exist for this assertion
If a simple bean with a public field declares any scope other than @Dependent, a DefinitionException is thrown by the container at deployment time.
A top-level interface Java class is a simple bean if it is annotated @Decorator.
Coverage
No tests exist for this assertion
A top-level Java class is not a simple bean if it is annotated with any of the EJB component-defining annotations
Coverage
No tests exist for this assertion
A top-level Java class is not a simple bean if it is declared as an EJB bean class in ejb-jar.xml
Coverage
No tests exist for this assertion
A top-level Java class is not a simple bean if it is declared as a JPA entity in orm.xml
Coverage
No tests exist for this assertion
A top-level Java class is only a simple bean if it has an appropriate constructor - a constructor with no parameters
Coverage
No tests exist for this assertion
A top-level Java class is only a simple bean if it has an appropriate constructor - a constructor annotated @Initializer
Coverage
No tests exist for this assertion
Additional simple beans with the same bean class may be defined using XML, by specifying the class in beans.xml.
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings
Coverage
No tests exist for this assertion
A simple bean may extend another simple bean
Coverage
No tests exist for this assertion
Simple beans may be declared in beans.xml using the bean class name
Coverage
No tests exist for this assertion
A simple bean may even be declared at any injection point declared in XML, as defined in Section 9.9, "Inline bean declarations", in which case no bindings are specified.
Coverage
No tests exist for this assertion
If the bean class of a simple bean defined in XML is a non-static inner class, a DefinitionException is thrown by the container at deployment time.
If the bean class of a simple bean defined in XML is an abstract class, and the simple bean is not a decorator, a DefinitionException is thrown by the container at deployment time
If the bean class of a simple bean defined in XML is annotated @Interceptor, then the bean must be explicitly declared as an interceptor in XML, as defined in Section A.3.5.2, "Declaring an interceptor using XML". If a simple bean defined in XML has a bean class annotated @Interceptor and is not declared as an interceptor in XML, a DefinitionException is thrown by the container at deployment time.
If the bean class of a simple bean defined in XML is annotated @Interceptor, then the bean must be explicitly declared as an interceptor in XML, as defined in Section A.3.5.2, "Declaring an interceptor using XML". If a simple bean defined in XML has a bean class annotated @Interceptor and is not declared as an interceptor in XML, a DefinitionException is thrown by the container at deployment time.
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has the same bean class
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has the same bean constructor defined by annotations
Coverage
No tests exist for this assertion
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has the same bean initializer methods defined by annotations
Coverage
No tests exist for this assertion
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has the same injected fields defined by annotations
Coverage
No tests exist for this assertion
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has the same interceptor bindings defined by annotations
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has scope @Dependent
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has deployment type @Standard
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has @javax.inject.New as the only binding
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no bean name
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no stereotypes
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no observer methods
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no producer methods
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no producer fields
Every class that satisfies the requirements of Section 3.2.1, "Which Java classes are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such simple bean, a second simple bean exists which has no disposal methods
The bean constructor may be identified by annotating the constructor @Initializer
If a simple bean defined using annotations does not explicitly declare a constructor using @Initializer, the constructor that accepts no parameters is the bean constructor
If a simple bean defined using annotations has more than one constructor annotated @Initializer, a DefinitionException is thrown by the container at deployment time
If a bean constructor has a parameter annotated @Disposes, a DefinitionException is thrown by the container at deployment time
If a bean constructor has a parameter annotated @Observes, a DefinitionException is thrown by the container at deployment time
For a simple bean defined using XML, the bean constructor may be specified by listing the parameter types of the constructer, in order, as direct children of the element that declares the bean
Coverage
No tests exist for this assertion
If a simple bean defined using XML does not explicitly declare constructor parameters in XML, the constructor that accepts no parameters is the bean constructor
If a simple bean declared in XML does not have a constructor with the parameter types declared in XML, a DefinitionException is thrown by the container at deployment time
If the bean constructor has parameters, the container calls the method Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies" to determine a value for each parameter and calls the constructor with those parameter values.
If a bean class of a simple bean X defined using annotations is annotated @Specializes, then the bean class of X must directly extend the bean class of another simple bean Y defined using annotations. Then X inherits all bindings of Y, and if Y has a name, X has the same name as Y.
Coverage
If the bean class of X does not directly extend the bean class of another simple bean, a DefinitionException is thrown by the container at deployment time.
Coverage
No tests exist for this assertion
If a simple bean X defined in XML declares the
Coverage
No tests exist for this assertion
A session bean is a bean that is implemented by an EJB 3-style session bean
Coverage
No tests exist for this assertion
A singleton bean must belong to either the @ApplicationScoped scope or to the @Dependent pseudo-scope
If a session bean specifies an illegal scope, a DefinitionException is thrown by the container at deployment time
Coverage
If a session bean is a stateful session bean, and the scope is @Dependent, the application may call any EJB remove method of an instance of the session bean.
Coverage
No tests exist for this assertion
If a session bean is a stateful session bean, and the scope is not @Dependent, the application may not directly call any EJB remove method of any instance of the session bean
If the application directly calls an EJB remove method of an instance of a session bean that is a stateful session bean and declares any scope other than @Dependent, an UnsupportedOperationException is thrown
If the application directly calls an EJB remove method of an instance of a session bean that is a stateful session bean and has scope @Dependent then no parameters are passed to the method by the container.
If the application directly calls an EJB remove method of an instance of a session bean that is a stateful session bean and has scope @Dependent then the container ignores the instance instead of destroying it when Bean.destroy() is called, as defined in Section 6.5, "Lifecycle of stateful session beans"
All session beans exposing an EJB 3.x client view and declared via an EJB component defining annotation on the EJB bean class are beans, and thus no special declaration is required. Additional beans for these EJBs may be defined using XML, by specifying the bean class in beans.xml
All session beans exposing an EJB 3.x client view and declared in ejb-jar.xml are also beans. Additional beans for these EJBs may be defined using XML, by specifying the bean class and EJB name in beans.xml
The set of bean types for a session bean contains all local interfaces of the bean that do not have wildcard type parameters or type variables and their superinterfaces.
If the EJB has a bean class local view and the bean class is not a parameterized type, the set of bean types contains the bean class and all superclasses.
A session bean does not require any special annotations
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings
Coverage
No tests exist for this assertion
A bean class may also specify a scope, name, deployment type, stereotypes and/or bindings~
Coverage
No tests exist for this assertion
A session bean class may extend another bean class
Coverage
No tests exist for this assertion
Session beans may be declared in beans.xml using the bean class name (for EJBs defined using a component-defining annotation) or bean class and EJB name (for EJBs defined in ejb-jar.xml)
Coverage
No tests exist for this assertion
The ejbName attribute declares the EJB name of an EJB defined in ejb-jar.xml
Coverage
No tests exist for this assertion
If an entity bean class is declared in XML, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
If a message-driven bean class is declared in XML, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has the same bean class
Coverage
No tests exist for this assertion
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has the initializer methods and injected fields defined by annotations
Coverage
No tests exist for this assertion
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has the same interceptor bindings defined by annotations
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has scope @Dependent,
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has deployment type @Standard
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has @javax.inject.New as the only binding
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no bean name
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no stereotypes
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no observer methods
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no producer methods
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no producer fields
Every EJB that satisfies the requirements of Section 3.3.2, "Which EJBs are beans?" is a bean, with scope, deployment type and bindings defined using annotations. Additionally, for each such session bean, a second bean exists which has no disposal methods
If a bean class of a session bean X defined using annotations is annotated @Specializes, then the bean class of X must directly extend the bean class of another session bean Y defined using annotations. Then X inherits all bindings of Y, and if Y has a name, X has the same name as Y. Also, X must support all local interfaces supported by Y, and if Y supports a bean-class local view, X must also support a bean-class local view. Otherwise, a DefinitionException is thrown by the container at deployment time.
We say that X directly specializes Y, and we can be certain that Y will never be called by the container if X is enabled
Coverage
No tests exist for this assertion
If the bean class of X does not directly extend the bean class of another session bean, a DefinitionException is thrown by the container at deployment time
Coverage
If a session bean X defined in XML declares the
Coverage
No tests exist for this assertion
The default name for a session bean is the unqualified class name of the bean class, after converting the first character to lower case
EJB local object references do not implement all local interfaces of the EJB. A local object reference may not be typecast to different local interface type, as required by Section 2.2, "Bean types". Therefore, the container proxies the local object reference. A session bean proxy implements all local interfaces of the EJB.
Coverage
No tests exist for this assertion
All session bean proxies must be serializable
Coverage
No tests exist for this assertion
A producer method must be a method of a simple bean class or session bean class
Coverage
No tests exist for this assertion
If a producer method returns a null value at runtime, and the producer method declares any other scope, an IllegalProductException is thrown by the container. This restriction allows the container to use a client proxy, as defined in Section 5.4, "Client proxies".
If a producer method return type contains a wildcard type parameter, a DefinitionException is thrown by the container at deployment time
If a producer method return type contains a type variable, a DefinitionException is thrown by the container at deployment time
The application may call producer methods directly. However, if the application calls a producer method directly, no parameters will be passed to the producer method by the container; the returned object is not bound to any context; and its lifecycle is not managed by the container
If the return type of a producer method is an interface, the set of bean types contains the return type, all interfaces it extends directly or indirectly and java.lang.Object
If a return type of a producer method is primitive or is a Java array type, the set of bean types contains exactly two types: the method return type and java.lang.Object
If the return type of a producer method is a class, the set of bean types contains the return type, every superclass and all interfaces it implements directly or indirectly
A producer method may specify a deployment type
Coverage
If a producer method has a parameter annotated @Disposes, a DefinitionException is thrown by the container at deployment time
If a producer method has a parameter annotated @Observes, a DefinitionException is thrown by the container at deployment time
If a non-static method of a session bean class is annotated @Produces, and the method is not a business method of the EJB, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
For a bean defined in XML, a producer method may be declared using the method name, the
Coverage
No tests exist for this assertion
When a producer method is declared in XML, the container ignores binding annotations applied to the Java method or method parameters
Coverage
No tests exist for this assertion
If the bean class of a bean declared in XML does not have a method with the name and parameter types declared in XML, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
If the producer method has parameters, the container calls the method Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies" to determine a value for each parameter and calls the producer method with those parameter values
Coverage
No tests exist for this assertion
If a producer method X is annotated @Specializes, then it must be non-static and directly override another producer method Y. Then X inherits all bindings of Y, and if Y has a name, X has the same name as Y.
If the method does not directly override another producer method, a DefinitionException is thrown by the container at deployment time
Each disposal method must have exactly one disposed parameter, of the same type as the corresponding producer method return type
When searching for disposal methods for a producer method, the container considers the type and bindings of the disposed parameter. If a disposed parameter resolves to a producer method according to the typesafe resolution algorithm, the container must call this method when destroying an instance returned by that producer method
If the disposed parameter does not resolve to any producer method according to the typesafe resolution algorithm, an UnsatisfiedDependencyException is thrown by the container at deployment time
If a disposed parameter resolves to a producer method according to the typesafe resolution algorithm, the container must call this method when destroying an instance returned by that producer method
A disposal method may be declared using annotations by annotating a parameter @javax.inject.Disposes. That parameter is the disposed parameter
If a non-static method of a session bean class has a parameter annotated @Disposes, and the method is not a business method of the EJB, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
When a disposal method is declared in XML, the container ignores binding annotations applied to the Java method parameter
If the bean class of a bean declared in XML does not have a method with the name and parameter types declared in XML, a DefinitionException is thrown by the container at deployment time
In addition to the disposed parameter, a disposal method may declare additional parameters, which may also specify bindings. The container calls Manager.getInstanceToInject() to determine a value for each parameter of a disposal method and calls the disposal method with those parameter values
When searching for disposal methods for a producer method, the container searches for disposal methods which are declared by an enabled bean, and for which the disposed parameter must resolve to the producer method, according to the typesafe resolution algorithm
The default name for a producer method is the method name, unless the method follows the JavaBeans property getter naming convention, in which case the default name is the JavaBeans property name
A producer field must be a field of a simple bean class or session bean class
Coverage
No tests exist for this assertion
If a producer method contains a null value at runtime, and the producer field declares any other scope, an IllegalProductException is thrown by the container. This restriction allows the container to use a client proxy, as defined in Section 5.4, "Client proxies"
If a producer field return type contains a wildcard type parameter, a DefinitionException is thrown by the container at deployment time
If a producer field return type contains a type variable, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
The bean types of a producer field depend upon the field type. If the field type is an interface, the set of bean types contains the field type, all interfaces it extends directly or indirectly and java.lang.Object
The bean types of a producer field depend upon the field type. If a field type is primitive or is a Java array type, the set of bean types contains exactly two types: the field type and java.lang.Object
The bean types of a producer field depend upon the field type. If the field type is a class, the set of bean types contains the field type, every superclass and all interfaces it implements directly or indirectly
For a bean defined in XML, a producer field may be declared using the field name, the
Coverage
No tests exist for this assertion
When a producer field is declared in XML, the container ignores binding annotations applied to the Java field
Coverage
No tests exist for this assertion
If the bean class of a bean declared in XML does not have a field with the name and type declared in XML, a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
Resources may be declared in beans.xml, allowing direct injection of an EE resource
Coverage
No tests exist for this assertion
Resources may be declared in beans.xml, allowing direct injection of an entity manager
Coverage
No tests exist for this assertion
Resources may be declared in beans.xml, allowing direct injection of an entity manager factory
Coverage
No tests exist for this assertion
Resources may be declared in beans.xml, allowing direct injection of an EJB remote object
Coverage
No tests exist for this assertion
Resources may be declared in beans.xml, allowing direct injection of a web service reference
Coverage
No tests exist for this assertion
The lifecycle of an injected reference is identical to the semantics of Java EE injection using @Resource
Coverage
No tests exist for this assertion
The lifecycle of an injected reference is identical to the semantics of Java EE injection using @PersistenceContext
Coverage
No tests exist for this assertion
The lifecycle of an injected reference is identical to the semantics of Java EE injection using @PersistenceUnit
Coverage
No tests exist for this assertion
The lifecycle of an injected reference is identical to the semantics of Java EE injection using @EJB
Coverage
No tests exist for this assertion
The lifecycle of an injected reference is identical to the semantics of Java EE injection using @WebServiceRef
Coverage
No tests exist for this assertion
A resource always has scope @Dependent
Coverage
No tests exist for this assertion
A resource may not declare a bean name
Coverage
No tests exist for this assertion
A resource may be declared in beans.xml using an element that represents the Java type of the resource. For a Java EE resource, the EE resource type must be specified - for example javax.sql.Datasource for a JDBC datasource. The bean type of the resource is this specified type
Coverage
No tests exist for this assertion
A resource may be declared in beans.xml using an element that represents the Java type of the resource. For a persistence context, javax.persistence.EntityManager must be specified. The bean type of the resource is this specified type
Coverage
No tests exist for this assertion
A resource may be declared in beans.xml using an element that represents the Java type of the resource. For a persistence unit, javax.persistence.EntityManagerFactory must be specified. The bean type of the resource is this specified type
Coverage
No tests exist for this assertion
A resource may be declared in beans.xml using an element that represents the Java type of the resource. For a remote EJB, an EJB remote interface type must be specified. The bean type of the resource is this specified type
Coverage
No tests exist for this assertion
A resource may be declared in beans.xml using an element that represents the Java type of the resource. For a web service, a web service type must be specified. The bean type of the resource is this specified type
Coverage
No tests exist for this assertion
Each resource declaration must contain a child
Coverage
No tests exist for this assertion
Each resource declaration must contain a child
Coverage
No tests exist for this assertion
Each resource declaration must contain a child
Coverage
No tests exist for this assertion
Each resource declaration must contain a child
Coverage
No tests exist for this assertion
Each resource declaration must contain a child
Coverage
No tests exist for this assertion
The JNDI name specified by the
Coverage
No tests exist for this assertion
Optionally, one or more bindings may be specified for resources in XML. If no binding is explicitly specified, the default binding @Current is assumed.
Coverage
No tests exist for this assertion
JMS resources may be declared in beans.xml
Coverage
No tests exist for this assertion
A JMS TopicSession resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS TopicSubscriber resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS TopicPublisher resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS Queue resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS QueueConnection resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS QueueSession resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS QueueReceiver resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS QueueSender resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS Topic resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS TopicConnection resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS TopicSession resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS TopicSubscriber resource may not declare a bean name
Coverage
No tests exist for this assertion
A JMS TopicPublisher resource may not declare a bean name
Coverage
No tests exist for this assertion
JMS resources are always declared using XML
Coverage
No tests exist for this assertion
JMS queue resources must allow the direct injection of the Queue
Coverage
No tests exist for this assertion
JMS queue resources must allow the direct injection of the QueueConnection
Coverage
No tests exist for this assertion
JMS queue resources must allow the direct injection of the QueueSession
Coverage
No tests exist for this assertion
JMS queue resources must allow the direct injection of the QueueReceiver
Coverage
No tests exist for this assertion
JMS queue resources must allow the direct injection of the QueueSender
Coverage
No tests exist for this assertion
JMS topic resources must allow the direct injection of the Topic
Coverage
No tests exist for this assertion
JMS topic resources must allow the direct injection of the TopicConnection
Coverage
No tests exist for this assertion
JMS topic resources must allow the direct injection of the TopicSession
Coverage
No tests exist for this assertion
JMS topic resources must allow the direct injection of the TopicSubscriber
Coverage
No tests exist for this assertion
JMS topic resources must allow the direct injection of the TopicPublisher
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a QueueConnection, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a QueueSession, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a QueueReceiver, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a QueueSender, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a TopicConnection, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a TopicSession, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a TopicSubscriber, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
If the application calls close() on an instance of a TopicPublisher, an UnsupportedOperationException is thrown by the container.
Coverage
No tests exist for this assertion
A JMS Queue resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS QueueConnection resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS QueueSession resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS QueueReceiver resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS QueueSender resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS Topic resource always has scope @Dependent
Coverage
No tests exist for this assertion
A JMS TopicConnection resource always has scope @Dependent
Coverage
No tests exist for this assertion
For JMS resources that represent a queue, the bean types are Queue, QueueConnection, QueueSession and QueueSender
Coverage
No tests exist for this assertion
For JMS resources that represent a topic, the bean types are Topic, TopicConnection, TopicSession and TopicPublisher
Coverage
No tests exist for this assertion
A JMS resource may be declared using the
Coverage
No tests exist for this assertion
Each JMS resource declaration must contain a child
Coverage
No tests exist for this assertion
One or more bindings may be specified. If no binding is explicitly specified, the default binding @Current is assumed
Coverage
No tests exist for this assertion
An injected field is a non-static, non-final field of a servlet.
Coverage
No tests exist for this assertion
An injected field is a non-static, non-final field of any EJB session bean class.
Coverage
No tests exist for this assertion
An injected field is a non-static, non-final field of any message driven bean class.
Coverage
No tests exist for this assertion
Injected fields are initialized by the container immediately after instantiation and before any methods of the instance are invoked. The container calls the method Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies" to determine a value for each injected field
Coverage
No tests exist for this assertion
Any EJB session bean may declare injected fields and have those fields injected by the container
Coverage
No tests exist for this assertion
Any EJB message driven bean may declare injected fields and have those fields injected by the container
Coverage
No tests exist for this assertion
If a field is a producer field, it is not an injected field
Coverage
No tests exist for this assertion
If a field is a decorator delegate attribute, it is not an injected field
Coverage
No tests exist for this assertion
An initializer method is a non-static method of a servlet.
Coverage
No tests exist for this assertion
An initializer method is a non-static method of any EJB session bean class.
Coverage
No tests exist for this assertion
Initializer methods are called by the container immediately after injected fields have been initialized by the container and before any other methods of the instance are invoked.
Coverage
Any EJB session bean may declare initializer methods and have the methods called by the container
Coverage
No tests exist for this assertion
Any EJB message driven bean may declare initializer methods and have the methods called by the container
Coverage
No tests exist for this assertion
If an initializer method has a parameter annotated @Disposes, a DefinitionException is thrown by the container at deployment time
If an initializer method has a parameter annotated @Observes, a DefinitionException is thrown by the container at deployment time
If the bean class of a bean declared in XML does not have a method with the name and parameter types declared in XML, a DefinitionException is thrown by the container at deployment time
An initializer method may have any number of parameters. If the initializer method has parameters, the container calls Manager.getInstanceToInject() to determine a value for each parameter and calls the initializer method with those parameter values
An instance of Bean exists for every enabled bean in a deployment
Coverage
No tests exist for this assertion
An application or third party framework may add support for new kinds of beans beyond those defined by the this specification (simple beans, session beans, producer methods and fields, resources and JMS resources) by extending Bean and registering beans with the container, using the mechanism defined in Section 11.3, "Bean registration".
Coverage
No tests exist for this assertion
By default, Java implementation reuse is assumed
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
For class X which is extended directly by the bean class of a simple bean Y, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
For class X which is extended directly by the bean class of a simple bean Y, if X is annotated with a interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X is annotated with a interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X is annotated with a interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X is annotated with a interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares an annotation of type Z.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a scope type.
For class X which is extended directly by the bean class of a session bean Y, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a scope type.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a scope type.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a scope type.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a deployment type.
For class X which is extended directly by the bean class of a session bean Y, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a deployment type.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a deployment type.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor any intermediate class that is a subclass of X and a superclass of Y declares a deployment type.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scopes and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scopes and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scopes and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scopes and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X is annotated with an interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X is annotated with a binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X is annotated with a stereotype Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X is annotated with an interceptor binding type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare an annotation of type Z using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare a scope type using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X is annotated with a scope type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare a scope type using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare a deployment type using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X is annotated with a deployment type Z then Y inherits the annotation if and only if Z declares the @Inherited meta-annotation and Y does not explicitly declare a deployment type using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scope and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, the scope types and deployment types explicitly declared by and inherited from the class X take precedence over default scope and deployment types declared by stereotypes.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X declares an injected field x then Y inherits x.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares an injected field x then Y inherits x.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares an injected field x then Y inherits x.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a @PostConstruct method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
For class X which is extended directly by the bean class of a session bean Y, if X declares a @PostConstruct method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a @PostConstruct method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a @PostConstruct method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a @PreDestroy method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
For class X which is extended directly by the bean class of a session bean Y, if X declares a @PreDestroy method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a @PreDestroy method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a @PreDestroy method x() then Y inherits x() if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x()
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x().
For class X which is extended directly by the bean class of a session bean Y, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x().
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x().
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y overrides the method x().
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a non-static producer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
For class X which is extended directly by the bean class of a simple bean Y, if X declares a non-static disposal method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a non-static observer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
For class X which is extended directly by the bean class of a session bean Y, if X declares a non-static producer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X declares a non-static disposal method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if X declares a non-static observer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a non-static producer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a non-static disposal method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a non-static observer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a non-static producer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a non-static disposal method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a non-static observer method x() then Y does not inherit this method unless Y is explicitly declared to specialize or realize X
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if X declares a non-static producer field x then Y does not inherit this field unless Y is explicitly declared to specialize or realize X.
For class X which is extended directly by the bean class of a session bean Y, if X declares a non-static producer field x then Y does not inherit this field unless Y is explicitly declared to specialize or realize X.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if X declares a non-static producer field x then Y does not inherit this field unless Y is explicitly declared to specialize or realize X.
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if X declares a non-static producer field x then Y does not inherit this field unless Y is explicitly declared to specialize or realize X.
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a simple bean Y, if Y is a decorator and X declares a delegate attribute x then Y inherits x if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y defines a delegate attribute
Coverage
No tests exist for this assertion
For class X which is extended directly by the bean class of a session bean Y, if Y is a decorator and X declares a delegate attribute x then Y inherits x if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y defines a delegate attribute
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a simple bean Y, if Y is a decorator and X declares a delegate attribute x then Y inherits x if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y defines a delegate attribute
Coverage
No tests exist for this assertion
For class X which is extended indirectly by the bean class of a session bean Y, if Y is a decorator and X declares a delegate attribute x then Y inherits x if and only if neither Y nor any intermediate class that is a subclass of X and a superclass of Y defines a delegate attribute
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares an injected field x then Y inherits x, unless Y explicitly declares x using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares an injected field x then Y inherits x, unless Y explicitly declares x using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares an initializer method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a @PostConstruct method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a @PreDestroy method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares an initializer method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a @PostConstruct method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a @PreDestroy method x() then Y inherits x(), unless Y explicitly declares x() using XML
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding, unless Y explicitly declares x() using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static method x() annotated with an interceptor binding type Z then Y inherits the binding, unless Y explicitly declares x() using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static producer method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static producer method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static disposal method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static disposal method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static observer method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static observer method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static producer method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static producer method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static disposal method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static disposal method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static observer method x() then Y does not inherit this method, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static observer method x() then Y does not inherit this method, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static producer field x then Y does not inherit this field, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if X declares a non-static producer field x then Y does not inherit this field, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static producer field x then Y does not inherit this field, unless Y is explicitly declared to specialize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if X declares a non-static producer field x then Y does not inherit this field, unless Y is explicitly declared to realize X.
Coverage
No tests exist for this assertion
For class X which is the bean class of a simple bean Y declared using XML, if Y is a decorator and X declares a delegate attribute x then Y inherits x, unless Y explicitly declares a delegate attribute using XML.
Coverage
No tests exist for this assertion
For class X which is the bean class of a session bean Y declared using XML, if Y is a decorator and X declares a delegate attribute x then Y inherits x, unless Y explicitly declares a delegate attribute using XML.
Coverage
No tests exist for this assertion
If two beans both support a certain bean type, and share at least one binding, then they are both eligible for injection to any injection point with that declared type and binding. The container will choose the bean with the highest priority enabled deployment type.
Coverage
No tests exist for this assertion
If the bean with the lower priority deployment type declares a binding that is not declared by the bean with the higher priority deployment type, then the bean with the higher priority deployment type will not be eligible for injection to an injection point with that binding.
Coverage
No tests exist for this assertion
The only way one bean can completely override a lower-priority bean at all injection points is if it implements all the bean types and declares all the bindings of the lower-priority bean. However, if the lower-priority bean declares a producer method, then even this is not enough to ensure that the lower-priority bean is never called
Coverage
No tests exist for this assertion
A bean declared using annotations may declare that it specializes a lower-priority bean using the @Specializes annotation
A bean declared using XML may declare that it specializes a lower-priority bean using the
Coverage
No tests exist for this assertion
The bindings of a bean X that specializes a lower-priority bean Y include all bindings of Y, together with all bindings declared explicitly by X.
Coverage
If a bean X specializes a lower-priority bean Y with a name, the name of X is the same as the name of Y.
Coverage
If a bean X specializes a lower-priority bean Y with a name, and X declares a name explicitly, a DefinitionException is thrown by the container at deployment time
Coverage
When an enabled bean specializes a lower-priority bean, we can be certain that the lower-priority bean is never instantiated or called by the container.
Coverage
Even if the lower-priority bean defines a producer method, the method will be called upon an instance of the specializing bean
Any non-static producer methods (see Section 3.4, "Producer methods") of any bean are invoked upon an instance of the most specialized enabled bean that specializes the bean, as defined by Section 6.7, "Lifecycle of producer methods".
Any non-static producer fields (see Section 3.5, "Producer fields") of any bean are invoked upon an instance of the most specialized enabled bean that specializes the bean, as defined by Section 6.8, "Lifecycle of producer fields".
Any non-static disposal methods (see Section 3.4.6, "Disposal methods") of any bean are invoked upon an instance of the most specialized enabled bean that specializes the bean.
Coverage
No tests exist for this assertion
Any non-static observer methods (see Section 7.5, "Observer methods") of any bean are invoked upon an instance of the most specialized enabled bean that specializes the bean, as defined by Section 7.4, "Observer notification".
If, in a particular deployment, either some enabled bean X specializes another enabled bean Y and X does not have a higher precedence than Y, or more than one enabled bean directly specializes the same bean we say that inconsistent specialization exists, and an InconsistentSpecializationException is thrown by the container at deployment time
Coverage
If a generic class Y declares a non-static producer method with a certain combination of scope, stereotypes, bindings and interceptor bindings, then every bean X that realizes Y also has a producer method with the same scope, stereotypes and interceptor bindings. The bindings for this inherited producer method consist of all bindings declared by the producer method of Y, excluding all bindings of Y, together with the bindings declared explicitly by X. The deployment type of the inherited producer method is the deployment type of X
Coverage
If a generic class Y declares a non-static producer field with a certain combination of scope, stereotypes, bindings and interceptor bindings, then every bean X that realizes Y also has a producer field with the same scope, stereotypes and interceptor bindings. The bindings for this inherited producer field consist of all bindings declared by the producer field of Y, excluding all bindings of Y, together with the bindings declared explicitly by X. The deployment type of the inherited producer field is the deployment type of X
Coverage
If a generic class Y declares a non-static disposal method with a disposed parameter with a certain combination of bindings, then every bean X that realizes Y also has a disposal method. The bindings of the disposed parameter of this inherited disposal method consist of all bindings declared by the disposed parameter of the disposal method of Y, excluding all bindings of Y, together with the bindings declared explicitly by X.
If a generic class Y declares a non-static observer method with an event parameter with a certain combination of event bindings, then every bean X that realizes Y also has an observer method. The event bindings of the event parameter of this inherited observer method consist of all event bindings declared by the event parameter of the observer method of Y.
Coverage
No tests exist for this assertion
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.
Coverage
No tests exist for this assertion
The container is required to support circularities in the bean dependency graph
Coverage
No tests exist for this assertion
Coverage
No tests exist for this assertion
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
If necessary, the container performs boxing or unboxing when it injects a value to a field or parameter of primitive or wrapper type.
Coverage
No tests exist for this assertion
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
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
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.
Coverage
No tests exist for this assertion
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.
Coverage
No tests exist for this assertion
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
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
The behavior of all methods declared by java.lang.Object, except for toString(), is undefined for a client proxy
Coverage
No tests exist for this assertion
If an injection point declares no binding, the default binding @Current is assumed
Coverage
No tests exist for this assertion
An injection point declared in XML has it's type determined according to Section 9.10, "Specifying bean types and bindings"
Coverage
No tests exist for this assertion
An injection point declared in XML has it's bindings determined according to Section 9.10, "Specifying bean types and bindings"
Coverage
No tests exist for this assertion
The javax.inject.manager.InjectionPoint.getAnnotation() method returns annotations of the parameter in the case of method parameter
Coverage
No tests exist for this assertion
The javax.inject.manager.InjectionPoint.getAnnotation() method returns annotations annotations of the parameter in the case of constructor parameter injection.
Coverage
No tests exist for this assertion
The javax.inject.manager.InjectionPoint.getAnnotations() method returns annotations of the parameter in the case of method parameter
Coverage
No tests exist for this assertion
The javax.inject.manager.InjectionPoint.getAnnotations() method returns annotations annotations of the parameter in the case of constructor parameter injection.
Coverage
No tests exist for this assertion
getAnnotation() returns a null value if no annotation of the given type exists at the field injection point
Coverage
No tests exist for this assertion
getAnnotation() returns a null value if no annotation of the given type exists at the method parameter injection point
Coverage
No tests exist for this assertion
getAnnotation() returns a null value if no annotation of the given type exists at the constructor injection point
Coverage
No tests exist for this assertion
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
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
Implementations of Bean maintain a reference to an instance of Manager
Coverage
No tests exist for this assertion
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()
Coverage
No tests exist for this assertion
Manager.getInstanceToInject() returns a contextual instance or client proxy to be injected to the given injection point
Coverage
No tests exist for this assertion
The Manager.getInstanceToInject() method must Identify the bean by calling Manager.resolveByType(), passing the type and bindings of the injection point
Coverage
No tests exist for this assertion
The Manager.getInstanceToInject() method must throw an UnsatisfiedDependencyException if resolveByType() did not return a bean
Coverage
No tests exist for this assertion
The Manager.getInstanceToInject() method must throw an AmbiguousDependencyException if resolveByType() returned more than one bean
Coverage
No tests exist for this assertion
The Manager.getInstanceToInject() method must throw an UnproxyableDependencyExceptionif 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"
Coverage
No tests exist for this assertion
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"
Coverage
No tests exist for this assertion
The container provides a built-in bean with bean type Manager
Coverage
No tests exist for this assertion
The container provides a built-in bean with scope @Dependent
Coverage
No tests exist for this assertion
The container provides a built-in bean with deployment type @Standard
Coverage
No tests exist for this assertion
The container provides a built-in bean with binding @Current.
Coverage
No tests exist for this assertion
A contextual instance of a bean may be obtained by calling Manager.getInstance(), passing the Bean object representing the bean
Coverage
No tests exist for this assertion
Manager.getInstance() returns a contextual instance or client proxy for the given bean
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
The getInstanceByType() method must identify the bean by calling Manager.resolveByType(), passing the given type and bindings
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
An instance of the javax.inject.Instance interface may be injected via use of the @javax.inject.Obtains binding
Coverage
No tests exist for this assertion
Additional bindings may be specified at the injection point
Coverage
No tests exist for this assertion
The Instance interface provides a method for obtaining instances of beans of a specific type
Coverage
No tests exist for this assertion
If two instances of the same binding type are passed to Instance.get(), a DuplicateBindingTypeException is thrown
Coverage
No tests exist for this assertion
If an instance of an annotation that is not a binding type is passed to Instance.get(), an IllegalArgumentException is thrown
Coverage
No tests exist for this assertion
The @Obtains annotation or
Coverage
No tests exist for this assertion
If the type of the injection point is not of type Instance a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
If no actual type parameter is specified a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
If the type parameter contains a type variable a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
If the type parameter contains a wildcard a DefinitionException is thrown by the container at deployment time
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
Whenever the @Obtains annotation appears at an injection point, an implicit bean exists with deployment type @Standard
Coverage
No tests exist for this assertion
Whenever the @Obtains annotation appears at an injection point, an implicit bean exists with @Dependent scope
Coverage
No tests exist for this assertion
Whenever the @Obtains annotation appears at an injection point, an implicit bean exists with no bean name
Coverage
No tests exist for this assertion
Whenever the @Obtains annotation appears at an injection point, an implicit bean exists with an implementation provided automatically by the container
Coverage
No tests exist for this assertion
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()
Coverage
No tests exist for this assertion
The application may obtain a contextual instance by calling the Instance.get() method
Coverage
No tests exist for this assertion
When the application calls Instance.get() to obtain a contextual instance dynamically, it may need to pass instances of binding annotation types
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
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
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")
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")
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")
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.
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
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
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
A producer method may declare multiple bindings
Coverage
No tests exist for this assertion
A producer field may declare multiple bindings
Coverage
No tests exist for this assertion
A bean must declare all of the bindings that are specified at the injection point to be considered a candidate for injection
Coverage
No tests exist for this assertion
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
Coverage
No tests exist for this assertion
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
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
Coverage
No tests exist for this assertion
The resolveByName() method of the Manager interface performs name resolution
Coverage
No tests exist for this assertion
When resolving a bean by name, the container must identify the set of matching enabled beans which have the given name
Coverage
No tests exist for this assertion
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
If there are no matching beans, an empty set is returned
Coverage
No tests exist for this assertion
The container is required to perform dependency injection for session bean instances obtained directly from JNDI
Coverage
The container is required to perform dependency injection for session bean instances injected using @EJB
Coverage
No tests exist for this assertion
The container is required to perform dependency injection for session bean instances injected using @Resource
Coverage
No tests exist for this assertion
The container is required to perform dependency injection for session bean instances created by the container to receive remote method calls
Coverage
No tests exist for this assertion
The container is required to perform dependency injection for session bean instances created by the container to receive timeouts
Coverage
No tests exist for this assertion
The container is required to create interceptor stacks for session bean instances obtained directly from JNDI
Coverage
No tests exist for this assertion
The container is required to create interceptor stacks for session bean instances injected using @EJB
Coverage
No tests exist for this assertion
The container is required to create interceptor stacks for session bean instances injected using @Resource
Coverage
No tests exist for this assertion
The container is required to create interceptor stacks for session bean instances created by the container to receive remote method calls
Coverage
No tests exist for this assertion
The container is required to create interceptor stacks for session bean instances created by the container to receive timeouts
Coverage
No tests exist for this assertion
The container is required to create decorator stacks for session bean instances obtained directly from JNDI
Coverage
No tests exist for this assertion
The container is required to create decorator stacks for session bean instances injected using @EJB
Coverage
No tests exist for this assertion
The container is required to create decorator stacks for session bean instances injected using @Resource
Coverage
No tests exist for this assertion
The container is required to create decorator stacks for session bean instances created by the container to receive remote method calls
Coverage
No tests exist for this assertion
The container is required to create decorator stacks for session bean instances created by the container to receive timeouts
Coverage
No tests exist for this assertion
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"
Coverage
No tests exist for this assertion
For the purposes of interceptor stack creation, 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"
Coverage
No tests exist for this assertion
For the purposes of decorator stack creation, 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"
Coverage
No tests exist for this assertion
The container creates interceptor stacks for message-driven bean instances according to the bean class annotations
Coverage
No tests exist for this assertion
The container creates decorator stacks for message-driven bean instances according to the bean class annotations
Coverage
No tests exist for this assertion
To create a contextual instance of a producer method bean, the container calls the producer method
Coverage
No tests exist for this assertion
To destroy a contextual instance of a producer method bean, the container calls the disposal method, if any
Coverage
No tests exist for this assertion
When the container injects a dependency and there is no existing instance of the bean cached by the context object for the bean scope, the context object automatically creates a new contextual instance of the bean
Coverage
No tests exist for this assertion
When the container resolves an EL name and there is no existing instance of the bean cached by the context object for the bean scope, the context object automatically creates a new contextual instance of the bean
Coverage
No tests exist for this assertion
When a context is destroyed, the context object automatically destroys any instances associated with that context
Coverage
No tests exist for this assertion
To create and destroy contextual instances, the context object calls operations defined by the interface Contextual
Coverage
No tests exist for this assertion
If Contextual.create() calls CreationalContext.push(), it must also return the instance passed to push()
Coverage
No tests exist for this assertion
The Contextual.create() method injects any dependencies
Coverage
No tests exist for this assertion
The Contextual.create() method sets any initial field values defined in XML
Coverage
No tests exist for this assertion
If any exception occurs while creating an instance, the exception is rethrown by the create() method
Coverage
If a checked exception occurs while creating an instance, it is wrapped and rethrown as an (unchecked) CreationException
Coverage
The Contextual.destroy() method calls the disposal method, if necessary
Coverage
No tests exist for this assertion
The Contextual.destroy() method destroys all dependent objects of the instance, as defined in Section 8.3.2, "Dependent object destruction"
Coverage
No tests exist for this assertion
If any exception occurs while destroying an instance, the exception is caught by the destroy() method
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, the container first calls the bean constructor to obtain an instance of the bean. For each constructor parameter, the container passes the object returned by Manager.getInstanceToInject(). The container is permitted to return an instance of a container-generated subclass of the bean class, allowing interceptor and decorator bindings
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, after the bean constructor is called the container next initializes the values of any attributes annotated @EJB
When the create() method of the Bean object that represents a simple bean is called, after the bean constructor is called the container next initializes the values of any attributes annotated @PersistenceContext
When the create() method of the Bean object that represents a simple bean is called, after the bean constructor is called the container next initializes the values of any attributes annotated @Resource
When the create() method of the Bean object that represents a simple bean is called, after the @EJB, @PersistenceContext and @Resource attributes are initialized the container initializes the values of all injected fields. For each injected field, the container sets the value to the object returned by Manager.getInstanceToInject().
When the create() method of the Bean object that represents a simple bean is called, after injected fields are initialized the container initializes the values of any fields with initial values specified in XML, as defined in Section 9.5.5, "Field initial value declarations".
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, after the values of fields with initial values specified in XML are initialized the container calls all initializer methods. For each initializer method parameter, the container passes the object returned by Manager.getInstanceToInject()
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, after all initializer methods are called the container builds the interceptor stacks for the instance as defined in Section A.3.10 "Interceptor stack creation"
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, after all initializer methods are called the container builds the decorator stacks for the instance as defined in Section A.5.8 "Decorator stack creation"
Coverage
No tests exist for this assertion
When the create() method of the Bean object that represents a simple bean is called, after the interceptor and decorator stacks are built the container calls the @PostConstruct method, if any
When the destroy() method of a Bean object is called, after the container calls the @PreDestroy method, it finally destroys dependent objects
Coverage
No tests exist for this assertion
When the create() method of a Bean object that represents a stateful session bean that is called, the container creates and returns a session bean proxy, as defined in Section 3.3.9, "Session bean proxies".
When the create() method of a Bean object that represents a stateless session or singleton session bean is called, the container creates and returns a session bean proxy, as defined in Section 3.3.9, "Session bean proxies".
When the create() method of a Bean object that represents a producer method is called, the container must invoke the producer method, passing the object returned by Manager.getInstanceToInject() to each parameter
If a producer method is not static, the container must obtain the Bean object for the most specialized bean that specializes the bean which declares the producer method
If a producer method is not static, after obtaining the most specialized Bean object the container must obtain an instance of the most specialized bean, by calling Manager.getInstance(), passing the Bean object representing the bean
Coverage
No tests exist for this assertion
If a producer method is not static, after obtaining an instance of the most specialized bean the container must invoke the producer method upon this instance
Coverage
No tests exist for this assertion
The return value of the producer method, after method interception completes, is the new contextual instance to be returned by Bean.create()
Coverage
No tests exist for this assertion
If the producer method returns a null value, and the scope of the producer method is not @Dependent, the create() method throws an IllegalProductException
When the destroy() method is called, and if there is a disposal method for this producer method, the container must invoke the disposal method, passing the instance given to destroy() to the disposed parameter, and the object returned by Manager.getInstanceToInject() to each of the other parameters
If a disposal method is static, the container must invoke the method
Coverage
No tests exist for this assertion
If a disposal method is non-static, the container must obtain the Bean object for the most specialized bean that specializes the bean which declares the disposal method
Coverage
No tests exist for this assertion
If a disposal method is non-static, after obtaining the Bean object for the most specialized bean, the container must obtain an instance of the most specialized bean, by calling Manager.getInstance(), passing the Bean object representing the bean
Coverage
No tests exist for this assertion
If a disposal method is non-static, after obtaining the instance of the most specialized bean the container must invoke the disposal method upon this instance
Coverage
No tests exist for this assertion
Finally, the container destroys dependent objects
Coverage
No tests exist for this assertion
It is not required that the returned object of a producer field be an instance of another bean
Coverage
No tests exist for this assertion
When the create() method of a Bean object that represents a producer field is called, the container must access the producer field to obtain the current value of the field
If a producer field is non-static, the container must obtain the Bean object for the most specialized bean that specializes the bean which declares the producer field
If a producer field is non-static, after obtaining the Bean object for the most specialized bean the container must obtain an instance of the most specialized bean, by calling Manager.getInstance(), passing the Bean object representing the bean
Coverage
No tests exist for this assertion
If the producer field contains a null value, and the scope of the producer method is not @Dependent, the create() method throws an IllegalProductException
An instance of a resource is a proxy object, provided by the container, that implements the declared bean type, delegating the actual implementation of the methods directly to the underlying Java EE resource, entity manager, entity manager factory, EJB remote object or web service referenc
A resource proxy object is a dependent object of the object it is injected into
Coverage
No tests exist for this assertion
Resource proxy objects are serializable
Coverage
No tests exist for this assertion
When the create() method of a Bean object that represents a JMS resource is called, the container creates and returns a proxy object that implements the bean type of the resource
Coverage
No tests exist for this assertion
The methods of this proxy object delegate to the underlying implementation, which is obtained using the metadata provided in the resource declaration
Coverage
No tests exist for this assertion
A Java EE resource is obtained using the JNDI name or mapped name specified by
Coverage
No tests exist for this assertion
A persistence context is obtained using the persistence unit name specified by
Coverage
No tests exist for this assertion
A persistence unit is obtained using the persistence unit name specified by
Coverage
No tests exist for this assertion
A remote EJB is obtained using the JNDI name, mapped name or EJB link specified by
Coverage
No tests exist for this assertion
A web service is obtained using the JNDI name or mapped name specified by
Coverage
No tests exist for this assertion
When the destroy() method is called, the container discards the proxy object
Coverage
No tests exist for this assertion
An instance of a JMS resource is a proxy object, provided by the container, that implements all the bean types defined in Section 3.7, "JMS resources", delegating the actual implementation of these methods directly to the underlying JMS objects
A JMS resource proxy object is a dependent object of the object it is injected into
Coverage
No tests exist for this assertion
JMS resource proxy objects are serializable
Coverage
No tests exist for this assertion
When the create() method of a Bean object that represents a JMS resource is called, the container creates and returns a proxy object that implements all the bean types of the JMS resource
Coverage
No tests exist for this assertion
The methods of this proxy object delegate to JMS objects obtained as needed using the metadata provided by the JMS resource declaration and using standard JMS APIs
Coverage
No tests exist for this assertion
The Destination is obtained using the JNDI name or mapped name specified by
Coverage
No tests exist for this assertion
The appropriate ConnectionFactory for the topic or queue is obtained automatically
Coverage
No tests exist for this assertion
The Connection is obtained by calling QueueConnectionFactory.createQueueConnection() or TopicConnectionFactory.createTopicConnection()
Coverage
No tests exist for this assertion
The container is permitted to share a connection between multiple proxy objects
The Session object is obtained by calling QueueConnection.createQueueSession() or TopicConnection.createTopicSession()
Coverage
No tests exist for this assertion
The MessageProducer object is obtained by calling QueueSession.createSender() or TopicSession.createPublisher()
Coverage
No tests exist for this assertion
The MessageConsumer object is obtained by calling QueueSession.createReceiver() or TopicSession.createSubscriber()
Coverage
No tests exist for this assertion
When the destroy() method is called, the container must ensure that all JMS objects created by the proxy object are destroyed by calling close() if necessary
Coverage
No tests exist for this assertion
The Connection is destroyed by calling Connection.close() if necessary
Coverage
No tests exist for this assertion
If the connection is being shared between multiple proxy objects, the container is not required to close the connection when the proxy is destroyed
Coverage
No tests exist for this assertion
The Session object is destroyed by calling Session.close()
Coverage
No tests exist for this assertion
The MessageProducer object is destroyed by calling MessageProducer.close()
Coverage
No tests exist for this assertion
The MessageConsumer object is destroyed by calling MessageConsumer.close()
Coverage
No tests exist for this assertion
The close() method of a JMS resource proxy object always throws an UnsupportedOperationException
Coverage
No tests exist for this assertion
When the EJB container creates a new instance of an EJB, after Java EE injection has been performed and before the @PostConstruct callback occurs the container must initialize the values of all injected fields . For each injected field, the container sets the value to the object returned by Manager.getInstanceToInject()
When the EJB container creates a new instance of an EJB, after Java EE injection has been performed and before the @PostConstruct callback occurs the container must initialize the values of any fields with initial values specified in XML, as defined in Section 9.5.5, "Field initial value declarations"
When the EJB container creates a new instance of an EJB, after Java EE injection has been performed and before the @PostConstruct callback occurs the container calls all initializer methods. For each initializer method parameter, the container passes the object returned by Manager.getInstanceToInject()
When the EJB container creates a new instance of an EJB, after Java EE injection has been performed and before the @PostConstruct callback occurs the container builds the interceptor stacks for the instance as defined in Section A.3.10, "Interceptor stack creation" and Section A.5.8, "Decorator stack creation" and binds them to the instance
When the EJB container creates a new instance of an EJB, after Java EE injection has been performed and before the @PostConstruct callback occurs the container builds the decorator stacks for the instance as defined in Section A.3.10, "Interceptor stack creation" and Section A.5.8, "Decorator stack creation" and binds them to the instance
When the servlet container creates a new instance of a servlet, the container initializes the values of all injected fields. For each injected field, the container sets the value to the object returned by Manager.getInstanceToInject()
Coverage
No tests exist for this assertion
When the servlet container creates a new instance of a servlet, the container calls all initializer methods. For each initializer method parameter, the container passes the object returned by Manager.getInstanceToInject()
Coverage
No tests exist for this assertion
When the servlet container destroys a servlet, the container destroys all dependent objects
Coverage
No tests exist for this assertion
In a Java EE 5 environment, the container is not required to support injected fields or initializer methods of servlets
An event consumer will be notified of an event if the observed event type it specifies is one of the event types of the event, and if all the observed event bindings it specifies are event bindings of the event
In the signature of Manager.addObserver(), the first parameter is the observer object, the second parameter is the observed event type, and the remaining parameters are optional observed event bindings
If the observed event type passed to addObserver() or removeObserver() contains type variables or wildcards, an IllegalArgumentException is thrown
If the observed event type passed to addObserver() or removeObserver() contains type variables or wildcards, an IllegalArgumentException is thrown
If two instances of the same binding type are passed to addObserver() or removeObserver(), a DuplicateBindingTypeException is thrown
If two instances of the same binding type are passed to addObserver() or removeObserver(), a DuplicateBindingTypeException is thrown
If an instance of an annotation that is not a binding type is passed to addObserver() or removeObserver(), an IllegalArgumentException is thrown
When an event is fired by the application the container must, for each observer, call the notify() method of the Observer interface, passing the event object
If an observer throws an exception, the exception aborts processing of the event. No other observers of that event will be called. The fireEvent() method rethrows the exception
An observer method is an observer defined via annotations, instead of by explicitly implementing the Observer interface. Unlike regular observers, observer methods are automatically discovered and registered by the container
If the bean is a session bean, the observer method must be a business method of the EJB or a static method of the bean class
Each observer method must have exactly one event parameter, of the same type as the event type it observes. When searching for observer methods for an event, the container considers the type and bindings of the event parameter
If the type of the event parameter contains type variables or wildcards, a DefinitionException is thrown by the container at deployment time
If a non-static method of a session bean class has a parameter annotated @Observes, and the method is not a business method of the EJB, a DefinitionException is thrown by the container at deployment time
If the bean class of a bean declared in XML does not have a method with parameters that match those declared in XML, a DefinitionException is thrown by the container at deployment time
In addition to the event parameter, observer methods may declare additional parameters, which may declare bindings. The container calls the method Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies" to determine a value for each parameter of an observer method and calls the observer method with those parameter values
Transactional observer methods are observer methods which receive event notifications during the before or after completion phase of the transaction in which the event was fired. If no transaction is in progress when the event is fired, they are notified at the same time as other observers
A transactional observer method may not specify more than one of the four types. If a transactional observer method specifies more than one of the four types, a DefinitionException is thrown by the container at deployment time
If an asynchronous observer method is also a transactional observer method, it may not be a before completion observer method or a conditional observer method. If an asynchronous observer method is specified as a before completion or conditional observer method, a DefinitionException is thrown by the container at deployment time
If an asynchronous observer method is also a transactional observer method, it may not be a before completion observer method or a conditional observer method. If an asynchronous observer method is specified as a before completion or conditional observer method, a DefinitionException is thrown by the container at deployment time
For every observer method of an enabled bean, the container is responsible for providing and registering an appropriate implementation of the Observer interface, that delegates event notifications to the observer method
The notify() method of the Observer implementation for an observer method either invokes the observer method immediately, or asynchronously, or registers the observer method for later invocation during the transaction completion phase, using a JTA Synchronization
The notify() method of the Observer implementation for an observer method either invokes the observer method immediately, or asynchronously, or registers the observer method for later invocation during the transaction completion phase, using a JTA Synchronization
The notify() method of the Observer implementation for an observer method either invokes the observer method immediately, or asynchronously, or registers the observer method for later invocation during the transaction completion phase, using a JTA Synchronization
If the observer method is an asynchronous transactional observer method and there is currently a JTA transaction in progress, the observer object calls the observer method asynchronously during the after transaction completion phase
If the observer method is a transactional observer method and there is currently a JTA transaction in progress, the observer object calls the observer method during the appropriate transaction completion phase
To invoke an observer method, the container must pass the event object to the event parameter and the object returned by Manager.getInstanceToInject() to each of the other parameters
If the observer is a transactional or asynchronous observer method, any exception is caught and logged by the container
If the observer isn't a transactional or asynchronous observer method, the exception is rethrown by the notify() method of the observer object
The observer object is registered by calling Manager.addObserver(), passing the event parameter type as the observed event type, and the bindings of the event parameter as the observed event bindings
If the observer method is an asynchronous observer method, it is called with no active transaction, no client security context and with a new request context that is destroyed when the observer method returns. The application context is also active
If the observer method is a @BeforeTransactionCompletion transactional observer method, it is called within the context of the transaction that is about to complete and with the same client security context and lifecycle contexts
If the observer method is any other kind of transactional observer method, it is called in an unspecified transaction context, but with the same client security context and lifecycle contexts as the transaction that just completed
If an observer method is not an asynchronous observer method, and not a @BeforeTransactionCompletion transactional method, and not any other kind of transactional observer method, then the observer method is called in the same transaction context, client security context and lifecycle contexts as the invocation of Event.fire()
The transaction and security contexts for a business method of a session bean also depend upon the transaction attribute and @RunAs descriptor, if any
Coverage
No tests exist for this assertion
If the type of the injection point parameter contains a type variable a DefinitionException is thrown by the container at deployment time
If the type of the injection point parameter contains a wildcard a DefinitionException is thrown by the container at deployment time
Whenever the @Fires annotation appears at an injection point, an implicit bean exists with exactly the bean type and bindings that appear at the injection point
The fire() method of the provided implementation of Event must call Manager.fireEvent(), passing the event object passed to Event.fire(), all bindings declared at the injection point (except @Fires), and all bindings passed to Event.fire()
The observe() method of the provided implementation of Event must call Manager.addObserver(), passing the observer object passed to Event.observe(), all bindings declared at the injection point (except @Fires), and all bindings passed to Event.observer()
When searching for observers for an event, the event object must be assignable to the observed event type, taking type parameters into consideration
When searching for observers for an event, for each observed event binding, (a) an instance of the binding type must have been passed to fireEvent() and (b) any member values of the binding type must match the member values of the instance passed to fireEvent()
All observers of mapped event types must be asynchronous observer methods. If an observer for a mapped event type is not an asynchronous observer method, a DeploymentException is thrown by the container at deployment time
When an event type is mapped to a topic, the container must listen for messages containing events of that type sent to the topic, and notify all observers of the event type whenever a message containing an event of that type is received
The get() method of the Context object may create a new instance of the given contextual type by calling Contextual.create() and return the new instance, if a CreationalContext is given
The Context implementation is responsible for destroying any contextual instance it creates by passing the instance to the destroy() method of the Contextual object representing the contextual type
The isActive() method returns false when the scope of the context object is inactive, and true when it is active
Coverage
No tests exist for this assertion
The get() operation of the Context object for an active normal scope returns the current instance of the given contextual type
Coverage
No tests exist for this assertion
When a context is destroyed, all mapped instances of contextual types with that scope are destroyed by passing them to the Contextual.destroy() method
Coverage
No tests exist for this assertion
Contexts with normal scopes must obey the following rule: Suppose beans A, B and Z all have normal scopes. Suppose A has an injection point x, and B has an injection point y. Suppose further that both x and y resolve to bean Z according to the typesafe resolution algorithm. If a is the current instance of A, and b is the current instance of B, then both a.x and b.y refer to the same instance of Z. This instance is the current instance of Z.
Coverage
No tests exist for this assertion
When a bean is declared to have @Dependent scope, any injected instance of the bean is bound to the lifecycle of the bean, servlet or EJB into which it is injected
When a bean is declared to have @Dependent scope, any instance of the bean that receives a producer method, producer field, disposal method or observer method invocation exists to service that invocation only
Coverage
Coverage
The @Dependent scope is inactive except when the container is creating or destroying a contextual instance of a bean or injecting its dependencies
The @Dependent scope is inactive except when the container is injecting dependencies of a servlet
Coverage
No tests exist for this assertion
The @Dependent scope is even active during invocation of interceptors and decorators of observer methods and interceptors and decorators of @PostConstruct and @PreDestroy callbacks
Coverage
No tests exist for this assertion
Instances of interceptors or decorators with scope @Dependent are also dependent objects of the bean they intercept or decorate
Coverage
No tests exist for this assertion
The container must destroy all dependent objects of a contextual bean instance when the instance is destroyed
The container must destroy all dependent objects of an EJB or servlet when the EJB or servlet is destroyed
The container must destroy all dependent objects of an EJB or servlet when the EJB or servlet is destroyed
Coverage
No tests exist for this assertion
The container must destroy any @Dependent scoped contextual instance created to receive a producer method, producer field, disposal method or observer method invocation when the invocation completes
The container must destroy any @Dependent scoped contextual instance created to receive a producer method, producer field, disposal method or observer method invocation when the invocation completes
The container must destroy any @Dependent scoped contextual instance created to receive a producer method, producer field, disposal method or observer method invocation when the invocation completes
The container must destroy any @Dependent scoped contextual instance created to receive a producer method, producer field, disposal method or observer method invocation when the invocation completes
The container must validate that every bean declared with a passivating scope truly is serializable - EJB local objects are serializable. Therefore, a session bean may declare any passivating scope
Simple beans are not required to be serializable. If a simple bean declares a passivating scope, and the bean class is not serializable, a DefinitionException is thrown by the container at deployment time
If a producer method or field declares a passivating scope and returns a non-serializable object at runtime, an IllegalProductException is thrown by the container
Coverage
No tests exist for this assertion
If a producer method or field declares a passivating scope and returns a non-serializable object at runtime, an IllegalProductException is thrown by the container
Coverage
No tests exist for this assertion
EJB local objects are serializable, therefore, any reference to a session bean of scope @Dependent is serializable
If a simple bean of scope @Dependent and a nonserializable bean class is injected into a stateful session bean an UnserializableDependencyException must be thrown by the container at deployment time
Coverage
If a simple bean of scope @Dependent and a nonserializable bean class is injected into a non-transient field an UnserializableDependencyException must be thrown by the container at deployment time
If a simple bean of scope @Dependent and a nonserializable bean class is injected into a bean constructor parameter of a bean which declares a passivating scope, an UnserializableDependencyException must be thrown by the container at deployment time
If a simple bean of scope @Dependent and a nonserializable bean class is injected into an initializer method parameter of a bean which declares a passivating scope, an UnserializableDependencyException must be thrown by the container at deployment time
If a simple bean of scope @Dependent and a nonserializable bean class is injected into a parameter of a producer method which declares a passivating scope, an UnserializableDependencyException must be thrown by the container at deployment time
If a producer method or field of scope @Dependent returns a non-serializable object for injection into a stateful session bean, an IllegalProductException is thrown by the container
If a producer method or field of scope @Dependent returns a non-serializable object for injection into a non-transient field an IllegalProductException is thrown by the container
Coverage
If a producer method or field of scope @Dependent returns a non-serializable object for injection into a bean constructor parameter of a bean which declares a passivating scope, an IllegalProductException is thrown by the container
If a producer method or field of scope @Dependent returns a non-serializable object for injection into an initializer method parameter of a bean which declares a passivating scope, an IllegalProductException is thrown by the container
If a producer method or field of scope @Dependent returns a non-serializable object for injection into a parameter of a producer method which declares a passivating scope, an IllegalProductException is thrown by the container
The method Bean.isSerializable() may be used to detect if a bean is serializable
Coverage
No tests exist for this assertion
The container provides an implementation of the Context interface for each of the built-in scopes
Coverage
No tests exist for this assertion
The built-in contexts do not propagate across remote method invocations or to asynchronous processes such as JMS message listeners or EJB timer service timeouts
The request scope is active during the doFilter() method of any servlet filter
Coverage
No tests exist for this assertion
The request scope is active during any asynchronous observer method notification
Coverage
No tests exist for this assertion
The request context is destroyed after a asynchronous observer method notification completes
Coverage
No tests exist for this assertion
The session scope is active during the doFilter() method of any servlet filter
Coverage
No tests exist for this assertion
The application scope is active during the doFilter() method of any servlet filter
Coverage
No tests exist for this assertion
The application scope is active during any asynchronous observer method notification
Coverage
No tests exist for this assertion
The application context is shared between all asynchronous observer method notifications that execute within the same application
Coverage
No tests exist for this assertion
The application context is shared between all web service invocations that execute within the same application
Coverage
No tests exist for this assertion
The application context is shared between all EJB remote method invocations that execute within the same application
Coverage
No tests exist for this assertion
The application context is shared between all EJB timeouts that execute within the same application
Coverage
No tests exist for this assertion
The application context is shared between all message deliveries to message driven beans that execute within the same application
Coverage
No tests exist for this assertion
For a JSF faces request, the conversation context is active from the beginning of the apply request values phase, until the response is complete
Coverage
No tests exist for this assertion
Any JSF request has exactly one associated conversation
Coverage
No tests exist for this assertion
The conversation associated with a JSF request is determined at the end of the restore view phase and does not change during the request
Coverage
No tests exist for this assertion
A transient conversation may be marked long-running by calling Conversation.begin()
All long-running conversations have a string-valued unique identifier, which may be set by the application when the conversation is marked long-running, or generated by the container
All long-running conversations have a string-valued unique identifier, which may be set by the application when the conversation is marked long-running, or generated by the container
The container provides a built-in bean with bean type javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding @Current, named javax.context.conversation
The container provides a built-in bean with bean type javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding @Current, named javax.context.conversation
The container provides a built-in bean with bean type javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding @Current, named javax.context.conversation
The container provides a built-in bean with bean type javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding @Current, named javax.context.conversation
The container provides a built-in bean with bean type javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding @Current, named javax.context.conversation
If the conversation associated with the current JSF request is in the transient state at the end of a JSF request, it is destroyed, and the conversation context is also destroyed
If the conversation associated with the current JSF request is in the long-running state at the end of a JSF request, it is not destroyed
The long-running conversation context associated with a request that renders a JSF view is automatically propagated to any faces request (JSF form submission) that originates from that rendered page
The long-running conversation context associated with a request that results in a JSF redirect (via a navigation rule) is automatically propagated to the resulting non-faces request, and to any other subsequent request to the same URL. This is accomplished via use of a GET request parameter named cid containing the unique identifier of the conversation
The long-running conversation associated with a request may be propagated to any non-faces request via use of a GET request parameter named cid containing the unique identifier of the conversation. In this case, the application must manage this request parameter
A custom implementation of Context may be associated with any scope type at any point in the execution of the application, by calling Manager.addContext()
Coverage
No tests exist for this assertion
Every time Manager.getInstance() is called, for example, during instance or EL name resolution, the container must call Manager.getContext() to retrieve an active context object associated with the bean scope
If no active context object exists for the given scope type, Manager.getContext() must throw a ContextNotActiveException
The following 8 tests do not match any known assertions:
| Section | Assertion | Test Class | Test Method |
|---|---|---|---|
| review | review | org.jboss.jsr299.tck.tests.implementation.simple.newSimpleBean.newAndOtherBindingType NewAndOtherBindingTypeTest | testNewAnnotationCannotAppearInConjunctionWithOtherBindingType() |
| review | review | org.jboss.jsr299.tck.tests.implementation.enterprise.newBean NewEnterpriseBeanTest | testNewAnnotationCannotBeAppliedToNonWebBeanImplementationClass() |
| review | review | org.jboss.jsr299.tck.tests.implementation.enterprise.newBean NewEnterpriseBeanTest | testNewAnnotationCannotBeExplicitlyDeclared() |
| review | review | org.jboss.jsr299.tck.tests.implementation.enterprise.newAndOtherBinding NewAndOtherBindingTest | testNewAnnotationCannotAppearInConjunctionWithOtherBindingType() |
| review | review | org.jboss.jsr299.tck.tests.implementation.simple.newSimpleBean NewSimpleBeanTest | testNewAnnotationCannotBeExplicitlyDeclared() |
| review | review | org.jboss.jsr299.tck.tests.lookup.clientProxy.unknown UnknownBeanTest | testGettingUnknownBeanFails() |
| A.5 | unknown | org.jboss.jsr299.tck.tests.implementation.decorator DecoratorDefinitionTest | testDecoratorBindingInherited() |
| A.5 | unknown | org.jboss.jsr299.tck.tests.implementation.decorator DecoratorDefinitionTest | testDecoratorBindingBlockedByIntermediateClass() |