A bean comprises of a set of interceptor bindings.
| Chapter | Assertions | Testable | Total Tested | Total Tests | Tested (problematic) |
Tested (working) |
Coverage % |
|---|---|---|---|---|---|---|---|
| 2 Concepts | 133 | 110 | 110 | 142 | 0 | 110 | 100,00% |
| 3 Programming model | 234 | 224 | 223 | 290 | 0 | 223 | 99,55% |
| 4 Inheritance and specialization | 90 | 84 | 84 | 118 | 0 | 84 | 100,00% |
| 5 Dependency injection, lookup, and EL | 276 | 263 | 250 | 343 | 0 | 250 | 95,06% |
| 6 Scopes and contexts | 224 | 195 | 190 | 249 | 0 | 190 | 97,44% |
| 7 Lifecycle of contextual instances | 61 | 56 | 50 | 65 | 0 | 50 | 89,29% |
| 8 Decorators | 68 | 65 | 63 | 96 | 0 | 63 | 96,92% |
| 9 Interceptor bindings | 57 | 52 | 52 | 67 | 0 | 52 | 100,00% |
| 10 Events | 93 | 83 | 79 | 130 | 0 | 79 | 95,18% |
| 11 Portable extensions | 374 | 358 | 322 | 429 | 0 | 322 | 89,94% |
| 12 Packaging and Deployment | 78 | 57 | 57 | 83 | 0 | 57 | 100,00% |
| Total | 1688 | 1547 | 1480 | 2012 | 0 | 1480 | 95,67% |
| Colour Key |
|---|
| Assertion is covered |
| Assertion is not covered |
| Assertion test is unimplemented |
| Assertion is untestable |
A bean comprises of a (nonempty) set of bean types.
A bean comprises of a (nonempty) set of qualifiers.
A bean comprises of a scope.
A bean comprises of a set of interceptor bindings.
A bean comprises of a bean implementation.
Coverage
A bean may or may not be an alternative.
A bean may have multiple bean types.
All beans have the bean type java.lang.Object.
Coverage
A bean type may be an interface.
A bean type may be a concrete class.
Coverage
A bean type may be an abstract class.
A bean type may have final methods.
A bean type may be a parameterized type with actual type parameters.
Coverage
A bean type may be a parameterized type with type variables.
Coverage
A bean type may be an array type. Two array types are considered identical only if the element type is identical.
Coverage
A bean type may be a primitive type. Primitive types are considered to be identical to their corresponding wrapper types in java.lang.
A bean type may be a raw type.
Coverage
A type variable is not a legal bean type.
Coverage
A parameterized type that contains a wildcard type parameter is not a legal bean type.
Coverage
The bean types of a bean may be restricted by annotating the bean class or producer method or field with the annotation @javax.enterprise.inject.Typed. When a @Typed annotation is explicitly specified, only the types whose classes are explicitly listed using the value member, together with java.lang.Object are bean types of the bean.
Check managed bean
Coverage
Check session bean
Coverage
Check producer method
Coverage
Check producer field
Coverage
Check generic managed bean
Coverage
Check generic producer method
Coverage
Check generic producer field
Coverage
If a bean class or producer method or field specifies a @Typed annotation, and the value member specifies a class which does not correspond to a type in the unrestricted set of bean types of a bean, the container automatically detects the problem and treats it as a definition error.
Check managed bean
Coverage
Check session bean
Coverage
Check producer method
Coverage
Check producer field
Coverage
A client of a bean may typecast its contextual reference to a bean to any bean type of the bean which is a Java interface. However, the client may not in general typecast its contextual reference to an arbitrary concrete bean type of the bean.
Coverage
Every bean has the built-in qualifier @Any, even if it does not explicitly declare this qualifier, except for the special @New qualified beans defined in Section 3.14, "@New qualified beans".
Coverage
If a bean does not explicitly declare a qualifier other than @Named, the bean has exactly one additional qualifier, of type @Default. This is called the default qualifier.
Coverage
The default qualifier is also assumed for any injection point that does not explicitly declare a qualifier.
Coverage
A qualifier type is a Java annotation defined as @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME).
A qualifier type is a Java annotation defined as @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME).
A qualifier type may be declared by specifying the @javax.inject.Qualifier meta-annotation.
Coverage
A qualifier type may define annotation members.
The qualifiers of a bean are declared by annotating the bean class or producer method or field with the qualifier types.
Test by annotating a bean class.
Coverage
Test by annotating a producer method.
Coverage
Test by annotating a producer field.
Coverage
Qualifier types may be applied to injected fields (see Section 3.8, "Injected fields") to determine the bean that is injected, according to the rules of typesafe resolution defined in Section 5.3, "Typesafe resolution".
Coverage
A bean may only be injected to an injection point if it has all the qualifiers of the injection point.
Coverage
Qualifier types may be applied to parameters of producer methods, initializer methods, disposer methods, observer methods or bean constructors (see Chapter 3, Bean implementation) to determine the bean instance that is passed when the method is called by the container.
Test initializer method.
Coverage
Test disposer method.
Coverage
Test observer method.
Test bean constructor.
Coverage
All beans have a scope.
A scope type is represented by an annotation type.
The set of scope types is extensible.
Coverage
There are five standard scope types defined by this specification, all defined in the package javax.enterprise.context.
The @RequestScoped, @ApplicationScoped and @SessionScoped annotations defined in Section 6.7, "Context management for built-in scopes" represent the standard scopes defined by the Java Servlets specification.
The @RequestScoped, @ApplicationScoped and @SessionScoped annotations defined in Section 6.7, "Context management for built-in scopes" represent the standard scopes defined by the Java Servlets specification.
The @RequestScoped, @ApplicationScoped and @SessionScoped annotations defined in Section 6.7, "Context management for built-in scopes" represent the standard scopes defined by the Java Servlets specification.
The @ConversationScoped annotation represents the conversation scope defined in Section 6.7.4, "Conversation context lifecycle".
Coverage
The @Dependent pseudo-scope is for dependent objects, as defined in Section 6.4, "Dependent pseudo-scope"
If an interceptor or decorator has any scope other than @Dependent, non-portable behavior results.
A scope type is a Java annotation defined as @Target({TYPE, METHOD, FIELD}) and @Retention(RUNTIME).
Coverage
A scope type is a Java annotation defined as @Target({TYPE, METHOD, FIELD}) and @Retention(RUNTIME).
A scope type must not have any attributes. If a scope type has attributes non-portable behavior results.
All scope types must specify the @javax.inject.Scope or @javax.enterprise.context.NormalScope meta-annotation.
Coverage
The scope of a bean is defined by annotating the bean class or producer method or field with a scope type.
Coverage
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, the container automatically detects the problem and treats it as a definition error.
Coverage
A scope type may be specified using a stereotype annotation, as defined in Section 2.7.2, "Declaring the stereotypes for a bean"
Coverage
When no scope is explicitly declared by annotating the bean class or producer method or field the scope of a bean is defaulted.
If the bean does not declare any stereotype with a declared default scope, the default scope for the bean is @Dependent.
Coverage
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, the container automatically detects the problem and treats it as a definition error.
If a bean explicitly declares a scope, any default scopes declared by stereotypes are ignored.
A valid bean EL name is a period-separated list of valid EL identifiers
Coverage
To specify the EL name of a bean, the qualifier @javax.inject.Named is applied to the bean class or producer method or field.
Test with a bean class.
Test with a producer method.
Coverage
Test with a producer field.
Coverage
If the @Named annotation does not specify the value member, the EL name is defaulted.
Coverage
A default name must be assigned by the container when a bean class or producer method or field of a bean declares a @Named annotation and no bean name is explicitly specified by the value member.
Test with a bean class.
Test with a producer method.
Coverage
Test with a producer field.
Coverage
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 an bean name.
Coverage
If a bean class or producer method or field of a bean declares a @Named annotation and no bean name is explicitly specified the value of the value member is defaulted.
Test with a producer method.
Coverage
Test with a producer field.
Coverage
If @Named is not declared by the bean, nor by its stereotypes, a bean has no name.
If an interceptor or decorator has a name, non-portable behavior results.
An alternative is a bean that must be explicitly declared in the beans.xml file if it should be available for lookup, injection or EL resolution.
An alternative may be declared by annotating the bean class or producer method or field with the @Alternative annotation.
Test with a producer method.
Coverage
Test with a producer field.
Coverage
An alternative may be declared by annotating a bean, producer method or producer field with a stereotype that declares an @Alternative annotation.
Test with a bean.
Coverage
Test with a producer method.
Coverage
Test with a producer field.
Coverage
If an interceptor or decorator is an alternative, non-portable behavior results.
A stereotype may specify that all beans with the stereotype are alternatives.
Coverage
A bean may declare zero, one or multiple stereotypes.
A bean may declare zero stereotypes.
Test with one stereotype.
Coverage
Test with multiple stereotypes.
Coverage
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).
Test @Target({TYPE, METHOD, FIELD}).
Test @Target(TYPE).
Test @Target(FIELD).
Test @Target({METHOD, FIELD}).
@Retention(RUNTIME) - untestable.
A stereotype may be declared by specifying the @javax.enterprise.inject.Stereotype meta-annotation.
Coverage
The default scope of a stereotype is defined by annotating the stereotype with a scope type. A stereotype may declare at most one scope. If a stereotype declares more than one scope, the container automatically detects the problem and treats it as a definition error.
Test that a stereotype with multiple scopes throws an exception.
Coverage
The interceptor bindings of a stereotype are defined by annotating the stereotype with the interceptor binding types.
Coverage
A stereotype may declare zero interceptor bindings.
Coverage
A stereotype may declare one interceptor bindings.
A stereotype may declare multiple interceptor bindings.
Coverage
A stereotype may declare an empty @Named annotation, which specifies that every bean with the stereotype has a defaulted name when a name is not explicitly specified by the bean.
Coverage
A @Named qualifier declared by a stereotype is not added to the qualifiers of a bean with the stereotype.
Coverage
If a stereotype declares a non-empty @Named annotation, the container automatically detects the problem and treats it as a definition error.
Coverage
A stereotype should not declare any qualifier annotation other than @Named. If a stereotype declares any other qualifier annotation, non-portable behavior results.
A stereotype should not be annotated @Typed. If a stereotype is annotated @Typed, non-portable behavior results.
A stereotype may declare an @Alternative annotation, which specifies that every bean with the stereotype is an alternative.
Coverage
A stereotype may declare other stereotypes.
Coverage
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
Stereotypes declared @Target(TYPE) may not be applied to stereotypes declared @Target({TYPE, METHOD, FIELD}), @Target(METHOD), @Target(FIELD), @Target({METHOD, FIELD}).
Stereotype annotations may be applied to a bean class or producer method or field.
Test with a bean class.
Coverage
Test with a producer method.
Coverage
Test with a producer field.
Coverage
The default scope declared by the stereotype may be overridden by the bean.
Coverage
The built-in stereotype @javax.enterprise.inject.Model is intended for use with beans that define the model layer of an MVC web application architecture such as JSF.
When the application violates a rule defined by this specification, the container automatically detects the problem. There are three kinds of problem - definition errors occur when a single bean definition violates the rules of this specification, deployment problems occur when there are problems resolving dependencies, or inconsistent specialization, in a particular deployment, and exceptions occur at runtime.
Definition errors are developer errors. They may be detected by tooling at development time, and are also detected by the container at initialization time. If a definition error exists in a deployment, initialization will be aborted by the container.
If a definition error exists, the container must throw a subclass of javax.enterprise.inject.spi.DefinitionException.
Coverage
Deployment problems are detected by the container at initialization time. If a deployment problem exists in a deployment, initialization will be aborted by the container.
If a deployment problem occurs, the container must throw a subclass of javax.enterprise.inject.spi.DeploymentException.
The container is permitted to define a non-portable mode, for use at development time, in which some definition errors and deployment problems do not cause application initialization to abort.
Exceptions represent problems that may not be detected until they actually occur at runtime. All exceptions defined by this specification are unchecked exceptions. All exceptions defined by this specification may be safely caught and handled by the application.
If the bean class of a managed bean is annotated with both the @Interceptor and @Decorator stereotypes, the container automatically detects the problem and treats it as a definition error.
Coverage
If a managed bean has a non-static public field, it must have scope @Dependent. If a managed bean with a non-static public field declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Check a dependent scoped bean with a public field.
Coverage
Check a managed bean with a static public field which declares any scope other than @Dependent.
Coverage
If a managed bean with a non-static public field declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Coverage
If the managed bean class is a generic type, it must have scope @Dependent. If a managed bean with a parameterized bean class declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Coverage
A top-level Java class is not a managed bean if it is a non-static inner class.
Coverage
A top-level Java class that is a static inner class can be a managed bean.
Coverage
A top-level Java class is not a managed bean if it is an abstract class, unless it is annotated @Decorator.
Coverage
A top-level Java class is not a managed bean if it is an interface, unless it is annotated @Decorator.
Coverage
A top-level Java class is not a managed bean if it is annotated with any of the EJB component-defining annotations
Coverage
A top-level Java class is not a managed bean if it implements javax.enterprise.inject.spi.Extension.
Coverage
A top-level Java class is not a managed bean if it is annotated @Vetoed.
A top-level Java class is not a managed bean if it is declared as an EJB bean class in ejb-jar.xml
Coverage
A top-level Java class is only a managed bean if it has an appropriate constructor - a constructor with no parameters.
Coverage
A top-level Java class is only a managed bean if it has an appropriate constructor - a constructor annotated @Inject.
Coverage
The unrestricted set of bean types for a managed bean contains the bean class, every superclass and all interfaces it implements directly or indirectly.
A managed bean with a constructor that takes no parameters does not require any special annotations
Coverage
If the managed bean does not have a constructor that takes no parameters, it must have a constructor annotated @Inject. No additional special annotations are required.
A bean class may also specify a scope, name, stereotypes and/or qualifiers.
Test a bean with a scope.
Test a bean with a name.
Test a bean with a stereotype.
Test a bean with a qualifier.
Coverage
A managed bean may extend another managed bean.
Coverage
If a bean class of a managed bean X is annotated @Specializes, then the bean class of X must directly extend the bean class of another managed bean Y. Then X directly specializes Y, as defined in Section 4.3, "Specialization".
Test that a specializing bean has all its own qualifiers and the qualifiers of the specialized bean.
Coverage
Test that a specializing bean has the name of the specialized bean.
Coverage
Test a specialized bean extending a managed bean.
Coverage
If the bean class of X does not directly extend the bean class of another managed bean, the container automatically detects the problem and treats it as a definition error.
Test a specializing bean extending a non simple bean.
Coverage
Test a specializing bean extending nothing.
Coverage
Test a specializing bean directly extending an enterprise bean class.
Coverage
Test a specializing bean implementing an interface and extending nothing.
Coverage
The default name for a managed bean is the unqualified class name of the bean class, after converting the first character to lower case
A session bean is a bean that is implemented by a session bean with an EJB 3.x client view that is not annotated with @Vetoed.
Coverage
No tests exist for this assertion
The basic lifecycle and semantics of EJB session beans are defined by the EJB specification.
A stateless session bean must belong to the @Dependent pseudo-scope
Coverage
A singleton bean must belong to either the @ApplicationScoped scope or to the @Dependent pseudo-scope
If a session bean specifies an illegal scope, the container automatically detects the problem and treats it as a definition error.
Coverage
A stateful session bean may have any scope.
Coverage
When a contextual instance of a session bean is obtained via the dependency injection service, the behavior of SessionContext.getInvokedBusinessInterface() is specific to the container implementation. Portable applications should not rely upon the value returned by this method.
If the bean class of a session bean is annotated @Interceptor, the container automatically detects the problem and treats it as a definition error.
Coverage
If the bean class of a session bean is annotated @Decorator, the container automatically detects the problem and treats it as a definition error.
Coverage
If the session bean class is a generic type, it must have scope @Dependent. If a session bean with a parameterized bean class declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Coverage
If a session bean is a stateful session bean, and the scope is @Dependent, the application may call any EJB remove method of a contextual instance of the session bean.
Coverage
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 any contextual instance of a session bean that is a stateful session bean and declares any scope other than @Dependent, an UnsupportedOperationException is thrown
Coverage
If the application directly calls an EJB remove method of a contextual 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.
Coverage
If the application directly calls an EJB remove method of a contextual 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 Contextual.destroy() is called, as defined in Section 6.5, "Lifecycle of stateful session beans"
Coverage
The unrestricted set of bean types for a session bean contains all local interfaces of the bean and their superinterfaces.
Coverage
If the session bean has a bean class local view, the set of bean types contains the bean class and all superclasses.
Coverage
Remote interfaces are not included in the set of bean types
Coverage
A session bean does not require any special annotations apart from the component-defining annotation (or XML declaration) required by the EJB specification.
Coverage
A bean class may also specify a scope, name, stereotypes and/or qualifiers.
Test a bean class with a scope.
Coverage
Test a bean class with a name.
Coverage
Test a bean class with a stereotype.
Coverage
Test a bean class with a qualifier.
Coverage
A session bean class may extend another bean class.
Coverage
If a bean class of a session bean X is annotated @Specializes, then the bean class of X must directly extend the bean class of another session bean Y. Then X directly specializes Y, as defined in Section 4.3 "Specialization".
Coverage
If the bean class of X does not directly extend the bean class of another session bean, the container automatically detects the problem and treats it as a definition error.
Coverage
The default name for a session bean is the unqualified class name of the session bean class, after converting the first character to lower case.
Coverage
A producer method must be a default-access, public, protected or private, non-abstract method of a managed bean class or session bean class.
A producer method may be static.
Coverage
If the bean is a session bean, the producer method must be either a business method of the EJB or a static method of the bean class
Coverage
If a producer method sometimes returns a null value, then the producer method must have scope @Dependent.
Coverage
If a producer method returns a null value at runtime, and the producer method declares scope other than @Dependent, 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".
Coverage
If the producer method return type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter.
Coverage
If a producer method return type contains a wildcard type parameter the container automatically detects the problem and treats it as a definition error.
Coverage
If the producer method return type is a parameterized type with a type variable, it must have scope @Dependent.
Coverage
If a producer method with a parameterized return type with a type variable declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Coverage
If a producer method return type is a type variable the container automatically detects the problem and treats it as a definition error.
Coverage
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.
Coverage
If the return type of a producer method is an interface, the unrestricted set of bean types contains the return type, all interfaces it extends directly or indirectly and java.lang.Object
Coverage
If a return type of a producer method is primitive or is a Java array type, the unrestricted set of bean types contains exactly two types: the method return type and java.lang.Object.
Check primitive return type
Coverage
Check array return type
Coverage
If the return type of a producer method is a class, the unrestricted set of bean types contains the return type, every superclass and all interfaces it implements directly or indirectly.
Coverage
A producer method may be declared by annotating a method with the @javax.enterprise.inject.Produces annotation
Coverage
A producer method may specify stereotypes.
Coverage
A producer method may specify qualifiers.
Coverage
If a producer method is annotated @Inject, has a parameter annotated @Disposes, or has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
Test with a producer method annotated @Inject.
Coverage
Test with a producer method annotated @Disposes.
Coverage
Test with a producer method annotated @Observes.
Coverage
If a non-static method of a session bean class is annotated @Produces, and the method is not a business method of the session bean, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare producer methods. If an interceptor or decorator has a method annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare producer methods. If an interceptor or decorator has a method annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
A producer method may have any number of parameters.
Coverage
All producer method parameters are injection points.
Coverage
If a producer method X is annotated @Specializes, then it must be non-static and directly override another producer method Y. Then X directly specializes Y, as defined in Section 4.3 "Specialization".
Coverage
If a producer method is static, the container automatically detects the problem and treats it as a definition error.
Coverage
If a producer method does not directly override another producer method, the container automatically detects the problem and treats it as a definition error.
Coverage
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
Test default name is the method name.
Coverage
Test default name is the JavaBeans property name.
Coverage
A producer field must be a default-access, public, protected or private, field of a managed bean class or session bean class
Coverage
A producer field must be a default-access, public, protected or private, field of a managed bean class or session bean class
Coverage
A producer field may be static.
Coverage
A producer field may be non-static.
Coverage
If the bean is a session bean, the producer field must be a static field of the bean class.
Coverage
If a producer field sometimes contains a null value when accessed, then the producer field must have scope @Dependent
Coverage
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"
Coverage
If the producer field type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter
Coverage
If the producer field type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter
Coverage
If a producer field type contains a wildcard type parameter the container automatically detects the problem and treats it as a definition error.
Coverage
If the producer field type is a parameterized type with a type variable, it must have scope @Dependent. If a producer field with a parameterized type with a type variable declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.
Coverage
If a producer field type is a type variable the container automatically detects the problem and treats it as a definition error.
Coverage
The application may access producer fields directly. However, if the application accesses a producer field directly, the returned object is not bound to any context; and its lifecycle is not managed by the container
A bean may declare multiple producer fields
Coverage
The bean types of a producer field depend upon the field type. If the field type is an interface, the unrestricted set of bean types contains the field type, all interfaces it extends directly or indirectly and java.lang.Object.
Coverage
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 unrestricted set of bean types contains exactly two types: the field type and java.lang.Object.
Check primitive type
Coverage
Check array type
Coverage
The bean types of a producer field depend upon the field type. If the field type is a class, the unrestricted set of bean types contains the field type, every superclass and all interfaces it implements directly or indirectly
Coverage
A producer field may be declared by annotating a field with the @javax.enterprise.inject.Produces annotation.
Coverage
A producer field may specify a scope.
Coverage
A producer field may specify a name.
Coverage
A producer field may specify stereotypes.
Coverage
A producer field may specify qualifiers.
Coverage
If a producer field is annotated @Inject, the container automatically detects the problem and treats it as a definition error.
Coverage
If a non-static field of a session bean class is annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare producer fields. If an interceptor or decorator has a field annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare producer fields. If an interceptor or decorator has a field annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
The default name for a producer field is the field name
Coverage
A disposer method must be a default-access, public, protected or private, non-abstract method of a managed bean class or session bean class.
Coverage
A disposer method may be static.
A disposer method may be non-static.
Coverage
If the bean is a session bean, the disposer method must be a business method of the EJB or a static method of the bean class.
Coverage
A bean may declare multiple disposer methods.
Coverage
Each disposer method must have exactly one disposed parameter, of the same type as the corresponding producer method return type or producer field type.
Coverage
When searching for disposer methods for a producer method or producer field the container considers the type and qualifiers of the disposed parameter. f a producer method or producer field declared by the same bean class is assignable to the disposed parameter, according to the rules of typesafe resolution defined in Section 5.2, "Typesafe resolution", the container must call this method when destroying any instance returned by that producer method or producer field.
A disposer method may resolve to multiple producer methods or producer fields declared by the bean class, in which case the container must call it when destroying any instance returned by any of these producer methods or producer fields.
Coverage
A disposer method may be declared by annotating a parameter @javax.enterprise.inject.Disposes. That parameter is the disposed parameter
Coverage
Qualifiers may be declared by annotating the disposed parameter.
Coverage
If a method has more than one parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
If a disposer method is annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
If a disposer method is annotated @Inject, the container automatically detects the problem and treats it as a definition error.
Coverage
If a disposer method has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
Coverage
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 session bean, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare disposer methods. If an interceptor or decorator has a method annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare disposer methods. If an interceptor or decorator has a method annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
In addition to the disposed parameter, a disposer method may declare additional parameters, which may also specify qualifiers. These additional parameters are injection points.
A disposer method is bound to a producer method if the producer method is declared by the same bean class as the disposer method, and the producer method is assignable to the disposed parameter, according to the rules of typesafe resolution defined in Section 5.2, "Typesafe resolution".
Coverage
A disposer method is bound to a producer field if the producer field is declared by the same bean class as the disposer method, and the producer field is assignable to the disposed parameter, according to the rules of typesafe resolution defined in Section 5.2, "Typesafe resolution".
Coverage
If there are multiple disposer methods for a single producer method or producer field, the container automatically detects the problem and treats it as a definition error.
Coverage
If there is no producer method or producer field declared by the bean class that is assignable to the disposed parameter of a disposer method, the container automatically detects the problem and treats it as a definition error.
Coverage
The container is not required to support resources with scope other than @Dependent.
A resource may not declare a bean EL name
A resource may be declared by specifying a Java EE component environment injection annotation as part of a producer field declaration.
For a persistence context, @PersistenceContext must be specified.
Coverage
For a persistence unit, @PersistenceUnit must be specified.
Coverage
For a remote EJB, @EJB must be specified.
Coverage
For a web service, @WebServiceRef must be specified.
Coverage
The injection annotation specifies the metadata needed to obtain the resources, entity manager, entity manager factory, remote EJB instance or web service reference from the component environment.
The bean type and qualifiers of the resource are determined by the producer field declaration.
Coverage
If the producer field declaration specifies an EL name, the container automatically detects the problem and treats it as a definition error.
Coverage
If the matching object in the Java EE component environment is not of the same type as the producer field declaration, the container automatically detects the problem and treats it as a definition errors.
Coverage
The unrestricted set of bean types of a resource is determined by the declared type of the producer field, as specified by Section 3.4.1, "Bean types of a producer field".
Check @PersistenceContext
Coverage
Check @PersistenceUnit
Coverage
Check @EJB
Coverage
Check @WebServiceRef
Coverage
A Java EE or embeddable EJB container must provide a bean with qualifier @Default and bean type javax.transaction.UserTransaction, allowing injection of a reference to the JTA UserTransaction.
Coverage
A Java EE or embeddable EJB container must provide a bean with qualifier @Default and bean type javax.security.Principal, allowing injection of a Principal representing the current caller identity.
A servlet container must provide a bean with qualifier @Default and bean type javax.servlet.http.HttpServletRequest, allowing injection of a reference to the HttpServletRequest. This bean is passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
A servlet container must provide a bean with qualifier @Default and bean type javax.servlet.http.HttpSession, allowing injection of a reference to the HttpSession. This bean is passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
A servlet container must provide a bean with qualifier @Default and bean type javax.servlet.ServletContext, allowing injection of a reference to the ServletContext. This bean is passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
If a Java EE component class has an injection point of type UserTransaction and qualifier @Default, and may not validly make use of the JTA UserTransaction according to the Java EE platform specification, the container automatically detects the problem and treats it as a definition error.
Coverage
When the container instantiates a bean, it calls the bean constructor. The bean constructor is a default-access, public, protected or private constructor of the bean class.
Coverage
The bean constructor may be identified by annotating the constructor @Inject
Test an @Inject constructor is used on a managed bean
Coverage
Test an @Inject constructor is used on a session bean
Coverage
If a bean class does not explicitly declare a constructor using @Inject, the constructor that accepts no parameters is the bean constructor.
Coverage
If a bean class has more than one constructor annotated @Inject, the container automatically detects the problem and treats it as a definition error.
Coverage
If a bean constructor has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
If a bean constructor has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
Coverage
A bean constructor may have any number of parameters.
Coverage
An injected field is a non-static, non-final field of a bean class, a non-static, non-final field of an enum, or of any Java EE component class supporting injection.
Test a bean class.
Coverage
Test a Java EE component class.
Coverage
An injected field may be declared by annotating the field @javax.inject.Inject.
If an injected field is annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
An initializer method is a default-access, public, protected or private, non-abstract, non-static, non-generic method of a bean class, a non-abstract, non-static method of an enum or of any Java EE component class supporting injection.
Test a bean-class.
Coverage
Test a Java EE component class.
Coverage
If the bean is a session bean, the initializer method is not required to be a business method of the session bean.
Coverage
Method interceptors are never called when the container calls an initializer method
Coverage
A bean class may declare multiple (or zero) initializer methods
Coverage
The application may call initializer methods directly, but then no parameters will be passed to the method by the container
An initializer method may be declared by annotating the method @javax.inject.Inject
Coverage
If a generic method of a bean is annotated @Inject, the container automatically detects the problem and treats it as a definition error.
Coverage
If an initializer method is annotated @Produces, the container automatically detects the problem and treats it as a definition error.
Coverage
If an initializer method has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
If an initializer method has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
Coverage
An initializer method may have any number of parameters.
Coverage
All initializer method parameters are injection points.
If an injection point declares no qualifier, the injection point has exactly one qualifier, the default qualifier @Default.
Coverage
Any type or package may be prevented from being considered by CDI by adding the @Vetoed annotation on the type or package.
Coverage
If an injected field declares a @Named annotation that does not specify the value member, the name of the field is assumed.
Coverage
If any other injection point declares a @Named annotation that does not specify the value member, the container automatically detects the problem and treats it as a definition error.
Coverage
For each managed bean, a second bean exists which has the same bean class.
Coverage
For each managed bean, a second bean exists which has the same bean types.
Coverage
For each managed bean, a second bean exists which has the same bean constructor.
Coverage
For each managed bean, a second bean exists which has the same initializer methods.
Coverage
For each managed bean, a second bean exists which has the same injected fields.
Coverage
For each managed bean, a second bean exists which has the same interceptor bindings.
Coverage
For each session bean, a second bean exists which has the same bean class.
Coverage
For each session bean, a second bean exists which has the same bean types.
Coverage
For each session bean, a second bean exists which has the same bean constructor.
Coverage
For each session bean, a second bean exists which has the same initializer methods.
Coverage
For each session bean, a second bean exists which has the same injected fields.
Coverage
For each session bean, a second bean exists which has the same interceptor bindings.
Coverage
This second bean has scope @Dependent.
Coverage
This second bean has exactly one qualifier: @javax.enterprise.inject.New(X.class) where x is the bean class.
Coverage
This second bean has no bean EL name.
Coverage
This second bean has no producer fields.
Coverage
This second bean is not an alternative.
Coverage
This second bean is enabled, in the sense of Section 5.1.2, "Enabled and disabled beans", if and only if some other enabled bean has an injection point with the qualifier @New(X.class) where X is the bean class.
Coverage
This bean is called the @New qualified bean for the class X.
Note that this second bean exists, and may be enabled and available for injection even if the first bean is disabled, as defined by Section 5.1.2, “Enabled and disabled beans” or if the bean class is deployed outside of a bean deployment archive, as defined in Section 12.1, “Bean deployment archives”, and is therefore not discovered during the bean discovery process defined in Chapter 12, Packaging and deployment. The container discovers @New qualified beans by inspecting injection points of other enabled beans.
Check that @New on a field injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a field injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
Check that @New on a initializer method injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a initializer method injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
Check that @New on a constructor injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a constructor injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
Check that @New on a producer method injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a producer method injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
Check that @New on a observer method injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a observer method injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
Check that @New on a disposer method injection point outside the BDA, but in the classpath causes a bean with qualifier @New and the given type to be created
Coverage
Check that @New on a disposer method injection point (which is a session bean class) outside the BDA, but in the classpath causes a session bean with qualifier @New and the given type to be created
Coverage
When the qualifier @New is specified at an injection point and no value member is explicitly specified, the container defaults the value to the declared type of the injection point.
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y. If X is annotated with a qualifier type, stereotype or 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.
Test qualifier type for directly extended managed bean annotated @Inherited is inherited.
Coverage
Test qualifier type for directly extended managed bean not annotated @Inherited is not inherited.
Test stereotype for directly extended managed bean annotated @Inherited is inherited.
Test stereotype for directly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test interceptor binding type for directly extended managed bean annotated @Inherited is inherited.
Coverage
Test interceptor binding type for directly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test qualifier type for indirectly extended managed bean annotated @Inherited is inherited.
Coverage
Test qualifier type for indirectly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test stereotype for indirectly extended managed bean annotated @Inherited is inherited.
Coverage
Test stereotype for indirectly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test interceptor binding type for indirectly extended managed bean annotated @Inherited is inherited.
Coverage
Test interceptor binding type for indirectly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test qualifier type for directly extended session bean annotated @Inherited is inherited.
Coverage
Test qualifier type for directly extended session bean not annotated @Inherited is not inherited.
Coverage
Test stereotype for directly extended session bean annotated @Inherited is inherited.
Coverage
Test stereotype for directly extended session bean not annotated @Inherited is not inherited.
Coverage
Test interceptor binding type for directly extended session bean annotated @Inherited is inherited.
Coverage
Test interceptor binding type for directly extended session bean not annotated @Inherited is not inherited.
Coverage
Test qualifier type for indirectly extended session bean annotated @Inherited is inherited.
Coverage
Test qualifier type for indirectly extended session bean not annotated @Inherited is not inherited.
Coverage
Test stereotype for indirectly extended session bean annotated @Inherited is inherited.
Coverage
Test stereotype for indirectly extended session bean not annotated @Inherited is not inherited.
Coverage
Test interceptor binding type for indirectly extended session bean annotated @Inherited is inherited.
Coverage
Test interceptor binding type for indirectly extended session bean not annotated @Inherited is not inherited.
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or 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.
Test scope type for directly extended managed bean annotated @Inherited is inherited.
Coverage
Test scope type for directly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test scope type for indirectly extended managed bean annotated @Inherited is inherited.
Coverage
Test scope type for indirectly extended managed bean not annotated @Inherited is not inherited.
Coverage
Test scope type for directly extended session bean annotated @Inherited is inherited.
Coverage
Test scope type for directly extended session bean not annotated @Inherited is not inherited.
Coverage
Test scope type for indirectly extended session bean annotated @Inherited is inherited.
Coverage
Test scope type for indirectly extended session bean not annotated @Inherited is not inherited.
Coverage
For class X which is extended directly by the bean class of a managed bean Y, a scope type explicitly declared by X and inherited by Y from X takes precedence over default scopes of stereotypes declared or inherited by Y.
Coverage
For class X which is extended indirectly by the bean class of a managed bean Y, a scope type explicitly declared by X and inherited by Y from X takes precedence over default scopes of stereotypes declared or inherited by Y.
Coverage
For class X which is extended directly by the bean class of a session bean Y, a scope type explicitly declared by X and inherited by Y from X takes precedence over default scopes of stereotypes declared or inherited by Y.
Coverage
For class X which is extended indirectly by the bean class of a session bean Y, a scope type explicitly declared by X and inherited by Y from X takes precedence over default scopes of stereotypes declared or inherited by Y.
Coverage
For annotations defined by the bean specification, all built-in scope types are declared @Inherited
For annotations defined by the bean specification, all built-in stereotypes are declared @Inherited
For annotations defined by the bean specification, no built-in qualifier type is declared @Inherited
The @Named annotation is not declared @Inherited and bean EL names are not inherited unless specialization is used
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y. If X declares an injected field x then Y inherits x.
Check managed bean X directly extends managed bean Y
Coverage
Check managed bean X indirectly extends managed bean Y
Coverage
Check session bean X directly extends session bean Y
Coverage
Check session bean X indirectly extends session bean Y
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y. If X declares an initializer, non-static observer, @PostConstruct or @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().
Check managed bean X directly extends managed bean Y with @PostConstruct
Check session bean X directly extends session bean Y with @PostConstruct
Coverage
Check managed bean X indirectly extends managed bean Y with @PostConstruct
Coverage
Check session bean X indirectly extends session bean Y with @PostConstruct
Coverage
Check managed bean X directly extends managed bean Y with @PostDestroy
Check session bean X directly extends session bean Y with @PostDestroy
Coverage
Check managed bean X indirectly extends managed bean Y with @PostDestroy
Coverage
Check session bean X indirectly extends session bean Y with @PostDestroy
Coverage
Check managed bean X directly extends managed bean Y with a non-static observer method
Check session bean X directly extends session bean Y with a non-static observer method
Coverage
Check managed bean X indirectly extends managed bean Y with a non-static observer method
Check session bean X indirectly extends session bean Y with a non-static observer method
Coverage
Check managed bean X directly extends managed bean Y with a initializer method
Coverage
Check session bean X directly extends session bean Y with a initializer method
Coverage
Check managed bean X indirectly extends managed bean Y with a initializer method
Coverage
Check session bean X indirectly extends session bean Y with a initializer method
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or 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().
Check managed bean X directly extends managed bean Y
Check session bean X directly extends session bean Y
Coverage
Check managed bean X indirectly extends managed bean Y
Check session bean X indirectly extends session bean Y
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y .If X declares a non-static producer or disposer method x() then Y does not inherit this method.
Check managed bean X directly extends managed bean Y with a non-static producer method
Check managed bean X directly extends managed bean Y with a non-static disposer method
Coverage
Check session bean X directly extends session bean Y with a non-static producer method
Check session bean X directly extends session bean Y with a non-static disposer method
Coverage
Check managed bean X indirectly extends managed bean Y with a non-static producer method
Coverage
Check managed bean X indirectly extends managed bean Y with a non-static disposer method
Coverage
Check session bean X indirectly extends session bean Y with a non-static producer method
Coverage
Check session bean X indirectly extends session bean Y with a non-static disposer method
Coverage
Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y. If X declares a non-static producer field x then Y does not inherit this field.
Check managed bean X directly extends managed bean Y
Coverage
Check managed bean X indirectly extends managed bean Y
Coverage
If X is a generic type, and an injection point or observer method declared by X is inherited by Y, and the declared type of the injection point, producer method, producer field, disposed para- meter or event parameter contains type variables declared by X, the type of the injection point, producer method, producer field, disposed parameter or event parameter inherited in Y is the declared type, after substitution of actual type arguments declared by Y or any intermediate class that is a subclass of X and a superclass of Y.
If two beans both support a certain bean type, and share at least one qualifier, then they are both eligible for injection to any injection point with that declared type and qualifier.
When an enabled bean specializes a second bean, we can be certain that the second bean is never instantiated or called by the container. Even if the second bean defines a producer or observer method, the method will never be called.
The second bean is never instantiated.
Coverage
Producer method on specialized bean is not called.
Coverage
Observer method on specialized bean is not called.
Producer field on specialized bean is not used.
Coverage
A bean X is said to specialize another bean Y if X directly specializes Y.
Coverage
A bean X is said to specialize another bean Y if a bean Z exists, such that X directly specializes Z and Z specializes Y.
Coverage
A bean X that specializes bean Y will include all qualifiers of Y, together with all qualifiers declared explicitly by X.
Coverage
A bean X that specializes bean Y will have the same name as Y if Y has a name.
Coverage
X must have all the bean types of Y. If X does not have some bean type of Y, the container automatically detects the problem and treats it as a definition error.
If Y has a bean name and X declares a bean name explicitly the container automatically detects the problem and treats it as a definition error.
Test that a specializing producer method with a name throws a definition exception.
Coverage
Test that a specializing managed bean with a name throws a definition exception.
Coverage
Test that a specializing enterprise bean with a name throws a definition exception.
Coverage
If an interceptor or decorator is annotated @Specializes, non-portable behavior results.
The container is required to support circularities in the bean dependency graph where at least one bean participating in every circular chain of dependencies has a normal scope, as defined in Section 6.3, "Normal scopes and pseudo-scopes".
Coverage
The container is not required to support circular chains of dependencies where every bean participating in the chain has a pseudo-scope.
Beans packaged in a certain Java EE module or library are available for injection, lookup and EL resolution to classes and JSP/JSF pages packaged in some other Java EE module or library if and only if the first module or library is required to be accessible to the other module or library by the Java EE platform specification.
Test with injection.
Coverage
Test with lookup.
Coverage
Test with EL resolution.
Coverage
An alternative is never available for injection, lookup or EL resolution in a Java EE module or library that is not a bean deployment archive (a module or library with no beans.xml file.
Nor is an alternative available for injection, lookup or EL resolution in every bean deployment archive. An alternative must be explicitly selected in every bean deployment archive in which the alternative should be available for injection, lookup and EL resolution.
Coverage
Alternatives may be selected for an application, or selected only for a particular bean archive.
By default, a bean archive has no selected alternatives.
Coverage
An alternative may be selected for an application using the <alternatives> element of the beans.xml file of the bean archive that declares the alternative. The <alternatives> element contains a list of bean classes and stereotypes, along with a priority attribute.
An alternative is selected for the entire application if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a priority attribute.
Coverage
An alternative is selected for the entire application if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a priority attribute.
Coverage
No tests exist for this assertion
An alternative is selected for the entire application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a priority attribute.
Coverage
An alternative is selected for the entire application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a priority attribute.
Coverage
An alternative is selected for the entire application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a priority attribute.
An alternative is selected for the entire application if any @Alternative stereotype of the alternative is listed, along with a priority attribute.
Coverage
An alternative may be selected for a bean archive using the <alternatives> element of the beans.xml file of the bean archive. The <alternatives> element contains a list of bean classes and stereotypes, along with a priority attribute.
An alternative is selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed.
Coverage
An alternative is selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed.
Coverage
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed.
Coverage
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed.
Coverage
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed.
Coverage
An alternative is selected for the bean archive if any @Alternative stereotype of the alternative is listed.
Coverage
An alternative selected only for a specific bean archive is not selected for an application.
Coverage
An alternative selected for an application may be deselected for a bean archive using the <alternatives> element of the beans.xml file of the bean archive. The <alternatives> element contains a list of bean classes and stereotypes, along with a disabled flag.
An alternative is not selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a disabled flag.
Coverage
An alternative is not selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a disabled flag.
Coverage
No tests exist for this assertion
An alternative is not selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag.
Coverage
An alternative is not selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag.
Coverage
An alternative is not selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag.
Coverage
An alternative is not selected for the bean archive if any @Alternative stereotype of the alternative is listed, along with a disabled flag.
Coverage
An alternative may be given a default priority, but not selected for an application using the <alternatives> element of the beans.xml file of the bean archive. The <alternatives> element contains a list of bean classes and stereotypes, along with a disabled flag and a priority attribute.
An alternative is is not selected for an application if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a disabled flag and a priority attribute.
Coverage
An alternative is is not selected for an application if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with a disabled flag and a priority attribute.
Coverage
No tests exist for this assertion
An alternative is is not selected for an application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag and a priority attribute.
Coverage
An alternative is is not selected for an application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag and a priority attribute.
Coverage
An alternative is is not selected for an application if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with a disabled flag and a priority attribute.
Coverage
An alternative is is not selected for an application if any @Alternative stereotype of the alternative is listed, along with a disabled flag and a priority attribute.
Coverage
An alternative with a default priority may be selected for a bean archive using the <alternatives> element of the beans.xml file of the bean archive. The <alternatives> element contains a list of bean classes and stereotypes, along with an enabled flag.
An alternative is selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with an enabled flag.
Coverage
An alternative is selected for the bean archive if the alternative is a managed bean or session bean and the bean class of the bean is listed, along with an enabled flag.
Coverage
No tests exist for this assertion
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with an enabled flag.
Coverage
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with an enabled flag.
Coverage
An alternative is selected for the bean archive if the alternative is a producer method, field or resource, and the bean class that declares the method or field is listed, along with an enabled flag.
Coverage
An alternative is selected for the bean archive if any @Alternative stereotype of the alternative is listed, along with an enabled flag.
Coverage
Each child <class> element must specify the name of a bean class of an alternative bean. If there is no class with the specified name, or if the class with the specified name is not an alternative bean class, the container automatically detects the problem and treats it as a deployment problem.
Each child <stereotype> element must specify the name of a @Alternative stereotype annotation. If there is no annotation with the specified name, or the annotation is not a @Alternative stereotype, the container automatically detects the problem and treats it as a deployment problem.
If the same type is listed twice under the <alternatives> element, the container automatically detects the problem and treats it as a deployment problem.
Coverage
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls isAlternative() to determine whether the bean is an alternative, and getBeanClass() and getStereotypes() to determine whether an alternative is selected in a certain bean deployment archive.
A bean is said to be enabled if it is deployed in a bean deployment archive, and it is not a producer method or field of a disabled bean, and it is not specialized by any other enabled bean, as defined in Section 4.3, "Specialization", and either it is not an alternative, or it is a selected alternative of at least one bean deployment archive. Otherwise, the bean is said to be disabled.
Suppose an enabled bean X specializes a second bean Y. If there is another enabled bean that specializes Y we say that inconsistent specialization exists. The container automatically detects inconsistent specialization and treats it as a deployment problem.
Coverage
A bean is available for injection in a certain module if the bean is not an interceptor or decorator, the bean is enabled, the bean is either not an alternative, or the module is a bean archive and the bean is a selected alternative of the bean archive, and the bean class is required to be accessible to classes in the module, according to the class accessibility requirements of the module architecture.
Check a decorator can not be injected
Coverage
Check an enabled managed bean can be injected
Coverage
Check an enabled session bean can be injected
Coverage
Check an enabled producer field can be injected
Coverage
Check an enabled producer method can be injected
Coverage
Check producer method of a disabled bean is not injectable
Coverage
Check producer field of a disabled bean is not injectable
Coverage
Check a disabled managed bean is not injectable
Coverage
Check a disabled session bean is not injectable
Coverage
Check a specialized session bean is not injectable
Coverage
Check a specialized managed bean is not injectable
Coverage
Check a specialized producer field is not injectable
Check a specialized producer method is not injectable
Coverage
Check a selected alternative is injected for a managed bean
Coverage
Check a selected alternative is injected for a session bean
Coverage
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface, the container calls getBeanClass() to determine the bean class of the bean and InjectionPoint.getMember() and then Member.getDeclaringClass() to determine the class that declares an injection point.
Check Bean.getBeanClass() is used to determine the bean class
Coverage
Check InjectionPoint.getMember().getDeclaringClass() is used to determine the class declaring the injection point
Coverage
No tests exist for this assertion
A bean is assignable to a given injection point if the bean has a bean type that matches the required type. For this purpose, primitive types are considered to match their corresponding wrapper types in java.lang and array types are considered to match only if their element types are identical. Parameterized and raw types are considered to match if they are identical or if the bean type is assignable to the required type, as defined in Section 5.2.3, "Assignability of raw and parameterized types".
Test with a primitive type.
Coverage
Test with an array type.
Coverage
Test with a parameterized type.
Coverage
Test with a raw type.
Coverage
Test with a @Named bean.
A bean is assignable to a given injection point if the bean has all the required qualifiers. If no required qualifiers were explicitly specified, the container assumes the required qualifier @Default. A bean has the required qualifier if it has a qualifier with (a) the same type and (b) the same annotation member value for each member which is not annotated @javax.enterprise.util.NonBinding.
Test with beans without required qualifiers.
Test with matching beans with matching qualifier with same type.
Coverage
Test with matching beans with matching qualifier with same annotation member value for each member which is not annotated @javax.enterprise.util.NonBinding.
Coverage
A bean is eligible for injection to a certain injection point if it is available for injection in the module that contains the class that declares the injection point, and it is assignable to the injection point.
Coverage
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls getTypes() and getQualifiers() to determine the bean types and qualifiers.
Test getTypes() determines bean types.
Coverage
Test getQualifiers() determines qualifiers.
Coverage
When an ambiguous dependency exists, the container attempts to resolve the ambiguity. The container eliminates all eligible beans that are not alternatives, except for producer methods and fields of beans that are alternatives. If there is exactly one bean remaining, the container will select this bean, and the ambiguous dependency is called resolvable. If all the beans left are alternatives with a priority, then the container will select the alternative with the highest priority, and the ambiguous dependency is called resolvable.
Test that the container eliminates all eligible beans that are not alternatives, except for producer methods and fields of beans that are alternatives.
Coverage
Test that the container eliminates all eligible beans that are not alternatives, except for producer methods and fields of beans that are alternatives.
Test that the container will select the alternative with the highest priority.
Coverage
The container must validate all injection points of all enabled beans, all enums, all observer methods, all disposer methods and all other Java EE component classes supporting injection when the application is initialized to ensure that there are no unsatisfied or ambiguous dependencies. If an unsatisfied or ambiguous dependency exists, the container automatically detects the problem and treats it as a deployment problem.
Test unsatisfied dependency for observer method.
Coverage
Test unsatisfied dependency for disposer method.
Coverage
Test unsatisfied dependency for Java EE component.
Coverage
Test ambiguous dependency for enabled bean.
Coverage
Test ambiguous dependency for observer method.
Coverage
Test ambiguous dependency for disposer method.
Coverage
Test ambiguous dependency for Java EE component.
Coverage
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls getInjectionPoints() to determine the set of injection points.
Coverage
Any legal bean type, as defined in Section 2.2.1, "Legal bean types" may be the required type of an injection point.
Coverage
The required type of an injection point may contain a wildcard type parameter. However, a type variable is not a legal injection point type.
Coverage
If an injection point type is a type variable, the container automatically detects the problem and treats it as a definition error.
Coverage
A parameterized bean type is considered assignable to a raw required type if the raw types are identical and all type parameters of the bean type are either unbounded type variables or java.lang.Object.
Coverage
A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and for each parameter: the required type parameter and the bean type parameter are actual types with identical raw type, and, if the type is parameterized, the bean type parameter is assignable to the required type parameter according to these rules, or the required type parameter is a wildcard, the bean type parameter is an actual type and the actual type is assignable to the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard, or the required type parameter is a wildcard, the bean type parameter is a type variable and the upper bound of the type variable is assignable to or assignable from the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard, or the required type parameter is an actual type, the bean type parameter is a type variable and the actual type is as- signable to the upper bound, if any, of the type variable, or the required type parameter and the bean type parameter are both type variables and the upper bound of the required type parameter is assignable to the upper bound, if any, of the bean type parameter.
Check the required type parameter and the bean type parameter are actual types with identical raw type
Coverage
Check the required type parameter and the bean type parameter are actual types with identical raw type for nested type parameters
Coverage
Check the required type parameter is a wildcard, the bean type parameter is an actual type and the actual type is assignable to the upper bound of the wildcard and assignable from the lower bound of the wildcard
Coverage
Check the required type parameter is a wildcard, the bean type parameter is a type variable and the upper bound of the type variable is assignable to the upper bound of the wildcard and assignable from the lower bound of the wildcard
Coverage
Check the required type parameter is a wildcard, the bean type parameter is a type variable and the upper bound of the type variable is assignable from the upper bound of the wildcard and assignable from the lower bound of the wildcard
Coverage
Check the required type parameter is an actual type, the bean type parameter is a type variable and the actual type is assignable to the upper bound of the type variable
Coverage
Check the required type parameter and the bean type parameter are both type variables and the upper bound of the required type parameter is assignable to the upper bound of the bean type parameter.
Coverage
A raw bean type is not assignable to a parameterized required type.
Coverage
If necessary, the container performs boxing or unboxing when it injects a value to a field or parameter of primitive or wrapper type.
Test unboxing.
Coverage
If an injection point of primitive type resolves to a producer method or producer field that returns a null value at runtime, the container must inject the primitive type's default value as defined by the Java Language Specification.
Coverage
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls isNullable() to determine whether the bean may have null values.
Qualifier types may have annotation members.
An annotation member may be excluded from consideration using the @NonBinding annotation.
Coverage
Array-valued or annotation-valued members of a qualifier type should be annotated @NonBinding in a portable application. If an array-valued or annotation-valued member of a qualifier is not annotated @NonBinding, non-portable behavior results.
A bean class may declare multiple qualifiers.
Coverage
A producer method may declare multiple qualifiers.
Coverage
A producer field may declare multiple qualifiers.
Coverage
A bean must declare all of the qualifiers that are specified at the injection point to be considered a candidate for injection.
Coverage
An EL name resolves to a bean if the bean has the given EL name, and the bean is available for injection in the war containing the JSP or JSF page with the EL expression.
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls getName() to determine the bean EL name.
Coverage
An ambiguous EL name exists in an EL expression when an EL name resolves to multiple beans. When an ambiguous EL name exists, the container attempts to resolve the ambiguity. If any of the beans are alternatives, the container eliminates all beans that are not alternatives. If there is exactly one bean remaining, the container will select this bean, and the ambiguous EL name is called resolvable.
Coverage
All unresolvable ambiguous EL names are detected by the container when the application is initialized. Suppose two beans are both accessible to classes in a certain war, and either the two beans have the same EL name and the name is not resolvable, or the EL name of one bean is of the form x.y, where y is a valid bean EL name, and x is the EL name of the other bean, the container automatically detects the problem and treats it as a deployment problem.
Test with two beans with the same EL name.
Coverage
Test with with an EL name in the form x.y.
Coverage
A contextual reference to a bean with a normal scope, as defined in Section 6.3, “Normal scopes and pseudo-scopes”, is not a direct reference to a contextual instance of the bean (the object returned by Contextual.create()). Instead, the contextual reference is a client proxy object.
Coverage
Client proxies are never required for a bean whose scope is a pseudo-scope such as @Dependent.
Client proxies are serializable
Coverage
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
Client proxies may be shared between multiple injection points.
Certain legal bean types cannot be proxied by the container. If an injection point whose declared type cannot be proxied by the container resolves to a bean with a normal scope, the container automatically detects the problem and treats it as a deployment problem.
Test a class which doesn't have a non-private constructor with no parameters.
Coverage
Test a class which is declared final.
Test a class that has non-static, final method with public visibility.
Coverage
Test with a class that has static final method with public visibility.
Coverage
Test a class that has final method with private visibility.
Coverage
Test primitive type
Coverage
Test array type.
Coverage
Every time a method of the bean is invoked upon a client proxy, the client proxy must obtain a contextual instance of the bean, as defined in Section 6.5.2, "Contextual instance of a bean", and invoke the method upon this instance.
Coverage
If the scope is not active, as specified in Section 6.5.1, "The active context object for a scope", the client proxy rethrows ContextNotActiveException or IllegalStateException.
The behavior of all methods declared by java.lang.Object, except for toString(), is undefined for a client proxy.
The container is required to perform dependency injection whenever it creates a contextual instance of a session bean.
Coverage
The container is required to perform dependency injection whenever it creates a contextual instance of a managed bean.
The container is required to perform dependency injection whenever it instantiates non-contextual instances of session beans (for example, session beans obtained by the application from JNDI or injected using @EJB).
Coverage
The container is required to perform dependency injection whenever it instantiates non-contextual instances of managed beans.
Coverage
The container is required to perform dependency injection whenever it instantiates non-contextual instances of enums.
The container is required to perform dependency injection whenever it instantiates instances of any other Java EE component class supporting injection.
Test injection into a servlet listener
Coverage
Test injection into a tag handler
Coverage
Test injection into a tag library listener
Coverage
Test injection into an EJB Interceptor
Coverage
Test injection into a WS endpoint
Coverage
Test injection into a servlet
Coverage
Test injection into a filter
Coverage
A Java EE 5 container is not required to support injection for non-contextual objects.
The container interacts with instances of beans, enums and other Java EE component classes supporting injection by calling methods and getting and setting the field values.
Coverage
No tests exist for this assertion
The object injected by the container may not be a direct reference to a contextual instance of the bean. Instead, it is an injectable reference, as defined by Section 6.5.5, "Injectable references".
Coverage
No tests exist for this assertion
When the container instantiates a managed bean or session bean with a constructor annotated @Inject, the container calls this constructor, passing an injectable reference to each parameter. If there is no constructor annotated @Inject, the container calls the constructor with no parameters.
Test managed bean with a constructor annotated @Inject.
Coverage
Test session bean with a constructor annotated @Inject.
Coverage
Test constructor with no parameters is used for a managed bean
Coverage
Test constructor with no parameters is used for a session bean
Coverage
When the container creates a new instance of a managed bean, session bean, enum or of any other Java EE component class supporting injection, the container must: Initialize the values of all injected fields. The container sets the value of each injected field to an injectable reference. Call all initializer methods, passing an injectable reference to each parameter.
Test session bean fields injected
Coverage
Test session bean initializer methods called
Coverage
Test managed bean fields injected
Test managed bean initializer methods called
Coverage
Test Servlet fields injected
Coverage
Test Servlet initializer methods called
Coverage
Test Servlet Filter fields injected
Coverage
Test Servlet Filter initializer methods called
Coverage
Test Servlet Listener fields injected
Coverage
Test Servlet Listener initializer methods called
Coverage
Test non-contextual session bean fields injected
Coverage
Test non-contextual session bean initializer methods called
Coverage
Test tag handler fields injected
Coverage
Test tag handler initializer methods called
Coverage
Test EJB interceptor fields injected
Coverage
Test EJB interceptor initializer methods called
Coverage
Test WS endpoint fields injected
Coverage
Test WS endpoint bean initializer methods called
Coverage
Test tag handler listener fields injected
Coverage
Test tag handler listener initializer methods called
Coverage
Test JSF managed bean fields injected
Coverage
Test JSF managed bean initializer methods called
Coverage
The container must ensure that: Initializer methods declared by a class X in the type hierarchy of the bean are called after all injected fields declared by X or by superclasses of X have been initialized, and after all Java EE component environment resource dependencies declared by X or by superclasses of X have been injected. Any @PostConstruct callback declared by a class X in the type hierarchy of the bean is called after all initializer meth- ods declared by X or by superclasses of X have been called, after all injected fields declared by X or by superclasses of X have been initialized, and after all Java EE component environment resource dependencies declared by X or by superclasses of X have been injected. Any servlet init() method is called after all initializer methods have been called, all injected fields have been initialized and all Java EE component environment resource dependencies have been injected.
Test session bean initializer methods called after injected field of X
Coverage
Test session bean initializer methods called after injected field of superclass of X
Coverage
Test session bean initializer methods called after EE resource injection of X
Coverage
Test session bean initializer methods called after EE resource injection of superclass of X
Coverage
Test session bean @PostConstruct called after initializer of X
Coverage
Test session bean @PostConstruct called after initializer of superclass of X
Coverage
Test managed bean initializer methods called after injected field of X
Coverage
Test managed bean initializer methods called after injected field of superclass of X
Coverage
Test managed bean initializer methods called after EE resource injection of X
Coverage
No tests exist for this assertion
Test managed bean initializer methods called after EE resource injection of superclass of X
Coverage
No tests exist for this assertion
Test managed bean @PostConstruct called after initializer of X
Coverage
Test managed bean @PostConstruct called after initializer of superclass of X
Coverage
Servlet init() method called after initializer method
Coverage
Servlet init() method called after injected fields
Coverage
Servlet init() method called after Java EE resource injection
Coverage
No tests exist for this assertion
Servlet Filter init() method called after initializer method
Coverage
Servlet Filter init() method called after injected fields
Coverage
Servlet Filter init() method called after Java EE resource injection
Coverage
No tests exist for this assertion
When the container destroys an instance of a bean, enum or of any Java EE component class supporting injection, the container destroys all dependent objects, as defined in Section 6.4.2, "Destruction of objects with scope @Dependent", after the @PreDestroy callback completes and after the servlet destroy() method is called.
When the container calls a producer method, if the method is static, the container must invoke the method.
Coverage
When the container calls a disposer method, if the method is static, the container must invoke the method.
Coverage
When the container calls a producer method, if the method is non-static the container must obtain a contextual instance of the bean which declares the method, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.
Coverage
When the container calls a disposer method, if the method is non-static the container must obtain a contextual instance of the bean which declares the method, as defined by Section 6.5.2 "Contextual instance of a bean", then invoke the method upon this instance.
Coverage
The container passes an injectable reference to each injected method parameter.
Coverage
The container is also responsible for destroying dependent objects created during this invocation, as defined in Section 6.4.2, "Destruction of objects with scope @Dependent".
When the container accesses the value of a producer field, if the producer field is static, the container must access the field value.
Coverage
When the container accesses the value of a producer field, if the producer field is non-static, the container must obtain a contextual instance of the bean which declares the producer field, as defined by Section 6.5.2 "Contextual instance of a bean", then access the field value of this instance.
Coverage
When the container calls an observer method (defined in Section 10.4 "Observer methods"), if the observer method is static, the container must invoke the method.
When the container calls an observer method (defined in Section 10.4 "Observer methods"), if the observer method is non-static, the container must obtain a contextual instance of the bean according to Section 6.5.2 "Contextual instance of a bean". If this observer method is a conditional observer method, obtain the contextual instance that already exists, only if the scope of the bean that declares the observer method is currently active, without creating a new contextual instance. Finally, the container must invoke the observer method on the resulting instance, if any, as a business method invocation, as defined in Section 7.2 "Container invocations and interception".
The container must pass the event object to the event parameter and an injectable instance to each injected method parameter.
The container is also responsible for destroying dependent objects created during this invocation, as defined in Section 6.4.2, "Destruction of objects with scope @Dependent".
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getBean() method returns the Bean object representing the bean that defines the injection point.
If the injection point represents a dynamically obtained instance, the getBean() method should return the Bean object representing the bean that defines the Instance injection point.
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getType() method returns the declared type of the injection point.
If the injection point represents a dynamically obtained instance, the javax.enterprise.inject.spi.InjectionPoint.getType() method returns the required type (as defined by Instance.select()).
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getQualifiers() method returns the declared qualifiers of the injection point.
Coverage
If the injection point represents a dynamically obtained instance, the javax.enterprise.inject.spi.InjectionPoint.getQualifiers() method returns required qualifiers of the injection point including any additional required qualifers (as defined by Instance.select()).
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Field object in the case of field injection.
Coverage
If the injection point represents a dynamically obtained instance, the javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Field object representing the field that defines the Instance injection point in the case of field injection.
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Method object in the case of method parameter injection.
Coverage
If the injection point represents a dynamically obtained instance, the javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Method object representing the method that defines the Instance injection point in the case of method parameter injection.
Coverage
The javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Constructor object in the case of constructor parameter injection.
Coverage
If the injection point represents a dynamically obtained instance, the javax.enterprise.inject.spi.InjectionPoint.getMember() method returns the Constructor object representing the constructor that defines the Instance injection point in the case of constructor parameter injection.
Coverage
The getAnnotated() method returns an instance of javax.enterprise.inject.spi.AnnotatedField or javax.enterprise.inject.spi.AnnotatedParameter, depending upon whether the injection point is an injected field or a constructor/method parameter.
If the injection point represents a dynamically obtained instance, then the getAnnotated() method returns an instance of javax.enterprise.inject.spi.AnnotatedField or javax.enterprise.inject.spi.AnnotatedParameter representing the Instance injection point, depending upon whether the injection point is an injected field or a constructor/method parameter.
Coverage
No tests exist for this assertion
The isDelegate() method returns true if the injection point is a decorator delegate injection point, and false otherwise.
If the injection point represents a dynamically obtained instance then isDelegate() returns false.
Coverage
The isTransient() method returns true if the injection point is a transient field, and false otherwise.
If the injection point represents a dynamically obtained instance then the isTransient() method returns true if the Instance injection point is a transient field, and false otherwise.
Coverage
The container must provide a bean with scope @Dependent, bean type InjectionPoint and qualifier @Default, allowing dependent objects, as defined in Section 6.4.1, "Dependent objects", to obtain information about the injection point to which they belong.
The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
Coverage
If a bean that declares any scope other than @Dependent has an injection point of type InjectionPoint and qualifier @Default, the container automatically detects the problem and treats it as a definition error.
Coverage
If a Java EE component class supporting injection that is not a bean has an injection point of type InjectionPoint and qualifier @Default, the container automatically detects the problem and treats it as a definition error.
Coverage
The InjectionPoint injected into a disposer method represents the producer method for which the disposer method is being invoked.
Coverage
The InjectionPoint injected into a decorator represents the injection point on the bean the decorated type is injected into.
Coverage
The container must provide beans allowing a bean instance to obtain a Bean, Interceptor or Decorator instance containing its metadata.
Bean with scope @Dependent, qualifier @Default and type Interceptor can be injected into any interceptor instance.
Coverage
Bean with scope @Dependent, qualifier @Default and type Decorator which can be injected into any decorator instance.
Coverage
Additionally, the container must provide beans allowing interceptors and decorators to obtain information about the beans they intercept and decorate.
Bean with scope @Dependent, qualifier @@Decorated and type Bean can be injected into any decorator instance.
Coverage
Bean with scope @Dependent, qualifier @Intercepted and type Bean which can be injected into any interceptor instance.
Coverage
These beans are passivation capable dependencies, as defined in Section 6.6.2, "Passivation capable dependencies".
If an Interceptor instance is injected into a bean instance other than an interceptor instance, the container automatically detects the problem and treats it as a definition error.
Coverage
If a Decorator instance is injected into a bean instance other than a decorator instance, the container automatically detects the problem and treats it as a definition error.
Coverage
The injection of bean metadata is restricted.
If the injection point is a field, an initializer method parameter or a bean constructor, with qualifier @Default and type parameter of the injected Bean is not the same as the type declaring the injection point, the container automatically detects the problem and treats it as a definition error.
If the injection point is a field, an initializer method parameter or a bean constructor, with qualifier @Default and type parameter of the injected Interceptor is not the same as the type declaring the injection point, the container automatically detects the problem and treats it as a definition error.
If the injection point is a field, an initializer method parameter or a bean constructor, with qualifier @Default and type parameter of the injected Decorator is not the same as the type declaring the injection point, the container automatically detects the problem and treats it as a definition error.
If the injection point is a field, an initializer method parameter or a bean constructor of an interceptor, with qualifier @Intercepted and the type parameter of the injected Bean is not an unbounded wildcard, the container automatically detects the problem and treats it as a definition error.
If he injection point is a field, an initializer method parameter or a bean constructor of a decorator, with qualifier @Decorated and the type parameter of the injected Bean is not the same as the delegate type, the container automatically detects the problem and treats it as a definition error.
If the injection point is a producer method parameter and the type parameter of the injected Bean is not the same as the producer method return type, the container automatically detects the problem and treats it as a definition error.
Coverage
If the injection point is a disposer method parameter and the type parameter of the injected Bean is not the same as the disposed parameter, the container automatically detects the problem and treats it as a definition error.
Coverage
If a Bean instance is injected into a disposer method, it represents the producer method to which the disposer method is bound.
Coverage
An instance of the javax.enterprise.inject.Instance interface may be injected.
Coverage
The method javax.enterprise.inject.Instance.get() returns a contextual reference.
Any combination of qualifiers may be specified at the injection point.
The @Any qualifier may be used to allow the application to specify qualifiers dynamically.
The @New qualifier may be used, allowing the application to obtain a @New qualified bean, as defined in Section 3.12, "@New qualified beans".
The Instance interface provides a method for obtaining instances of beans with a specified combination of required type and qualifiers, and inherits the ability to iterate beans with that combination of required type and qualifiers from java.lang.Iterable.
For an injected Instance, the required type is the type parameter specified at the injection point, and the required qualifiers are the qualifiers specified at the injection point.
The select() method returns a child Instance for a given required type and additional required qualifiers. If no required type is given, the required type is the same as the parent.
If an injection point of raw type Instance is defined, the container automatically detects the problem and treats it as a definition error.
Coverage
If two instances of the same qualifier type are passed to select(), an IllegalArgumentException is thrown.
Coverage
If an instance of an annotation that is not a qualifier type is passed to select(), an IllegalArgumentException is thrown.
The get() method must identify a bean that has the required type and required qualifiers and is eligible for injection into the class into which the parent Instance was injected, according to the rules of typesafe resolution, as defined in Section 5.2, "Typesafe resolution", resolving ambiguities according to Section 5.2.1, "Unsatisfied and ambiguous dependencies".
If typesafe resolution results in an unsatisfied dependency, throw an UnsatisfiedResolutionException.
Coverage
If typesafe resolution results in an unresolvable ambiguous dependency, throw an AmbiguousResolutionException.
Coverage
Otherwise, obtain a contextual reference for the bean and the required type, as defined in Section 6.5.3, "Contextual reference for a bean".
The iterator() method must identify the set of beans that have the required type and required qualifiers and are eligible for injection into the class into which the parent Instance was injected, according to the rules of typesafe resolution, as defined in Section 5.2, "Typesafe resolution".
The iterator() method must return an Iterator, that iterates over the set of contextual references for the resulting beans and required type, as defined in Section 6.5.3, "Contextual reference for a bean".
The method isUnsatisfied() returns true if there is no bean that has the required type and qualifiers and is eligible for injection into the class into which the parent Instance was injected, or false otherwise.
The method isAmbiguous() returns true if there is more than one bean that has the required type and qualifiers and is eligible for injection into the class into which the parent Instance was injected, or false otherwise.
The method destroy() instructs the container to destroy the instance. The bean instance passed to destroy() should be a dependent scoped bean instance, or a client proxy for a normal scoped bean. Applications are encouraged to always call destroy() when they no longer require an instance obtained from Instance.
Test client proxy passed to destroy().
Coverage
Test UnsupportedOperationException is thrown when if the active context object for the scope type of the bean does not support destroying bean instances.
Coverage
No tests exist for this assertion
The container must provide a built-in bean with Instance<X> and Provider<X> for every legal bean type x in its set of bean types.
The container must provide a built-in bean with every qualifier type in its set of qualifier types.
The container must provide a built-in bean with scope @Dependent.
Coverage
The container must provide a built-in bean with no bean EL name.
Coverage
The container must provide a built-in bean with an implementation provided automatically by the container.
Coverage
The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
Coverage
Test javax.enterprise.util.AnnotationLiteral when using Instance.select() to specify qualifiers.
Test javax.enterprise.util.TypeLiteral when specifying a parameterized type with actual type parameters when calling Instance.select().
If an exception occurs while creating an instance, the exception is rethrown by the create() method. If the exception is a checked exception, it must be wrapped and rethrown as an (unchecked) CreationException.
Coverage
If an exception occurs while destroying an instance, the exception must be caught by the destroy() method.
Coverage
If the application invokes a contextual instance after it has been destroyed, the behavior is undefined.
The container and portable extensions may define implementations of the Contextual interface that do not extend Bean, but it is not recommended that applications directly implement Contextual.
The interface javax.enterprise.context.spi.CreationalContext provides operations that are used by the Contextual implementation during instance creation and destruction.
push() registers an incompletely initialized contextual instance with the container. A contextual instance is considered incompletely initialized until it is returned by the create() method.
Coverage
release() destroys all dependent objects, as defined in Section 6.4.1, "Dependent objects", of the instance which is being destroyed, by passing each dependent object to the destroy() method of its Contextual object.
Coverage
The implementation of Contextual is not required to call push(). However, for certain bean scopes, invocation of push() between instantiation and injection helps the container minimize the use of client proxy objects (which would otherwise be required to allow circular dependencies).
If Contextual.create() calls push(), it must also return the instance passed to push().
Coverage
Contextual.create() should use the given CreationalContext when obtaining contextual references to inject, as defined in Section 6.5.3, "Contextual reference for a bean", in order to ensure that any dependent objects are associated with the contextual instance that is being created.
Contextual.destroy() should call release() to allow the container to destroy dependent objects of the contextual instance.
The javax.enterprise.context.spi.Context interface provides an operation for obtaining contextual instances with a particular scope of any contextual type.
The method getScope() returns the scope type of the context object.
Coverage
When a context object is active the isActive() method returns true. Otherwise, we say that the context object is inactive and the isActive() method returns false.
The Context.get() method may either return an existing instance of the given contextual type, or if no CreationalContext is given, return a null value, or if a CreationalContext is given, create a new instance of the given contextual type by calling Contextual.create() and return the new instance.
The Context.get() method may either return an existing instance of the given contextual type, or if no CreationalContext is given, return a null value, or if a CreationalContext is given, create a new instance of the given contextual type by calling Contextual.create() and return the new instance.
Coverage
The Context.get() method may either return an existing instance of the given contextual type, or if no CreationalContext is given, return a null value, or if a CreationalContext is given, create a new instance of the given contextual type by calling Contextual.create() and return the new instance.
Coverage
If the context object is inactive, the get() method must throw a ContextNotActiveException.
Coverage
The get() method may not return a null value unless no CreationalContext is given, or Contextual.create() returns a null value.
Coverage
The get() method may not return a null value unless no CreationalContext is given, or Contextual.create() returns a null value.
Coverage
The get() method may not create a new instance of the given contextual type unless a CreationalContext is given.
Coverage
When the container calls get() for a context that is associated with a passivating scope it must ensure that the given instance of Contextual and the instance of CreationalContext, if given, are serializable.
The destroy() method destroys an existing contextual instance, removing it from the context instance.
The context object 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.
Coverage
A destroyed instance must not subsequently be returned by the get() method.
Coverage
The context object must pass the same instance of CreationalContext to Contextual.destroy() that it passed to Contextual.create() when it created the instance.
There may be no more than one mapped instance of a context object per contextual type per thread
A context may be associated with one or more threads
The get() operation of the Context object for an active normal scope returns the current instance of the given contextual type.
When a context is destroyed, all mapped instances belonging to that context are destroyed by passing them to the Contextual.destroy() method.
Coverage
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
All normal scopes must be explicitly declared @NormalScope, to indicate to the container that a client proxy is required.
All pseudo-scopes must be explicitly declared @Scope, to indicate to the container that no client proxy is required.
All scopes defined by this specification, except for the @Dependent pseudo-scope, are normal scopes
When a bean is declared to have @Dependent scope, no injected instance of the bean is ever shared between multiple injection points.
Coverage
When a bean is declared to have @Dependent scope, any instance of the bean injected into an object that is being created by the container is bound to the lifecycle of the newly created object.
When a bean is declared to have @Dependent scope, when a unified EL expression in a JSF or JSP page that refers to the bean by its EL name is evaluated, at most one instance of the bean is instantiated. This instance exists to service just a single evaluation of the EL expression. It is reused if the bean EL name appears multiple times in the EL expression, but is never reused when the EL expression is evaluated again, or when another EL expression is evaluated.
Coverage
When a bean is declared to have @Dependent scope, any instance of the bean that receives a producer method, producer field, disposer method or observer method invocation exists to service that invocation only
Test with a producer method.
Coverage
Test with a producer field.
Coverage
Test with a disposer method.
Coverage
Test with an observer method.
Coverage
When a bean id declared to have @Dependent scope, any instance of the bean injected into method parameters of a disposer method or observer method exists to service the method invocation only (except for observer methods of container lifecycle events).
Every invocation of the get() operation of the Context object for the @Dependent scope with a CreationalContext returns a new instance of the given bean.
Coverage
Every invocation of the get() operation of the Context object for the @Dependent scope with no CreationalContext returns a null value.
Coverage
The @Dependent scope is always active.
Coverage
Instances of interceptors or decorators with scope @Dependent are dependent objects of the bean instance they decorate.
Test with a @Dependent-scoped interceptor.
Coverage
Test with a @Dependent-scoped decorator.
Coverage
An instance of a bean with scope @Dependent injected into a field, bean constructor or initializer method is a dependent object of the bean or Java EE component class instance into which it was injected.
Test with @Dependent-scoped bean injected into bean constructor.
Coverage
Test with @Dependent-scoped bean injected into initializer method.
Coverage
An instance of a bean with scope @Dependent injected into a producer method is a dependent object of the producer method bean instance that is being produced.
Coverage
An instance of a bean with scope @Dependent obtained by direct invocation of an Instance is a dependent object of the instance of Instance.
Coverage
The container must ensure that all dependent objects of a non-contextual instance of a bean or other Java EE component class are destroyed when the instance is destroyed by the container.
The container must ensure that all @Dependent scoped contextual instances injected into method parameters of a disposer method or observer method of any other event are destroyed when the invocation completes.
Check disposer method
Coverage
The container must ensure that any @Dependent scoped contextual instance created to receive a producer method, producer field, disposer method or observer method invocation is destroyed when the invocation completes.
Check producer method
Coverage
Check producer field
Coverage
Check disposer method
Coverage
Check observer method
Coverage
The container must ensure that all @Dependent scoped contextual instances created during evaluation of a Unified EL expression in a JSP or JSF page are destroyed when the evaluation completes.
Coverage
The container is permitted to destroy any @Dependent scoped contextual instance at any time if the instance is no longer referenced by the application (excluding weak, soft and phantom references).
Suppose a Unified EL expression in a JSF or JSP page refers to a bean with scope @Dependent by its EL name. Each time the EL expression is evaluated the bean is instantiated at most once, and the resulting instance is reused for every appearance of the EL name, and the resulting instance is destroyed when the evaluation completes.
Portable extensions that integrate with the container via Unified EL should also ensure that these rules are enforced.
From time to time, the container must obtain an active context object for a certain scope type. The container must search for an active instance of Context associated with the scope type. If no active context object exists for the scope type, the container throws a ContextNotActiveException.
Coverage
If more than one active context object exists for the given scope type, the container must throw an IllegalStateException.
Coverage
From time to time, the container must obtain a contextual instance of a bean. The container must obtain the active context object for 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
From time to time, the container attempts to obtain a contextual instance of a bean that already exists, without creating a new contextual instance. The container must determine if the scope of the bean is active and if it is, obtain the active context object for the bean scope, then attempt to obtain an instance of the bean by calling Context.get(), passing the Bean instance representing the bean without passing any instance of CreationalContext.
Coverage
If the scope is not active, or if Context.get() returns a null value, there is no contextual instance that already exists.
For a custom implementation of the Bean interface defined in Section 11.1, "The Bean interface", the container calls getScope() to determine the bean scope.
Coverage
Contextual references must be obtained with a given CreationalContext, allowing any instance of scope @Dependent that is created to be later destroyed.
Coverage
If the bean has a normal scope and the given bean type cannot be proxied by the container, as defined in Section 5.4.1, "Unproxyable bean types", the container throws an UnproxyableResolutionException.
Coverage
If the bean has a normal scope, then the contextual reference for the bean is a client proxy, as defined in Section 5.4, "Client proxies", created by the container, that implements the given bean type and all bean types of the bean which are Java interfaces.
Coverage
If the bean has a pseudo-scope, the container must obtain a contextual instance of the bean. If the bean has scope @Dependent, the container must associate it with the CreationalContext.
Coverage
The container must ensure that every injection point of type InjectionPoint and qualifier @Default of any dependent object instantiated during this process receives an instance of InjectionPoint representing the injection point into which the dependent object will be injected, or a null value if it is not being injected into any injection point.
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.
From time to time, the container must obtain an injectable reference for an injection point. The container must identify a bean according to the rules defined in Section 5.2, "Typesafe resolution" and resolving ambiguities according to Section 5.2.1, "Unsatisfied and ambiguous dependencies", then obtain a contextual reference for this bean and the type of the injection point according to Section 6.5.3, "Contextual reference for a bean".
Coverage
For certain combinations of scopes, the container is permitted to optimize the procedure for obtaining an injectable reference for an injection point - the container is permitted to directly inject a contextual instance of the bean, as defined in Section 6.5.2, "Contextual instance of a bean", and if an incompletely initialized instance of the bean is registered with the current CreationalContext, as defined in Section 6.1, "The Contextual interface", the container is permitted to directly inject this instance.
Injectable references to a bean must respect the rules of contextual reference validity, with the following exceptions - a reference to a bean injected into a field, bean constructor or initializer method is only valid until the object into which it was injected is destroyed, a reference to a bean injected into a producer method is only valid until the producer method bean instance that is being produced is destroyed, and a reference to a bean injected into a disposer method or observer method is only valid until the invocation of the method completes.
Coverage
No tests exist for this assertion
The application should not invoke a method of an invalid injected reference. If the application invokes a method of an invalid injected reference, the behavior is undefined.
Test that passivation occurs.
Coverage
As defined by the EJB specification, all stateful session beans are passivation capable if and only if all interceptors and decorators of the bean are passivation capable. Stateless and singleton session beans are not passivation capable.
Test passivation capable stateful session bean.
Coverage
A managed bean is passivation capable if and only if the bean class is serializable and all interceptors and decorators of the bean are passivation capable.
Tests with a serializable bean class.
Coverage
Tests with a serializable interceptor.
Coverage
Tests with a serializable decorator.
Coverage
A producer method is passivation capable if and only if it never returns a value which is not passivation capable at runtime.
A producer field is passivation capable if and only if it never refers to a value which is not passivation capable at runtime.
A producer method is passivation capable if and only if it never returns a value which is not passivation capable at runtime.
Test that a producer method with a primitive return type is passivation capable.
A test exists for this untestable assertion!Test that a producer method with a serializable return type is passivation capable.
Coverage
A producer field is passivation capable if and only if it never refers to a value which is not passivation capable at runtime.
Test that a producer field with a primitive type is passivation capable.
Coverage
Test that a producer field with a serializable type is passivation capable.
Coverage
A custom implementation of Bean is passivation capable if it implements the interface PassivationCapable.
Coverage
No tests exist for this assertion
An implementation of Contextual that is not a bean is passivation capable if it implements both PassivationCapable and Serializable.
Coverage
No tests exist for this assertion
The getId() method of the PassivationCapable implementation must return a value that uniquely identifies the instance of Bean or Contextual.
The getId() method of the PassivationCapable implementation must return a value that uniquely identifies the instance of Bean or Contextual. It is recommended that the string contain the package name of the class that implements Bean or Contextual.
The container must guarantee that all session beans are passivation capable dependencies.
Coverage
The container must guarantee that all passivation capable beans with scope @Dependent are passivation capable dependencies.
The container must guarantee that all resources are passivation capable dependencies.
Coverage
No tests exist for this assertion
The container must guarantee that the built-in beans of type Instance, Event, InjectionPoint and BeanManager are passivation capable dependencies.
Coverage
A custom implementation of Bean is a passivation capable dependency if it implements PassivationCapable or if getScope() returns a normal scope type.
Coverage
No tests exist for this assertion
A passivating scope requires that beans with the scope are passivation capable, and implementations of Contextual passed to any context object for the scope are passivation capable.
Test that a bean with the scope is passivation capable.
Coverage
Test that an implementation of Contextual passed to the context object for the scope is passivation capable.
Passivating scopes must be explicitly declared @NormalScope(passivating=true).
If a managed bean or stateful session bean which declares a passivating scope is not passivation capable, then the container automatically detects the problem and treats it as a deployment problem.
Test managed bean.
Coverage
Test stateful session bean.
Coverage
If a managed bean which declares a passivating scope has a non-transient injected field that does not resolve to a passivation capable dependency, then the container automatically detects the problem and treats it as a deployment problem.
Coverage
If a managed bean which declares a passivating scope has an interceptor or decorator with a non-transient injected field that does not resolve to a passivation capable dependency, then the container automatically detects the problem and treats it as a deployment problem.
Test interceptor with injected field.
Coverage
Test decorator with injected field.
Coverage
If a stateful session bean which declares a passivating scope has a non-transient injected field that does not resolve to a passivation capable dependency, then the container automatically detects the problem and treats it as a deployment problem.
Coverage
If a stateful session bean has an interceptor or decorator with a non-transient injected field that does not resolve to a passivation capable dependency, then the container automatically detects the problem and treats it as a deployment problem.
Test an interceptor with an injected field.
Coverage
Test a decorator with an injected field.
Coverage
If a producer method declares a passivating scope and has a return type that is declared final and does not implement or extend Serializable then the container automatically detects the problem and treats it as a deployment problem.
Coverage
If a producer method declares a passivating scope and doesn't only return Serializable types at runtime, then the container must throw an IllegalProductException.
Coverage
If a producer field declares a passivating scope and has a type that is declared final and does not implement or extend Serializable then the container automatically detects the problem and treats it as a deployment problem.
Coverage
If a producer field declares a passivating scope and doesn't only contain Serializable values at runtime then the container must throw anIllegalProductException.
Coverage
If a producer method or field of scope @Dependent returns an unserializable object for injection into an injection point that requires a passivation capable dependency, the container must throw an IllegalProductException
Test for a runtime exception with a producer method.
Coverage
Test for a runtime exception with a producer field.
Coverage
For a custom implementation of Bean, the container calls getInjectionPoints() to determine the injection points, and InjectionPoint.isTransient() to determine whether the injected point is a transient field.
Test calling getInjectionPoints().
Coverage
Test calling InjectionPoint.isTransient().
Coverage
If a bean which declares a passivating scope type has a decorator or interceptor which is not a passivation capable dependency, the container automatically detects the problem and treats it as a deployment problem.
Test a bean with decorator which is not a passivation capable dependency.
Coverage
Test a stateful session bean with decorator which is not a passivation capable dependency.
Coverage
Test a bean with interceptor which is not a passivation capable dependency.
Coverage
Test a stateful session bean with interceptor which is not a passivation capable dependency.
Coverage
Managed bean which declares a passivating scope may have bean constructor parameter or initializer method parameter that does not resolve to a passivation capable dependency.
Coverage
Stateful session bean which declares a passivating scope may have bean constructor parameter or initializer method parameter that does not resolve to a passivation capable dependency.
Coverage
Stateful session bean which does not declare a passivating scope needn't be passivation capable.
Coverage
Passivation capable interceptor with non-passivation capable dependencies is allowed unless it intercepts a bean declaring passivation scope.
Coverage
Passivation capable decorator with non-passivation capable dependencies is allowed unless it decorates a bean declaring passivation scope.
Coverage
The built-in request and application context objects are active during servlet, web service and EJB invocations, and the built in session and request context objects are active during servlet and web service invocations. For other kinds of invocations, a portable extension may define a custom context object for any or all of the built-in scopes.
The request scope is active during the service() method of any servlet in the web application, during the doFilter() method of any servlet filter and when the container calls any ServletRequestListener or AsyncListener.
Check service() method.
Coverage
Check doFilter() method.
Coverage
Check AsyncListener.
Coverage
The request scope is active during any Java EE web service invocation.
The request scope is active during any remote method invocation of any EJB, during any asynchronous method invocation of any EJB, during any call to an EJB timeout method and during message delivery to any EJB message-driven bean.
Test the request scope is active during a remote method invocation of any EJB.
Coverage
Test the request scope is active during any asynchronous method invocation of any EJB.
Coverage
Test the request scope is active during any call to an EJB timeout method.
Coverage
Test the request scope is active during message delivery to any EJB message-driven bean.
Coverage
The request context is destroyed at the end of the servlet request, after the service() method and all doFilter() methods, and all requestDestroyed() and onComplete() notifications return.
Check service() method.
Coverage
Check doFilter() methods.
Coverage
Check requestDestroyed() notification.
Coverage
Check onComplete() notification.
Coverage
The request context is destroyed after the web service invocation completes.
The request context is destroyed after the EJB remote method invocation, asynchronous method invocation, timeout or message delivery completes.
Test the request context is destroyed after an EJB remote method invocation.
Coverage
Test the request context is destroyed after an EJB asynchronous method invocation.
Coverage
Test the request context is destroyed after the EJB timeout.
Coverage
Test the request context is destroyed after the message delivery completes.
Coverage
The request context is destroyed after the after the @PostConstruct callback completes, if it did not already exist when the @PostConstruct callback occurred.
An event with qualifier @Initialized(RequestScoped.class) is fired when the request context is initialized and an event with qualifier @Destroyed(RequestScoped.class) when the request context is destroyed.
The event payload is the ServletRequestEvent if the context is initialized or destroyed due to a servlet request.
The event payload is the ServletRequestEvent if the context is initialized or destroyed due to a web service invocation.
Coverage
The event payload is the java.lang.Object if the context is initialized or destroyed due to a EJB remote method invocation.
Coverage
The event payload is the java.lang.Object if the context is initialized or destroyed due to a EJB asynchronous method invocation.
Coverage
The event payload is the java.lang.Object if the context is initialized or destroyed due to a EJB timeout method invocation.
Coverage
The event payload is the java.lang.Object if the context is initialized or destroyed due to a message delivery to any EJB message-driven bean.
Coverage
The session scope is active during the service() method of any servlet in the web application , during the doFilter() method of any servlet filter and when the container calls any HttpSessionListener, AsyncListener or ServletRequestListener.
Coverage
The session scope is active during the service() method of any servlet in the web application, during the doFilter() method of any servlet filter and when the container calls any HttpSessionListener, AsyncListener or ServletRequestListener.
Coverage
The session context is shared between all servlet requests that occur in the same HTTP servlet session.
Coverage
The session context is destroyed when the HTTPSession times out, after all HttpSessionListeners have been called, and at the very end of any request in which invalidate() was called, after all filters and ServletRequestListeners have been called.
Coverage
The session context is destroyed when the HTTPSession times out, after all HttpSessionListeners have been called, and at the very end of any request in which invalidate() was called, after all filters and ServletRequestListeners have been called.
Coverage
The session context is destroyed when the HTTPSession times out, after all HttpSessionListeners have been called, and at the very end of any request in which invalidate() was called, after all filters and ServletRequestListeners have been called.
An event with the HttpSessionEvent as payload and with qualifier @Initialized(SessionScoped.class) is fired when the session context is initialized.
An event with the HttpSessionEvent as payload and with qualifier @Destroyed(SessionScoped.class) is fired when the session context is destroyed.
The application scope is active during the service() method of any servlet in the web application, during the doFilter() method of any servlet filter and when the container calls any ServletContextListener, HttpSessionListener, AsyncListener or ServletRequestListener.
Check service method
Coverage
Check filter.
Coverage
Check ServletContextListener.
Coverage
Check HttpSessionListener
Coverage
Check AsyncListener
Coverage
Check ServletRequestListener
Coverage
The application scope is active during any Java EE web service invocation.
Coverage
The application scope is also active during any remote method invocation of any EJB, during any asynchronous method invocation of any EJB, during any call to an EJB timeout method and during message delivery to any EJB message-driven bean.
Test remote method invocation
Coverage
Test asynchronous method invocation
Coverage
Test EJB timeout method
Coverage
Test message delivery to any EJB message-driven bean.
Coverage
The application scope is active when the disposer method or @PreDestroy callback of any bean with any normal scope other than @ApplicationScoped is called.
Test disposer method
Coverage
Test @PreDestroy method
Coverage
The application scope is active during @PostConstruct callback of any bean.
The application context is shared between all servlet requests, asynchronous observer method notifications, web service invocations, EJB remote method invocations, EJB asynchronous method invocations, EJB timeouts and message deliveries to message driven beans that execute within the same application.
Coverage
The application context is destroyed when the application is shut down.
Coverage
An event with qualifier @Initialized(ApplicationScoped.class) is fired when the application context is initialized and an event with qualifier @Destroyed(ApplicationScoped.class) is fired when the application is destroyed.
The event payload is the ServletContextEvent if the application is a web application deployed to a Servlet container.
Coverage
the ??? in ???
The conversation scope is active during all Servlet requests.
Test JSF request.
Coverage
An event with qualifier @Initialized(ConversationContext.class) is fired when the conversation context is initialized and an event with qualifier @Destroyed(ConversationScoped.class) is fired when the conversation is destroyed. The event payload is the conversation id if the conversation context is destroyed and is not associated with a current Servlet request, the ServletRequestEvent if the application is a web application deployed to a Servlet container, any java.lang.Object for other types of application.
An event with the ServletRequestEvent as the payload and with qualifier @Initialized(ConversationContext.class) is fired when the conversation context is initialized.
An event with the ServletRequestEvent as the payload and with qualifier @Destroyed(ConversationContext.class) is fired when the conversation context is destroyed.
An event with the conversation id as the payload and with qualifier @Destroyed(ConversationContext.class) is fired when the conversation context is destroyed and is not associated with a current Servlet request.
Coverage
Any Servlet request has exactly one associated conversation.
The conversation associated with a Servlet request is determined at the beginning of the request before calling any service() method of any servlet in the web application, calling the doFilter() method of any servlet filter in the web application and before the container calls any ServletRequestListener or AsyncListener in the web application.
Test service() method of a servlet.
Coverage
Test doFilter() method of a servlet filter.
Coverage
Test ServletRequestListener.
Coverage
Test AsyncListener.
Coverage
By default, a conversation is transient.
Coverage
A transient conversation may be marked long-running by calling Conversation.begin()
Coverage
A long-running conversation may be marked transient by calling Conversation.end()
Coverage
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
Coverage
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
If the conversation associated with the current Servlet request is in the transient state at the end of a Servlet request, it is destroyed, and the conversation context is also destroyed.
Coverage
If the conversation associated with the current Servlet request is in the long-running state at the end of a Servlet request, it is not destroyed.
Coverage
The long-running conversation associated with a request may be propagated to any Servlet request via use of a request parameter named cid containing the unique identifier of the conversation. In this case, the application must manage this request parameter.
Coverage
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 request parameter named cid containing the unique identifier of the conversation.
Coverage
When no conversation is propagated to a Servlet request, or if a request parameter named conversationPropagation has the value none the request is associated with a new transient conversation.
The request is associated with a new transient conversation.
Coverage
Test request parameter named conversationPropagation.
Coverage
All long-running conversations are scoped to a particular HTTP servlet session and may not cross session boundaries.
When the HTTP servlet session is invalidated, all long-running conversation contexts created during the current session are destroyed, after the servlet service() method completes.
The container is permitted to arbitrarily destroy any long-running conversation that is associated with no current JSF request, in order to conserve resources
The conversation timeout, which may be specified by calling Conversation.setTimeout() is a hint to the container that a conversation should not be destroyed if it has been active within the last given interval in milliseconds.
If the propagated conversation cannot be restored, the container must associate the request with a new transient conversation and throw an exception of type javax.enterprise.context.NonexistentConversationException.
Coverage
The container ensures that a long-running conversation may be associated with at most one request at a time, by blocking or rejecting concurrent requests. If the container rejects a request, it must associate the request with a new transient conversation and throw an exception of type javax.enterprise.context.BusyConversationException.
Coverage
No tests exist for this assertion
The container provides a built-in bean with bean type Conversation, scope @RequestScoped, and qualifier @Default, named javax.enterprise.context.conversation.
Test the bean type is correct.
Coverage
Test the scope is correct.
Coverage
Test the qualifier is correct.
Coverage
Test the bean name is correct.
Coverage
begin() marks the current transient conversation long-running. A conversation identifier may, optionally, be specified. If no conversation identifier is specified, an identifier is generated by the container.
end() marks the current long-running conversation transient.
Coverage
getId() returns the identifier of the current long-running conversation, or a null value if the current conversation is transient.
Coverage
setTimeout() sets the timeout of the current conversation.
Coverage
isTransient() returns true if the conversation is marked transient, or false if it is marked long-running.
Coverage
If any method of Conversation is called when the conversation scope is not active, a ContextNotActiveException is thrown.
Coverage
If end() is called, and the current conversation is marked transient, an IllegalStateException is thrown.
Coverage
If begin() is called, and the current conversation is already marked long-running, an IllegalStateException is thrown.
Coverage
If begin() is called with an explicit conversation identifier, and a long-running conversation with that identifier already exists, an IllegalArgumentException is thrown.
Coverage
When the application invokes a method of a bean via a contextual reference to the bean, as defined in Section 6.5.3, "Contextual reference for a bean", or a business method of a session bean via an EJB remote or local reference, the invocation is treated as a business method invocation.
Invocations of initializer methods by the container are not business method invocations.
Coverage
Invocations of producer, disposer and observer methods by the container are business method invocations are are intercepted by method interceptors and decorators.
Verify producer methods are intercepted
Coverage
Verify producer methods are decorated
Coverage
Verify disposer methods are intercepted
Coverage
Verify disposer methods are decorated
Coverage
Verify observer methods are intercepted
Coverage
Verify observer methods are decorated
Coverage
Invocation of EJB timer service timeouts by the container are not business method invocations, but are intercepted by interceptors for EJB timeouts.
Coverage
Invocation of lifecycle callbacks by the container are not business method invocations, but are intercepted by interceptors for lifecycle callbacks.
Coverage
Invocations of interceptors and decorator methods during method or lifecycle callback interception are not business method invocations, and therefore no recursive interception occurs.
Verify decorators callbacks are not intercepted
Coverage
Invocations of message listener methods of message-driven beans during message delivery are business method invocations.
Verify message listener methods are intercepted
Coverage
Invocations of methods declared by java.lang.Object are not business method invocations.
Coverage
If, and only if, the invocation is a business method invocation it passes through method interceptors and decorators, and in the case of a session bean, it is subject to EJB services such a declarative transaction management, concurrency, security and asynchronicity, as defined by the EJB specification.
Verify that a managed bean's business methods are intercepted
Coverage
Verify that a managed bean's business methods are decorated
Coverage
Verify that a session bean's business methods are intercepted
Coverage
Verify that a session bean's business methods receive EJB services
Verify that a non-contextual session bean's business methods are intercepted
Coverage
Verify that a non-contextual session bean's business methods are decorated
Coverage
If the invocation is not a business method invocation, it is treated as a normal Java method call and is not intercepted by the container.
Coverage
When the create() method of the Bean object that represents a managed bean is called, the container obtains an instance of the bean, as defined by the Managed Beans specification, calling the bean constructor as defined by Section 5.5.1, "Injection using the bean constructor", and performing dependency injection as defined in Section 5.5.2, "Injection of fields and initializer methods".
Coverage
When the destroy() method is called, the container destroys the instance, as defined by the Managed Beans specification, and any dependent objects, as defined in Section 5.5.3, "Destruction of dependent objects".
When the create() method of a Bean object that represents a stateful session bean that is called, the container creates and returns a container-specific internal local reference to a new session bean instance. The reference must be passivation capable. This reference is not directly exposed to the application.
Before injecting or returning a contextual instance to the application, the container transforms its internal reference into an object that implements the bean types expected by the application and delegates method invocations to the underlying stateful session bean instance. This object must be passivation capable.
Coverage
When the destroy() method is called, and if the underlying EJB was not already removed by direct invocation of a remove method by the application, the container removes the stateful session bean. The @PreDestroy callback must be invoked by the container.
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 container-specific internal local reference to the session bean. This reference is not directly exposed to the application.
Before injecting or returning a contextual instance to the application, the container transforms its internal reference into an object that implements the bean types expected by the application and delegates method invocations to the underlying session bean. This object must be passivation capable.
Coverage
When the destroy() method is called, the container simply discards this internal reference.
Coverage
When the create() method of a Bean object that represents a producer method is called, the container must invoke the producer method as defined by Section 5.5.4, "Invocation of producer or disposer methods". The return value of the producer method, after method interception completes, is the new contextual instance to be returned by Bean.create().
If the producer method returns a null value and the producer method bean has the scope @Dependent, the create() method returns a null value.
Coverage
If the producer method returns a null value, and the scope of the producer method is not @Dependent, the create() method throws an IllegalProductException.
Coverage
When the destroy() method is called, and if there is a disposer method for this producer method, the container must invoke the disposer method as defined by Section 5.5.4, "Invocation of producer or disposer methods", passing the instance given to destroy() to the disposed parameter.
Coverage
Finally, the container destroys dependent objects, as defined in Section 5.5.3, "Destruction of dependent objects".
Coverage
When the create() method of a Bean object that represents a producer field is called, the container must access the producer field as defined by Section 5.5.5, "Access to producer field values" to obtain the current value of the field. The value of the producer field is the new contextual instance to be returned by Bean.create().
Coverage
If the producer field contains a null value and the producer field bean has the scope @Dependent, the create() method returns a null value.
Coverage
If the producer field contains 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 disposer method for this producer field, the container must invoke the disposer method as defined by Section 5.5.4, "Invocation of producer or disposer methods", passing the instance given to destroy() to the disposed parameter.
When the create() method of a Bean object that represents a resource is called, the container creates and returns a container-specific internal reference to the Java EE component environment resource, entity manager, entity manager factory, remote EJB instance or web service reference. This reference is not directly exposed to the application.
Check Entity Manager
Coverage
Check Remote EJB instance
Coverage
Check Web Service Reference
Coverage
No tests exist for this assertion
Before injecting or returning a contextual instance to the application, the container transforms its internal reference into an object that implements the bean types expected by the application and delegates method invocations to the underlying resource, entity manager, entity manager factory, remote EJB instance or web service reference. This object must be passivation capable.
Check delegations to underlying Java EE component environment resource
Check injected Java EE component environment resource is passivation capable
Coverage
Check delegations to underlying Entity Manager
Coverage
Check injected Entity Manager is passivation capable
Coverage
Check delegations to Entity Manager Factory
Coverage
Check injected Entity Manager Factory is passivation capable
Coverage
Check delegations to underlying Remote EJB instance
Coverage
Check injected Remote EJB instance is passivation capable
Coverage
Check delegations to underlying Web Service Reference
Coverage
No tests exist for this assertion
Check injected Web Service Reference is passivation capable
Coverage
No tests exist for this assertion
The container must perform ordinary Java EE component environment injection upon any non-static field that functions as a resource declaration, as defined by the Java EE platform and Common Annotations for the Java platform specifications.
The container is not required to perform Java EE component environment injection upon a static field. Portable applications should not rely upon the value of a static field that functions as a resource declaration.
References to EJBs and web services are always dependent scoped and a new instance must be obtained for every injection performed.
Coverage
No tests exist for this assertion
For an entity manager associated with a resource definition, it must behave as though it were injected directly using @PersistencContext.
Coverage
No tests exist for this assertion
When the destroy() method of a bean which represents a remote stateful EJB reference is called, the container will not automatically destroy the EJB reference.
Coverage
No tests exist for this assertion
Decorators may be associated with any managed bean that is not itself an interceptor or decorator or with any EJB session bean.
Decorators are not applied to the return value of a producer method or the current value of a producer field.
A decorator instance is a dependent object of the object it decorates.
Coverage
A decorator is a managed bean.
The set of decorated types of a decorator includes all bean types of the managed bean which are Java interfaces, except for java.io.Serializable.
Coverage
The decorator bean class and its superclasses are not decorated types of the decorator.
Coverage
The decorator class may be abstract.
Coverage
If the set of decorated types of a decorator is empty, the container automatically detects the problem and treats it as a definition error.
Decorators of a session bean must comply with the bean provider programming restrictions defined by the EJB specification.
Coverage
No tests exist for this assertion
Decorators of a stateful session bean must comply with the rules for instance passivation and conversational state defined by the EJB specification.
Coverage
No tests exist for this assertion
A decorator is declared by annotating the bean class with the @javax.decorator.Decorator stereotype.
Coverage
All decorators have a delegate injection point. A delegate injection point is an injection point of the bean class. The type and qualifiers of the injection point are called the delegate type and delegate qualifiers. The decorator applies to beans that are assignable to the delegate injection point. The delegate injection point must be be declared by annotating the injection point with the annotation @javax.decorator.Delegate.
Coverage
A decorator must have exactly one delegate injection point. If a decorator has more than one delegate injection point, or does not have a delegate injection point, the container automatically detects the problem and treats it as a definition error.
Test with more than one delegate injection point.
Coverage
Test a decorator without a delegate injection point.
Coverage
The delegate injection point must be an injected field, initializer method parameter or bean constructor method parameter. If an injection point that is not an injected field, initializer method parameter or bean constructor method parameter is annotated @Delegate, the container automatically detects the problem and treats it as a definition error.
Check an injected field is ok
Check an initializer method parameter is ok
Coverage
Check a bean constructor method parameter is ok
Coverage
Check that a producer method parameter is not ok
Coverage
If a bean class that is not a decorator has an injection point annotated @Delegate, the container automatically detects the problem and treats it as a definition error.
Coverage
The container must inject a delegate object to the delegate injection point. The delegate object implements the delegate type and delegates method invocations to the remaining uninvoked decorators and eventually to the bean. When the container calls a decorator during business method interception, the decorator may invoke any method of the delegate object.
If a decorator invokes the delegate object at any other time, the invoked method throws an IllegalStateException.
Coverage
The delegate type of a decorator must implement or extend every decorated type (with exactly the same type parameters). If the delegate type does not implement or extend a decorated type of the decorator (or specifies different type parameters), the container automatically detects the problem and treats it as a definition error.
Coverage
If a decorated type is a parameterized type and the delegate type does not have exactly the same type parameters as the decorated type, the container automatically detects the problem and treats it as a definition error.
Coverage
A decorator is not required to implement the delegate type.
Coverage
A decorator may be an abstract Java class, and is not required to implement every method of every decorated type.
Whenever the decorator does not implement a method of the decorated type, the container will provide an implicit implementation that calls the method on the delegate.
Coverage
If a decorator has abstract methods that are not declared by a decorated type, the container automatically detects the problem and treats it as a definition error.
Coverage
The decorator intercepts every method which is declared by a decorated type of the decorator and is implemented by the bean class of the decorator.
Decorators may be enabled for an application, or enabled only for a particular bean archive.
By default, a bean archive has no enabled decorators.
Coverage
A decorator may be enabled for the entire application by listing its class, along with a priority attribute, under the <decorators> element of the beans.xml file of the bean archive which contains the decorator class.
Coverage
A decorator may be enabled for a bean archive by listing its class under the <decorators> element of the beans.xml file of the bean archive.
Coverage
A decorator enabled for an application may be disabled for a bean archive by listing its class, along with an enabled flag, under the <decorators> element of the beans.xml file of the bean archive.
Coverage
A decorator may be given a default priority, but not enabled by listing its class, along with a disabled flag and the priority attribute, under the <decorators> element of the beans.xml file of the bean archive which contains the decorator class.
Coverage
A decorator with a default priority may be enabled for a bean archive by listing its class, along with an enabled flag, under the <decorators> element of the beans.xml file of the bean archive.
Coverage
The priority of the decorator declaration, defined in Section 2.9, "Priority ordering", determines the default decorator ordering for the application. The order of the decorator declarations for a bean archive overrides the default decorator order. If the set of decorators enabled for the application and the set of decorators enabled for a bean archive are disjoint, then the first decorator enabled for the bean archive is given a priority of 1000. Decorators which occur earlier in the list are called first.
Each child <class> element must specify the name of a decorator bean class. If there is no class with the specified name, or if the class with the specified name is not a decorator bean class, the container automatically detects the problem and treats it as a deployment problem.
Test with a nonexistent class name.
Coverage
Test with a non-decorator class.
Coverage
If the same class is listed twice under the <decorators> element, the container automatically detects the problem and treats it as a deployment problem.
Coverage
The process of matching decorators to a certain bean is called decorator resolution. A decorator is bound to a bean if the bean is assignable to the delegate injection point according to the rules defined in Section 5.2, "Typesafe resolution", and the decorator is enabled in the bean archive containing the bean.
Coverage
If a decorator matches a managed bean, and the managed bean class is declared final, the container automatically detects the problem and treats it as a deployment problem.
If a decorator matches a managed bean with a non-static, non-private, final method, and the decorator also implements that method, the container automatically detects the problem and treats it as a deployment problem.
Coverage
For a custom implementation of the Decorator interface defined in Section 11.1.1, "The Decorator interface", the container calls getDelegateType(), getDelegateQualifiers() and getDecoratedTypes() to determine the delegate type and qualifiers and decorated types of the decorator.
Coverage
A raw bean type is considered assignable to a parameterized delegate type if the raw types are identical and all type parameters of the delegate type are either unbounded type variables or java.lang.Object.
Check all type parameters are unbounded type variables
Coverage
Check all type parameters are Object
Check mix
Coverage
A parameterized bean type is considered assignable to a parameterized delegate type if they have identical raw type and for each parameter: the delegate type parameter and the bean type parameter are actual types with identical raw type, and, if the type is parameterized, the bean type parameter is assignable to the delegate type parameter according to these rules, or the delegate type parameter is a wildcard, the bean type parameter is an actual type and the actual type is assignable to the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard, or the delegate type parameter is a wildcard, the bean type parameter is a type variable and the upper bound of the type variable is assignable to the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard, or the delegate type parameter and the bean type parameter are both type variables and the upper bound of the bean type parameter is assignable to the upper bound, if any, of the delegate type parameter, or the delegate type parameter is a type variable, the bean type parameter is an actual type, and the actual type is assignable to the upper bound, if any, of the type variable.
Check both have identical type parameters
Coverage
Check nested identical type parameters
Coverage
Check delegate type parameter is a wildcard, the bean type parameter is an actual type and the actual type is assignable to the upper bound of the wildcard and assignable from the lower bound of the wildcard
Coverage
Check delegate type parameter is a wildcard, the bean type parameter is a type variable and the upper bound of the type variable is assignable to the upper bound of the wildcard and assignable from the lower bound of the wildcard
Coverage
Check the delegate type parameter and the bean type parameter are both type variables and the upper bound of the bean type parameter is assignable to the upper bound of the delegate type parameter
Coverage
Check the delegate type parameter is a type variable, the bean type parameter is an actual type, and the actual type is as- signable to the upper bound of the type variable
Coverage
Whenever a business method is invoked on an instance of a bean with decorators, the container intercepts the business method invocation and, after processing all interceptors of the method, invokes decorators of the bean. The container searches for the first decorator of the instance that implements the method that is being invoked as a business method. If such decorator exists, the container calls the method of the decorator.
Test decorator of managed bean is called.
Coverage
Test decorator of session bean is called .
Coverage
Test injected Event
Coverage
Test injected UserTransaction
Coverage
If no such decorator exists, the container invokes the business method of the intercepted instance.
Coverage
When any decorator is invoked by the container, it may in turn invoke a method of the delegate. The container intercepts the delegate invocation and searches for the first decorator of the instance such that the decorator occurs after the decorator invoking the delegate, and the decorator implements the method that is being invoked upon the delegate.
Coverage
If no such decorator exists, the container invokes the business method of the intercepted instance.
Coverage
Otherwise, the container calls the method of the decorator.
Coverage
An interceptor binding type is a Java annotation defined as @Target({TYPE, METHOD}) or @Target(TYPE) and @Retention(RUNTIME).
Coverage
An interceptor binding type may be declared by specifying the @javax.interceptor.InterceptorBinding meta-annotation.
Coverage
Multiple interceptors may be bound to the same interceptor binding type or types.
Coverage
An interceptor binding type may declare other interceptor bindings.
Coverage
Interceptor bindings are transitive - an interceptor binding declared by an interceptor binding type is inherited by all beans and other interceptor binding types that declare that interceptor binding type.
Coverage
Interceptor binding types declared @Target(TYPE) may not be applied to interceptor binding types declared @Target({TYPE, METHOD}).
Interceptor bindings may be applied to a stereotype by annotating the stereotype annotation
Coverage
An interceptor binding declared by a stereotype are inherited by any bean that declares that stereotype.
Coverage
If a stereotype declares interceptor bindings, it must be defined as @Target(TYPE).
The interceptor bindings of an interceptor are specified by annotating the interceptor class with the binding types and the @javax.interceptor.Interceptor annotation.
Coverage
An interceptor class may declare multiple interceptor bindings.
Coverage
If an interceptor does not declare an @Interceptor annotation, it must be bound to beans using @Interceptors or ejb-jar.xml.
Coverage
All interceptors declared using @Interceptor must specify at least one interceptor binding. If an interceptor declared using @Interceptor does not declare any interceptor binding, non-portable behavior results.
An interceptor for lifecycle callbacks may only declare interceptor binding types that are defined as @Target(TYPE). If an interceptor for lifecycle callbacks declares an interceptor binding type that is defined @Target({TYPE, METHOD}), the container automatically detects the problem and treats it as a definition error.
Coverage
An interceptor binding may be declared by annotating the bean class, or a method of the bean class, with the interceptor binding type.
Coverage
A bean class or method of a bean class may declare multiple interceptor bindings.
A bean class may declare multiple interceptor bindings.
Coverage
A method of a bean class may declare multiple interceptor bindings.
Coverage
If the bean class of a managed bean declares or inherits a class level interceptor binding or a stereotype with interceptor bindings, it must not be declared final, or have any non-static, non-private, final methods. If a managed bean has a class-level interceptor binding and is declared final or has a non-static, non-private, final method, the container automatically detects the problem and treats it as a definition error.
If the bean class of a managed bean declares a class level interceptor binding, it must not be declared final.
Coverage
If the bean class of a managed bean declares a class level interceptor binding, it must not have any non-static, non-private, final methods.
Coverage
If the bean class of a managed bean inherits a class level interceptor binding, it must not be declared final.
Coverage
If the bean class of a managed bean inherits a class level interceptor binding, it must not have any non-static, non-private, final methods.
Coverage
If the bean class of a managed bean inherits a stereotype with interceptor bindings, it must not be declared final.
Coverage
If the bean class of a managed bean inherits a stereotype with interceptor bindings, it must not have any non-static, non-private, final methods.
Coverage
If a non-static, non-private method of a bean class of a managed bean declares a method level interceptor binding, neither the method nor the bean class may be declared final. If a non-static, non-private, final method of a managed bean has a method level interceptor binding, the container automatically detects the problem and treats it as a definition error.
If a non-static, non-private method of a bean class of a managed bean declares a method level interceptor binding, the bean class may not be declared final.
Coverage
If a non-static, non-private method of a bean class of a managed bean declares a method level interceptor binding, the method may not be declared final.
Coverage
Interceptors may be enabled for an application, or enabled only for a particular bean archive.
By default, a bean archive has no enabled interceptors.
Coverage
An interceptor may be enabled for the entire application by listing its class, along with a priority attribute, under the <interceptors> element of the beans.xml file of the bean archive which contains the interceptor class.
An interceptor may be enabled for a bean archive by listing its class under the <interceptors> element of the beans.xml file of the bean archive.
An interceptor enabled for an application may be disabled for a bean archive by listing its class, along with a disabled flag, under the <interceptors> element of the beans.xml file of the bean archive.
Coverage
An interceptor may be given a default priority, but not enabled by listing its class, along with a disabled flag and the priority attribute, under the <interceptors> element of the beans.xml file of the bean archive which contains the interceptor class.
An interceptor with a default priority may be enabled for a bean archive by listing its class, along with an enabled flag, under the <interceptors> element of the beans.xml file of the bean archive.
Coverage
The priority of the interceptor declaration, defined in Section 2.9, "Priority ordering", determines the default interceptor ordering for the application. The order of the interceptor declarations for a bean archive overrides the default interceptor order. If the set of interceptors enabled for the application and the set of interceptors enabled for a bean archive are disjoint, then the interceptors enabled for the bean archive are given an incrementing priority starting at 1000. Interceptors which occur earlier in the list are called first.
Coverage
Each child <class> element must specify the name of an interceptor class. If there is no class with the specified name, or if the class with the specified name is not an interceptor class, the container automatically detects the problem and treats it as a deployment problem.
Test with a non-existant class.
Coverage
Test with a class that isn't an interceptor.
Coverage
If the same class is listed twice under the <interceptors> element, the container automatically detects the problem and treats it as a deployment problem.
Coverage
Interceptors declared using interceptor bindings are called after interceptors declared using @Interceptors or in ejb-jar.xml and before any around-invoke or lifecycle event callback methods declared on the target class or any superclass of the target class.
Test with session bean
Coverage
Interceptors are called before decorators.
For a lifecycle callback method, the interceptor bindings include the interceptor bindings declared or inherited by the bean at the class level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings and stereotypes.
Coverage
For a business method, or EJB timeout method, the bean interceptor bindings include the interceptor bindings declared or inherited by the bean at the class level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings and stereotypes, together with all interceptor bindings declared at the method level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings.
Check a business method
Coverage
Check an EJB timeout method
Coverage
An interceptor is bound to a method if the method has all the interceptor bindings of the interceptor. A method has an interceptor binding of an interceptor if it has an interceptor binding with (a) the same type and (b) the same annotation member value for each member which is not annotated @javax.enterprise.util.NonBinding, and the interceptor intercepts the given kind of lifecycle callback or business method, and the interceptor is enabled in the bean archive containing the bean.
Coverage
For a custom implementation of the Interceptor interface defined in Section 11.1.2, "The Interceptor interface", the container calls getInterceptorBindings() to determine the interceptor bindings of the interceptor and intercepts() to determine if the interceptor intercepts a given kind of lifecycle callback, EJB timeout or business method.
Check for @PostConstruct
Coverage
Check for @PreDestroy
Coverage
Check for @PostActivate
Coverage
Check for @PrePassivate
Coverage
Check for @AroundInvoke
Coverage
Check for @AroundTimeout
Coverage
An interceptor class may specify multiple interceptor bindings.
Test that the interceptor is applied to a bean with all of the bindings.
Coverage
Test that the interceptor it not applied to a bean with only some of the interceptor bindings.
Coverage
Interceptor binding types may have annotation members.
Coverage
Annotation member values are compared using equals().
Coverage
An annotation member may be excluded from consideration using the @Nonbinding annotation.
Coverage
Array-valued or annotation-valued members of an interceptor binding type should be annotated @Nonbinding in a portable application. If an array-valued or annotation-valued member of an interceptor binding type is not annotated @Nonbinding, non-portable behavior results.
Interceptor bindings defined on methods may override the interceptor bindings defined on classes.
Coverage
If the set of interceptor bindings of a bean or interceptor, including bindings inherited from stereotypes and other interceptor bindings, has two instances of a certain interceptor binding type and the instances have different values of some annotation member, the bean or interceptor must override the inherited set by definining an annotation instance of its own, otherwise, the container automatically detects the problem and treats it as a definition error.
Coverage
An event object is an instance of a concrete Java class with no type variables.
Coverage
The event types of the event include all superclasses and interfaces of the runtime class of the event object.
Coverage
An event type may not contain a type variable.
An event qualifier type is a Java annotation defined as @Target({FIELD, PARAMETER}) or @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME)
Coverage
An event qualifier type is a Java annotation defined as @Target({FIELD, PARAMETER}) or @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME)
Coverage
An event qualifier type is a Java annotation defined as @Target({FIELD, PARAMETER}) or @Target({METHOD, FIELD, PARAMETER, TYPE}) and @Retention(RUNTIME)
All event qualifier types must specify the @javax.inject.Qualifier meta-annotation
Coverage
Every event has the qualifier @javax.enterprise.inject.Any, even if it does not explicitly declare this qualifier.
The process of matching an event to its observer methods is called observer resolution. The container considers event type and qualifiers when resolving observers.
Observer resolution usually occurs at runtime.
An event is delivered to an observer method if the observer method belongs to an enabled bean, the event object is assignable to the observed event type, taking type parameters into consideration, the observer method has no event qualifiers or has a subset of the event qualifiers. An observer method has an event qualifier if it has an observed event qualifier with (a) the same type and (b) the same annotation member value for each member which is not annotated @javax.enterprise.util.Nonbinding. Also the event is not a container lifecycle event, as defined in Section 11.5 "Container lifecycle events", or the observer method belongs to an extension.
Check an event is delivered if the observer method belongs to an enabled bean, the event object is assignable to the observed event type and has a subset of the event qualifiers.
Check an event is not delivered if the observer method belongs to an disabled bean.
Coverage
If the runtime type of the event object contains a type variable, the container must throw an IllegalArgumentException.
Coverage
For a custom implementation of the ObserverMethod interface defined in Section 11.1.3, "The ObserverMethod interface", the container must call getObservedType() and getObservedQualifiers() to determine the observed event type and qualifiers.
An event type is considered assignable to a type variable if the event type is assignable to the upper bound, if any.
Coverage
A parameterized event type is considered assignable to a raw observed event type if the raw types are identical.
A parameterized event type is considered assignable to a parameterized observed event type if they have identical raw type and for each parameter the observed event type parameter is an actual type with identical raw type to the event type parameter, and, if the type is parameterized, the event type parameter is assignable to the observed event type parameter according to these rules, or the observed event type parameter is a wildcard and the event type parameter is assignable to the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard, or the observed event type parameter is a type variable and the event type parameter is assignable to the upper bound, if any, of the type variable.
Check the event type parameter and the observed event type parameter are actual types with identical raw type.
Coverage
Check the event type parameter and the observed event type parameter are actual types with identical raw type for nested type parameters.
Coverage
Check the observed event type parameter is a wildcard and the event type parameter is assignable to the upper bound, if any, of the wildcard and assignable from the lower bound, if any, of the wildcard.
Coverage
Check the observed event type parameter is a type variable and the event type parameter is assignable to the upper bound, if any, of the type variable.
Coverage
The qualifier type for an Event qualifier may have annotation members.
The container uses equals() to compare event qualifier type member values.
An observer method will only be notified if all the observed event qualifiers are specified when the event is fired.
Coverage
Beans fire events via an instance of the javax.enterprise.event.Event interface, which may be injected.
The method fire() accepts an event object.
Coverage
Any combination of qualifiers may be specified at the injection point.
Or, the @Any qualifier may be used, allowing the application to specify qualifiers dynamically.
Coverage
The Event interface provides a method for firing events with a specified combination of type and qualifiers.
Coverage
For an injected Event, the specified type is the type parameter specified at the injection point, and the specified qualifiers are the qualifiers specified at the injection point.
The select() method returns a child Event for a given specified type and additional specified qualifiers. If no specified type is given, the specified type is the same as the parent.
Coverage
If the specified type contains a type variable, an IllegalArgumentException is thrown.
Coverage
If two instances of the same qualifier type are passed to select(), an IllegalArgumentException is thrown.
If an instance of an annotation that is not a qualifier type is passed to select(), an IllegalArgumentException is thrown.
The method fire() fires an event with the specified qualifiers and notifies observers, as defined by Section 10.5, "Observer notification".
Coverage
If the runtime type of the event object contains a type variable, an IllegalArgumentException is thrown.
Coverage
If the runtime type of the event object is assignable to the type of a container lifecycle event, IllegalArgumentException is thrown.
The container must provide a built-in bean with Event<X> in its set of bean types, for every Java type x that does not contain a type variable.
Coverage
The container must provide a built-in bean with every event qualifier type in its set of qualifier types.
Coverage
The container must provide a built-in bean with scope @Dependent.
Coverage
The container must provide a built-in bean with no bean EL name.
Coverage
The container must provide a built-in bean with an implementation provided automatically by the container.
Coverage
If an injection point of raw type Event is defined, the container automatically detects the problem and treats it as a definition error.
Coverage
The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
Coverage
An observer method allows the application to receive and respond to event notifications.
An observer method is a non-abstract method of a managed bean class or session bean class (or of an extension, as defined in Section 11.5, "Container lifecycle events").
Coverage
An observer method may be either static or non-static.
If the bean is a session bean, the observer method must be either a business method of the EJB or a static method of the bean class.
Coverage
There may be arbitrarily many observer methods with the same event parameter type and qualifiers.
Coverage
A bean (or extension) may declare multiple observer methods.
Coverage
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 qualifiers of the event parameter
Coverage
If the event parameter does not explicitly declare any qualifier, the observer method observes events with no qualifier.
Coverage
The event parameter type may contain a type variable or wildcard.
Test with a type variable.
Coverage
Test with a wildcard.
Coverage
An observer method may be declared by annotating a parameter @javax.enterprise.event.Observes of a default-access, public, protected or private method. That parameter is the event parameter. The declared type of the parameter is the observed event type.
Coverage
If a method has more than one parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
Coverage
Observed event qualifiers may be declared by annotating the event parameter.
Coverage
If an observer method is annotated @Produces the container automatically detects the problem and treats it as a definition error.
Coverage
If an observer method is annotated @Inject the container automatically detects the problem and treats it as a definition error.
Coverage
If an observer method has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.
Coverage
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, the container automatically detects the problem and treats it as a definition error.
Coverage
Interceptors and decorators may not declare observer methods. If an interceptor or decorator has a method with a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.
In addition to the event parameter, observer methods may declare additional parameters, which may declare qualifiers. These additional parameters are injection points.
Coverage
A conditional observer method may be declared by specifying receive=IF_EXISTS.
Coverage
Beans with scope @Dependent may not have conditional observer methods. If a bean with scope @Dependent has an observer method declared receive=IF_EXISTS, the container automatically detects the problem and treats it as a definition error.
Coverage
The enumeration javax.enterprise.event.Reception identifies the possible values of receive.
Coverage
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
An after success observer method is called during the after completion phase of the transaction, only when the transaction completes successfully
An after failure observer method is called during the after completion phase of the transaction, only when the transaction fails
The enumeration javax.enterprise.event.TransactionPhase identifies the kind of transactional observer method.
When an event is fired by the application, the container must determine the observers for that event according to the observer resolution defined by Section 10.2, "Observer resolution", then then for each observer method, either invoke the observer method immediately or register the observer method for later invocation during the transaction completion phase, using a JTA Synchronization.
The container calls observer methods as defined in Section 5.5.6, "Invocation of observer methods".
If the observer method is a transactional observer method and there is currently a JTA transaction in progress, the container calls the observer method during the appropriate transaction completion phase. Otherwise, the container calls the observer immediately.
If the observer method is a transactional observer method and there is currently a JTA transaction in progress, the container calls the observer method during the appropriate transaction completion phase. Otherwise, the container calls the observer immediately.
Coverage
If the observer method is a conditional observer method and there is no context active for the scope to which the bean declaring the observer method belongs, then the observer method should not be called.
Coverage
The order in which observer methods are called is not defined, and so portable applications should not rely upon the order in which observers are called.
Any observer method called before completion of a transaction may call setRollbackOnly() to force a transaction rollback.
Coverage
An observer method may not directly initiate, commit or rollback JTA transactions.
Observers may throw exceptions. If an observer method is a transactional observer method, any exception is caught and logged by the container.
Observers may throw exceptions. If an observer method is a transactional observer method, any exception is caught and logged by the container. Otherwise, the exception aborts processing of the event.
Coverage
Observers may throw exceptions. If an observer method is a transactional observer method, any exception is caught and logged by the container. Otherwise, the exception aborts processing of the event. No other observer methods of that event will be called. The BeanManager.fireEvent() or Event.fire() method rethrows the exception. If the exception is a checked exception, it is wrapped and rethrown as an (unchecked) ObserverException.
Coverage
Observers may throw exceptions. If an observer method is a transactional observer method, any exception is caught and logged by the container. Otherwise, the exception aborts processing of the event. No other observer methods of that event will be called. The BeanManager.fireEvent() or Event.fire() method rethrows the exception. If the exception is a checked exception, it is wrapped and rethrown as an (unchecked) ObserverException.
Coverage
For a custom implementation of the ObserverMethod interface defined in Section 11.1.3, "The ObserverMethod interface", the container must call getTransactionPhase() to determine if the observer method is a transactional observer method, and notify() to invoke the method.
Check getTransactionPhase() is called.
Coverage
Check notify() is called.
Coverage
CDI 1.1 implementations should call the notify method which takes both the event object and the event qualifiers only.
Coverage
If the observer method is a before completion 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.
Coverage
No tests exist for this assertion
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.
Coverage
No tests exist for this assertion
If an observer method is not a before completion 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() or BeanManager.fireEvent().
Coverage
No tests exist for this assertion
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
A portable extension may integrate with the container by providing its own beans, interceptors and decorators to the container.
A portable extension may integrate with the container by injecting dependencies into its own objects using the dependency injection service.
A portable extension may integrate with the container by providing a context implementation for a custom scope.
Augmenting or overriding the annotation-based metadata with metadata from some other source.
Implementations of Bean must also implement the inherited operations defined by the Contextual interface defined in Section 6.1, "The Contextual interface".
getTypes(), getQualifiers(), getScope(), getName() and getStereotypes() must return the bean types, qualifiers, scope type, EL name and stereotypes of the bean, as defined in Chapter 2, Concepts.
Coverage
getBeanClass() returns the bean class of the managed bean or session bean or of the bean that declares the producer method or field.
Coverage
isAlternative() must return true if the bean is an alternative, and false otherwise.
isNullable() must return true if the method create() sometimes returns a null value, and false otherwise, as defined in Section 5.2.4, "Primitive types and null values".
getInjectionPoints() returns a set of InjectionPoint objects, defined in Section 5.5.7, "Injection point metadata", representing injection points of the bean, that will be validated by the container at initialization time.
Coverage
An instance of Bean exists for every enabled bean.
Coverage
A portable extension may add support for new kinds of beans beyond those defined by the this specification (managed beans, session beans, producer methods, producer fields and resources) by implementing Bean and registering beans with the container, using the mechanism defined in Section 11.5.2, "AfterBeanDiscovery event".
The Bean object for a decorator must implement the interface javax.enterprise.inject.spi.Decorator.
Coverage
getDecoratedTypes() returns the decorated types of the decorator.
Coverage
getDelegateType() and getDelegateQualifiers() return the delegate type and qualifiers of the decorator.
Coverage
An instance of Decorator exists for every enabled decorator.
Coverage
The Bean object for an interceptor must implement javax.enterprise.inject.spi.Interceptor.
Coverage
getInterceptorBindings() returns the interceptor bindings of the interceptor.
Coverage
intercepts() returns true if the interceptor intercepts the specified kind of lifecycle callback or method invocation, and false otherwise.
Coverage
intercept() invokes the specified kind of lifecycle callback or method invocation interception upon the given instance of the interceptor.
Coverage
An InterceptionType identifies the kind of lifecycle callback, EJB timeout method or business method.
Coverage
An instance of Interceptor exists for every enabled interceptor.
Coverage
The interface javax.enterprise.inject.spi.ObserverMethod defines everything the container needs to know about an observer method.
getBeanClass() returns the bean class of the bean that declares the observer method.
Coverage
getReception() returns IF_EXISTS for a conditional observer and ALWAYS otherwise.
Coverage
getTransactionPhase() returns the appropriate transaction phase for a transactional observer method or IN_PROGRESS otherwise.
Coverage
notify() calls the observer method, as defined in Section 5.5.6 "Invocation of observer methods".
Coverage
An instance of ObserverMethod exists for every observer method of every enabled bean.
Coverage
The interface javax.enterprise.inject.spi.Producer provides a generic operation for producing an instance of a type.
For a Producer that represents a class, produce() calls the constructor annotated @Inject if it exists, or the constructor with no parameters otherwise, as defined in Section 5.5.1, "Injection using the bean constructor". and returns the resulting instance. If the class has interceptors, produce() is responsible for building the interceptors and decorators of the instance.
Test field injection occurs
Coverage
Test initializer methods called
Coverage
Test constructor injected
Coverage
Test decorator stack built
Coverage
No tests exist for this assertion
Test interceptor stack built
Coverage
No tests exist for this assertion
For a Producer that represents a class, dispose() does nothing.
For a Producer that represents a class, getInjectionPoints() returns a set of InjectionPoint objects representing all injected fields, bean constructor parameters and initializer method parameters.
Test injected fields.
Coverage
Test bean constructor parameters.
Coverage
Test initializer method parameters.
Coverage
For a Producer that represents a producer method or field, produce() calls the producer method on, or accesses the producer field of, a contextual instance of the bean that declares the producer method, as defined in Section 5.5.4, "Invocation of producer or disposer methods".
For a Producer that represents a producer method or field, dispose() calls the disposer method, if any, on a contextual instance of the bean that declares the disposer method, as defined in Section 5.5.4, "Invocation of producer or disposer methods", or performs any additional required cleanup, if any, to destroy state associated with a resource.
Test with producer method.
Coverage
For a Producer that represents a producer method, getInjectionPoints() returns the set of InjectionPoint objects representing all parameters of the producer method.
Coverage
The subinterface javax.enterprise.inject.spi.InjectionTarget provides operations for performing dependency injection and lifecycle callbacks on an instance of a type.
inject() performs dependency injection upon the given object. The container performs Java EE component environment injection, according to the semantics required by the Java EE platform specification, sets the value of all injected fields, and calls all initializer methods, as defined in Section 5.5.2, "Injection of fields and initializer methods".
postConstruct() calls the @PostConstruct callback, if it exists, according to the semantics required by the Java EE platform specification.
Coverage
preDestroy() calls the @PreDestroy callback, if it exists, according to the semantics required by the Java EE platform specification.
Coverage
Implementations of Producer and InjectionTarget must ensure that the set of injection points returned by getInjectionPoints() are injected by produce() or inject().
The container provides a built-in bean with bean type BeanManager, scope @Dependent and qualifier @Default.
Test the bean type.
Coverage
Test the scope.
Coverage
Test the qualifier.
Coverage
The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, "Passivation capable dependencies".
Coverage
Any bean may obtain an instance of BeanManager by injecting it.
Any operation of BeanManager may be called at any time during the execution of the application.
Coverage
No tests exist for this assertion
A portable extension or other object may obtain a reference to the current container by calling CDI.current(). CDI.getBeanManager() may be called at any time after the container fires the BeforeBeanDiscovery container lifecycle event until the container fires the BeforeShutdown container lifecycle event. Other methods on CDI may be called after the application initialization is completed until the application shutdown starts.
Test CDI.getBeanManager() is called before the application initialization is completed.
Coverage
Test CDI.getBeanManager() is called after the application initialization is completed.
Coverage
Test lookup of bean instances after the application initialization is completed.
Coverage
The CDIProvider to use may be set by the application or container using the setCDIProvider() method. If the setCDIProvider() has not been called, the first service provider of the service javax.enterprise.inject.spi.CDIProvider declared in META-INF/services is used. If no provider is available an IllegalStateException is thrown.
Test using CDIProvider set by the application.
Coverage
The method BeanManager.getReference() returns a contextual reference for a given bean and bean type, as defined in Section 6.5.3, "Contextual reference for a bean".
Coverage
The first parameter is the Bean object representing the bean. The second parameter represents the bean type that must be implemented by any client proxy that is returned. The third parameter is an instance of CreationalContext that may be used to destroy any object with scope @Dependent that is created.
Coverage
If the given type is not a bean type of the given bean, an IllegalArgumentException is thrown.
Coverage
The method BeanManager.getInjectableReference() returns an injectable reference for a given injection point, as defined in Section 6.5.5, "Injectable references".
Coverage
The first parameter represents the target injection point. The second parameter is an instance of CreationalContext that may be used to destroy any object with scope @Dependent that is created.
Coverage
If the InjectionPoint represents a decorator delegate injection point, getInjectableReference() returns a delegate, as defined in Section 8.1.2, "Decorator delegate injection points".
Coverage
If typesafe resolution results in an unsatisfied dependency, the container must throw an UnsatisfiedResolutionException.
Coverage
If typesafe resolution results in an unresolvable ambiguous dependency, the container must throw an AmbiguousResolutionException.
Coverage
Implementations of Bean usually maintain a reference to an instance of BeanManager. When the Bean implementation performs dependency injection, it must obtain the contextual instances to inject by calling BeanManager.getInjectableReference(), 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
An instance of CreationalContext for a certain instance of Contextual may be obtained by calling BeanManager.createCreationalContext().
Coverage
An instance of CreationalContext for a non-contextual object may be obtained by passing a null value to createCreationalContext().
Coverage
The method BeanManager.getBeans() returns the set of beans which have the given required type and qualifiers and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules for candidates of typesafe resolution defined in Section 5.2.1, “Performing typesafe resolution”.
Test simple scenario.
Test alternatives are not filtered.
Coverage
The first parameter is a required bean type. The remaining parameters are required qualifiers.
If no qualifiers are passed to getBeans(), the default qualifier @Default is assumed.
Coverage
If the given type represents a type variable, an IllegalArgumentException is thrown.
If two instances of the same qualifier type are given, an IllegalArgumentException is thrown.
If an instance of an annotation that is not a qualifier type is given, an IllegalArgumentException is thrown.
The method BeanManager.getBeans() which accepts a string returns the set of beans which have the given EL name and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of EL name resolution defined in Section 5.3, "EL name resolution".
Coverage
The parameter is an EL name.
Coverage
The method BeanManager.getPassivationCapableBean() returns the PassivationCapable bean with the given identifier (see Section 6.6.1, "Passivation capable beans").
Coverage
The method BeanManager.resolve() applies the ambiguous dependency resolution rules defined in Section 5.2.1, "Unsatisfied and ambiguous dependencies" to a set of Beans.
Coverage
If the ambiguous dependency resolution rules fail, the container must throw an AmbiguousResolutionException.
Coverage
The method BeanManager.resolve() must return null, if:
null is passed to resolve(),
no beans are passed to resolve(),
Coverage
no bean is available for injection in the module (as defined in Section 5.1, "Modularity"").
Coverage
No tests exist for this assertion
The BeanManager.validate() operation validates an injection point and throws an InjectionException if there is a deployment problem (for example, an unsatisfied or unresolvable ambiguous dependency) associated with the injection point.
Coverage
The method validate() validates the dependency and throws an InjectionException if there is a deployment problem (for example, an unsatisfied or unresolvable ambiguous dependency) associated with the injection point.
Coverage
The method BeanManager.fireEvent() fires an event and notifies observers, according to Section 10.5, "Observer notification".
The first argument is the event object. The remaining parameters are event qualifiers.
If the runtime type of the event object contains a type variable, an IllegalArgumentException is thrown.
If two instances of the same qualifier type are given, an IllegalArgumentException is thrown.
Coverage
If an instance of an annotation that is not a qualifier type is given, an IllegalArgumentException is thrown.
Coverage
If the runtime type of the event object is assignable to the type of a container lifecycle event, IllegalArgumentException is thrown.
Coverage
The method BeanManager.resolveObserverMethods() resolves observer methods for an event according to the rules of observer resolution defined in Section 10.2, "Observer resolution".
The first parameter of resolveObserverMethods() is the event object. The remaining parameters are event qualifiers.
Coverage
If the runtime type of the event object contains a type variable, an IllegalArgumentException is thrown.
Coverage
If two instances of the same qualifier type are given, an IllegalArgumentException is thrown.
Coverage
If an instance of an annotation that is not a qualifier type is given, an IllegalArgumentException is thrown.
Coverage
The method BeanManager.resolveDecorators() returns the ordered list of decorators for a set of bean types and a set of qualifiers which are enabled in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, as defined in Section 8.3, "Decorator resolution".
The first argument is the set of bean types of the decorated bean. The annotations are qualifiers declared by the decorated bean.
Coverage
If two instances of the same qualifier type are given, an IllegalArgumentException is thrown.
Coverage
If an instance of an annotation that is not a qualifier type is given, an IllegalArgumentException is thrown.
Coverage
If the set of bean types is empty, an IllegalArgumentException is thrown.
The method BeanManager.resolveInterceptors() returns the ordered list of interceptors for a set of interceptor bindings and a type of interception which are enabled in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, as defined in Section 9.5, "Interceptor resolution".
Coverage
If two instances of the same interceptor binding type are given, an IllegalArgumentException is thrown.
Coverage
If no interceptor binding type instance is given, an IllegalArgumentException is thrown.
Coverage
If an instance of an annotation that is not an interceptor binding type is given, an IllegalArgumentException is thrown.
Coverage
A portable extension may test an annotation to determine if it is a qualifier type, scope type, stereotype or interceptor binding type, obtain the set of meta-annotations declared by a stereotype or interceptor binding type, or determine if a scope type is a normal or passivating scope.
Test qualifier type.
Coverage
Test scope type.
Test stereotype.
Coverage
Test interceptor binding type.
Coverage
Test meta-annotations for stereotype.
Coverage
Test meta-annotations for interceptor binding type.
Coverage
Test obtaining a ScopeType.
Coverage
A portable extension may determine if two qualifiers or two interceptor bindings are considered equivalent for the purposes of typesafe resolution, as defined in Section 5.2.1, "Performing typesafe resolution".
Test equivalence of qualifiers using BeanManager.areQualifiersEquivalent().
Coverage
Test equivalence of interceptor bindings using BeanManager.areInterceptorBindingsEquivalent().
Coverage
A portable extension may determine the hash code of a qualifier or and interceptor binding, ignoring any members annotated with @Nonbinding.
Determine the hash code of a qualifier using BeanManager.getQualifierHashCode().
Coverage
Determine the hash code of an interceptor binding using BeanManager.getInterceptorBindingHashCode().
Coverage
The method BeanManager.getContext() retrieves an active context object associated with the a given scope, as defined in Section 6.5.1, "The active context object for a scope".
The method BeanManager.getELResolver() returns the javax.el.ELResolver specified in Section 12.4, "Integration with Unified EL".
The method BeanManager.wrapExpressionFactory() returns a wrapper javax.el.ExpressionFactory that delegates MethodExpression and ValueExpression creation to the given ExpressionFactory.
Coverage
When a Unified EL expression is evaluated using a MethodExpression or ValueExpression returned by the wrapper ExpressionFactory, the rules defined in Section 6.4.3, "Dependent pseudo-scope and Unified EL" are enforced by the container.
Coverage
The method BeanManager.createAnnotatedType() returns an AnnotatedType that may be used to read the annotations of a given Java class or interface.
Coverage
The method BeanManager.getAnnotatedType() returns the AnnotatedType discovered or added during container initialization.
Coverage
The method BeanManager.getAnnotatedTypes() returns the AnnotatedTypes discovered or added during container initialization.
Coverage
The method BeanManager.createInjectionTarget() returns a container provided implementation of InjectionTarget for a given AnnotatedType or throws an IllegalArgumentException if there is a definition error associated with any injection point of the type.
Check InjectionTarget is provided.
Coverage
Check IllegalArgumentException is thrown.
Coverage
The method BeanManager.createProducer() returns a container provided implementation of Producer for a given AnnotatedMethod or AnnotatedField or throws an IllegalArgumentException if there is a definition error associated with the producer method or field.
Test that the method BeanManager.createProducer() returns a container provided implementation of Producer for a given AnnotatedMethod.
Test that the method BeanManager.createProducer() returns a container provided implementation of Producer for a given AnnotatedField.
Test that the method BeanManager.createProducer() throws an IllegalArgumentException if there is a definition error associated with the producer method.
Test that the method BeanManager.createProducer() throws an IllegalArgumentException if there is a definition error associated with the producer field.
The method BeanManager.createInjectionPoint() returns a container provided implementation of InjectionPoint for a given AnnotatedField or AnnotatedParameter or throws an IllegalArgumentException if there is a definition error associated with the injection point.
Test that the method BeanManager.createInjectionPoint() returns a container provided implementation of InjectionPoint for a given AnnotatedField.
Coverage
Test that the method BeanManager.createInjectionPoint() returns a container provided implementation of InjectionPoint for a given AnnotatedParameter.
Test that the method BeanManager.createInjectionPoint() throws an IllegalArgumentException if there is a definition error associated with the injection point.
The method BeanManager.createBeanAttributes() returns a container provided implementation of BeanAttributes by reading the annotations of a given AnnotatedType or AnnotatedMember, according to the rules define in Chapter 2, Concepts, or throws an IllegalArgumentException if there is a definition error associated with the declared bean attributes.
Test that the method BeanManager.createBeanAttributes() returns a container provided implementation of BeanAttributes by reading the annotations of a given AnnotatedType.
Coverage
Test that the method BeanManager.createBeanAttributes() returns a container provided implementation of BeanAttributes by reading the annotations of a given AnnotatedMember.
Test that the method BeanManager.createBeanAttributes() throws an IllegalArgumentException if there is a definition error associated with the declared bean attributes.
Coverage
The method BeanManager.createBean() returns a container provided implementation of Bean. The method accepts a BeanAttributes, which determines the bean types, qualifiers, scope, name and stereotypes of the returned Bean, and the return values of isAlternative() and isNullable(), and a class, which determines the return value of Bean.getClass().
Test the first version of the method BeanManager.createBean() that also accepts an InjectionTarget, which is used to create and destroy instances of the bean, to perform dependency injection and lifecycle callbacks, and which determines the return value of Bean.getInjectionPoints().
Test the second version of the method BeanManager.createBean() that also accepts a Producer, which is used to create and destroy instances of the bean, and which determines the return value of Bean.getInjectionPoints().
The method BeanManager.getExtension() returns the container's instance of an Extension class declared in META-INF/services, or throws an IllegalArgumentException if the container has no instance of the given class.
Test that the method BeanManager.getExtension() returns the container's instance of an Extension class declared in META-INF/services.
Test that the method BeanManager.getExtension() throws an IllegalArgumentException if the container has no instance of the given class.
The interfaces AnnotatedType, AnnotatedField, AnnotatedMethod, AnnotatedConstructor and AnnotatedParameter in the package javax.enterprise.inject.spi allow a portable extension to specify metadata that overrides the annotations that exist on a bean class. The portable extension is responsible for implementing the interfaces, thereby exposing the metadata to the container.
The interface javax.enterprise.inject.spi.AnnotatedType exposes the Class object and members.
Test that getConstructors() returns all the constructors declared for the type.
Coverage
Test that getMethods() returns all the methods declared on the type and those declared on any supertypes.
Test that getFields() returns all the fields declared on the type and those declared on any supertypes.
When determining annotations on a type, the container must only consider the special inheritance rules defined for scope types in Section 4.1, "Inheritance of type-level metadata".
Coverage
The interface javax.enterprise.inject.spi.Annotated exposes the overriding annotations and type declarations.
getBaseType() returns the type of the program element.
getTypeClosure() returns all types to which the base type should be considered assignable.
Coverage
getAnnotation() returns the program element annotation of the given annotation type, or a null value.
Coverage
getAnnotations() returns all annotations of the program element.
Coverage
isAnnotationPresent() returns true if the program element has an annotation of the given annotation type, or false otherwise.
Coverage
If the Annotated represents a type, then the annotations returned should include all annotations on the type and it's super types regardless of whether the annotation is marked @Inherited.
Coverage
The container must use the operations of Annotated and its subinterfaces to discover program element types and annotations. The container must not directly call the Java Reflection API. In particular, the container must call Annotated.getBaseType() to determine the type of an injection point, event parameter or disposed parameter, call Annotated.getTypeClosure() to determine the bean types of any kind of bean, call Annotated.getAnnotations() to determine the scope, qualifiers, stereotypes and interceptor bindings of a bean, call Annotated.isAnnotationPresent() and Annotated.getAnnotation() to read any bean annotations defined by this specification, and call AnnotatedType.getConstructors(), AnnotatedType.getMethods() and AnnotatedType.getFields() to determine the members of a bean class.
Check that the container uses the operations of Annotated and its subinterfaces to discover program element types and annotations. and that the container does not use the Java Reflection API.
Coverage
Check that getBaseType() is used to determine the type of a field injection point. The base type should be different from the orignal type specified in the class definition
Coverage
Check that getBaseType() is used to determine the type of an initializer method injection point. The base type should be different from the orignal type specified in the class definition
Coverage
Check that getBaseType() is used to determine the type of a constructor injection point. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that getBaseType() is used to determine the type of a producer method injection point. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that getBaseType() is used to determine the type of a observer method injection point. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that getBaseType() is used to determine the type of a disposer method injection point. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that getBaseType() is used to determine the type of an event parameter. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that getBaseType() is used to determine the type of disposed parameter. The base type should be different from the orignal type specified in the class definition
Coverage
No tests exist for this assertion
Check that a getTypeClosure() is used to determine the bean types for a managed bean. The type closure should be different from the orignal type specified in the class definition.
Coverage
Check that a getTypeClosure() is used to determine the bean types for a session bean. The type closure should be different from the orignal type specified in the class definition.
Coverage
No tests exist for this assertion
Check that a getTypeClosure() is used to determine the bean types for a producer field. The type closure should be different from the orignal type specified in the class definition.
Coverage
No tests exist for this assertion
Check that a getTypeClosure() is used to determine the bean types for a producer method. The type closure should be different from the orignal type specified in the class definition.
Coverage
No tests exist for this assertion
Check that getAnnotations() is used to determine the bean scope. The annotations should be different from the orignal type specified in the class definition.
Coverage
Check that getAnnotations() is used to determine the bean qualifiers. The annotations should be different from the orignal type specified in the class definition.
Coverage
Check that getAnnotations() is used to determine the bean stereotypes. The annotations should be different from the orignal type specified in the class definition.
Coverage
Check that getAnnotations() is used to determine the bean interceptors. The annotations should be different from the orignal type specified in the class definition.
Coverage
Check that isAnnotationPresent() returns the provided annotations
Check that a previously non-inject-annotated constructor is used by the container to instantiate a bean.
Coverage
Check that a qualifier added to a parameter is used by the container to instantiate a bean.
Coverage
No tests exist for this assertion
Check that a previously non-inject-annotated field is injected.
Coverage
Check that an extra qualifier is applied.
Coverage
Check that @Produces added creates a producer field.
Coverage
Check that a previously non-inject-annotated method is injected.
Coverage
Check that an extra qualifier is applied to an injectable method
Coverage
Check that @Produces added creates a producer method
Coverage
Check that an extra qualifier is applied to a producer method.
Coverage
Check that a qualifer added to a producer method parameter is applied.
Coverage
Check that @Disposes added to a parameter creates a disposes method
Coverage
No tests exist for this assertion
Check that an extra qualifier is applied to a disposes method parameter.
Coverage
No tests exist for this assertion
Check that a qualifer added to a disposes method injectable parameter is applied.
Coverage
No tests exist for this assertion
Check that @Observes added to a parameter creates a observer method
Coverage
Check that an extra qualifier is applied to an observes method parameter.
Coverage
Check that a qualifer added to a observes method injectable parameter is applied.
Coverage
During the application initialization process, the container fires a series of events, allowing portable extensions to integrate with the container initialization process defined in Section 12.2, "Application initialization lifecycle".
Observer methods of these events must belong to extensions. An extension is a service provider of the service javax.enterprise.inject.spi.Extension declared in META-INF/services.
Coverage
Service providers may have observer methods, which may observer any event, including any container lifecycle event, and obtain an injected BeanManager reference.
Coverage
An extension may use BeanManager.fireEvent() to deliver events to observer methods defined on extensions.
Coverage
The container is not required to deliver events fired during application initialization to observer methods defined on beans.
Any decorators associated with BeanManager will not be applied.
Coverage
The container instantiates a single instance of each extension at the beginning of the application initialization process and maintains a reference to it until the application shuts down. The container delivers event notifications to this instance by calling its observer methods.
For each service provider, the container must provide a bean of scope @ApplicationScoped and qualifier @Default, supporting injection of a reference to the service provider instance. The bean types of this bean include the class of the service provider and all superclases and interfaces.
The container must fire an event before it begins the bean discovery process. The event object must be of type javax.enterprise.inject.spi.BeforeBeanDiscovery.
Coverage
addQualifier() declares an annotation type as a qualifier type.
addScope() declares an annotation type as a scope type.
Coverage
addStereotype() declares an annotation type as a stereotype, and specifies its meta-annotations.
Coverage
addAnnotatedType() adds a given AnnotatedType to the set of types which will be scanned during bean discovery. More than one AnnotatedType may use the same base type, and the container must consider these as different types.
Test that more than one AnnotatedType may use the same base type.
Coverage
No tests exist for this assertion
If any observer method of the BeforeBeanDiscovery event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire a second event when it has fully completed the bean discovery process, validated that there are no definition errors relating to the discovered beans, and registered Bean and ObserverMethod objects for the discovered beans, but before detecting deployment problems. The event object must be of type javax.enterprise.inject.spi.AfterBeanDiscovery.
Coverage
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after all observers have been notified.
Coverage
addBean() fires an event of type ProcessBean containing the given Bean and then registers the Bean with the container, thereby making it available for injection into other beans. The given Bean may implement Interceptor or Decorator.
Check that ProcessBean is fired
Coverage
Check that a bean is registered
Coverage
Check that a decorator is registered
Coverage
Check that an interceptor is registered
Coverage
addObserverMethod() fires an event of type ProcessObserverMethod containing the given ObserverMethod and then registers the ObserverMethod with the container, thereby making it available for event notifications.
Check that the ProcessObserverMethod is fired
Coverage
Check that the observer method is registered
Coverage
addContext() registers a custom Context object with the container.
Coverage
A portable extension may take advantage of this event to register beans, interceptors, decorators, observer methods and custom context objects with the container.
If any observer method of the AfterBeanDiscovery event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire a third event after it has validated that there are no deployment problems and before creating contexts or processing requests. The event object must be of type javax.enterprise.inject.spi.AfterDeploymentValidation.
Coverage
addDeploymentProblem() registers a deployment problem with the container, causing the container to abort deployment after all observers have been notified.
Coverage
If any observer method of the AfterDeploymentValidation event throws an exception, the exception is treated as a deployment problem by the container.
Coverage
The container must not allow any request to be processed by the deployment until all observers of this event return.
Coverage
No tests exist for this assertion
The container must fire a final event after it has finished processing requests and destroyed all contexts. The event object must be of type javax.enterprise.inject.spi.BeforeShutdown.
Coverage
If any observer method of the BeforeShutdown event throws an exception, the exception is ignored by the container.
The container must fire an event for each bean deployment archive, before it processes the classes packaged in that module. The event object must be of type javax.enterprise.inject.spi.ProcessModule.
getAlternatives() returns the set of enabled alternatives of the bean deployment archive.
Coverage
getInterceptors() returns the list of enabled interceptors of the bean deployment archive.
Coverage
getDecorators() returns the list of enabled decorators of the bean deployment archive.
Coverage
getAnnotatedTypes() returns an iterator over AnnotatedType objects representing the Java classes and interfaces in the bean archive.
Coverage
getBeansXml() returns an input stream which can be used to read in the beans.xml for this module.
Any observer of this event is permitted to add classes to, or remove classes from, the set of alternatives, list of interceptors or list of decorators. The container must use the final values of these collections, after all observers have been called, to determine the enabled alternatives, interceptors, and decorators for the bean deployment archive. The initial values of these collections is determined by reading the beans.xml file of the bean deployment archive.
Check observer is permitted to add classes to the set of alternatives and the container reflects this operation.
Coverage
Check observer is permitted to remove classes from the set of alternatives and the container reflects this operation.
Coverage
Check observer is permitted to add classes to the list of interceptors and the container reflects this operation.
Coverage
Check observer is permitted to remove classes from the list of interceptors and the container reflects this operation.
Coverage
Check observer is permitted to add classes to the list of decorators and the container reflects this operation.
Coverage
Check observer is permitted to remove classes from the list of decorators and the container reflects this operation.
Coverage
Check the initial values are determined by reading the beans.xml file of the bean deployment archive.
If any observer method of a ProcessModule event throws an exception, the exception is treated as a deployment problem by the container.
Coverage
If the final list of enabled interceptors of the bean deployment archive contains duplicate elements, the container automatically detects the problem and treats it as a deployment problem.
Coverage
If the final list of enabled decorators of the bean deployment archive contains duplicate elements, the container automatically detects the problem and treats it as a deployment problem.
Coverage
The container must fire an event, before it processes a type, for each Java class, interface, enum or annotation discovered in a bean archive, Annotated type added by BeforeBeanDiscovery.addAnnotatedType(), annotation added by BeforeBeanDiscovery.addInterceptorBinding(), BeforeBeanDiscovery.addQualifier(), BeforeBeanDiscovery.addScope() or BeforeBeanDiscovery.addStereotype().
Test class discovered in a bean archive.
Coverage
Test interface discovered in a bean archive.
Coverage
Test enum discovered in a bean archive.
Coverage
Test annotation discovered in a bean archive.
Coverage
Test class added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
Test interface added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
Test enum added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
No tests exist for this assertion
Test annotation added by BeforeBeanDiscovery.addInterceptorBinding(), BeforeBeanDiscovery.addQualifier(), BeforeBeanDiscovery.addScope() and BeforeBeanDiscovery.addStereotype().
Coverage
No tests exist for this assertion
An event is not fired for any type annotated with @Vetoed, or in a package annotated with @Vetoed.
Test @Vetoed interface discovered in a bean archive.
Test @Vetoed enum discovered in a bean archive.
Test @Vetoed annotation discovered in a bean archive.
Test @Vetoed interface added by BeforeBeanDiscovery.addAnnotatedType().
Test @Vetoed enum added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
No tests exist for this assertion
Test @Vetoed annotation added by BeforeBeanDiscovery.addInterceptorBinding(), BeforeBeanDiscovery.addQualifier(), BeforeBeanDiscovery.addScope() and BeforeBeanDiscovery.addStereotype().
Coverage
No tests exist for this assertion
Test @Vetoed package.
The annotation @WithAnnotations may be applied to the event parameter. If the annotation is applied, the container must only deliver ProcessAnnotatedType events for types which contain at least one of the annotations specified. The annotation can appear on the type, on any field, method or constructor declared by the type, or on any parameter of any method or constructor declared by the type.
Test annotation on the field.
Coverage
Test annotation on the constructor.
Coverage
Test annotation on the parameter of the method.
Coverage
Test annotation on the parameter of the constructor.
Coverage
If the @WithAnnotations annotation is applied to any other event parameter, the container automatically detects the problem and treats it as a definition error.
getAnnotatedType() returns the AnnotatedType object that will be used by the container to read the declared annotations.
Coverage
setAnnotatedType() replaces the AnnotatedType.
Coverage
veto() forces the container to ignore the type.
Coverage
getSource() returns the Extension instance that added the annotated type.
Coverage
Any observer of this event is permitted to wrap and/or replace the AnnotatedType. The container must use the final value of this property, after all observers have been called, as the only source of types and annotations for the the program elements.
Test class added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
Test annotation added by BeforeBeanDiscovery.addAnnotatedType().
Coverage
No tests exist for this assertion
If any observer method of a ProcessAnnotatedType event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire an event for every injection point of every Java EE component class supporting injection that may be instantiated by the container at runtime. The event object must be of type javax.enterprise.inject.spi.ProcessInjectionPoint<T, X> where T is the bean class of the bean that declares the injection point, and X is the declared type of the injection point.
Coverage
getInjectionPoint() returns the InjectionPoint object that will be used by the container to perform injection.
Coverage
setInjectionPoint() replaces the InjectionPoint.
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
Any observer of this event is permitted to wrap and/or replace the InjectionPoint. The container must use the final value of this property, after all observers have been called, whenever it performs injection upon the injection point.
If any observer method of a ProcessInjectionPoint event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire an event for every Java EE component class supporting injection that may be instantiated by the container at runtime, including every managed bean declared using @ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled decorator. The event object must be of type javax.enterprise.inject.spi.ProcessInjectionTarget<X>, where x is the managed bean class, session bean class or Java EE component class supporting injection.
Test event is fired for a session bean
Coverage
Test event is fired for a message driven bean
Coverage
Test event is fired for a servlet listener
Coverage
Test event is fired for a tag handler
Coverage
Test event is fired for a tag library listener
Coverage
Test event is fired for an EJB Interceptor
Coverage
Test event is fired for a WS endpoint
Coverage
Test event is fired for a servlet
Coverage
Test event is fired for a filter
Coverage
Test supertype for a servlet listener
Coverage
Test supertype and subtype for a tag handler
Coverage
Test supertype and subtype for a servlet
Coverage
getAnnotatedType() returns the AnnotatedType representing the managed bean class, session bean or other Java EE component class supporting injection.
Test type for a managed bean
Coverage
Test type for a session bean
Coverage
Test type for a message driven bean
Coverage
Test type for a servlet listener
Coverage
Test type for a tag handler
Coverage
Test type for a tag library listener
Coverage
Test type for an EJB Interceptor
Coverage
Test type for a WS endpoint
Coverage
Test type for a servlet
Coverage
Test type for a filter
Coverage
getInjectionTarget() returns the InjectionTarget object that will be used by the container to perform injection.
Coverage
No tests exist for this assertion
setInjectionTarget() replaces the InjectionTarget.
Coverage
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
Any observer of this event is permitted to wrap and/or replace the InjectionTarget. The container must use the final value of this property, after all observers have been called, whenever it performs injection upon the managed bean, session bean or other Java EE component class supporting injection.
Test type for a managed bean
Coverage
Test type for a session bean
Coverage
No tests exist for this assertion
Test type for a servlet listener
Coverage
No tests exist for this assertion
Test type for a tag handler
Coverage
No tests exist for this assertion
Test type for a tag library listener
Coverage
No tests exist for this assertion
Test type for an EJB Interceptor
Coverage
No tests exist for this assertion
Test type for a WS endpoint
Coverage
No tests exist for this assertion
Test type for a servlet
Coverage
No tests exist for this assertion
Test type for a filter
Coverage
No tests exist for this assertion
If any observer method of a ProcessInjectionTarget event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire an event for each producer method or field of each enabled bean, including resources.
Test producer method
Coverage
Test producer field
Coverage
Test resource producer field
Coverage
The event object must be of type javax.enterprise.inject.spi.ProcessProducer<T, X>, where T is the bean class of the bean that declares the producer method or field and X is the return type of the producer method or the type of the producer field.
getAnnotatedMember() returns the AnnotatedField representing the producer field or the AnnotatedMethod representing the producer method.
getProducer() returns the Producer object that will be used by the container to call the producer method or read the producer field.
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
Any observer of this event is permitted to wrap and/or replace the Producer. The container must use the final value of this property, after all observers have been called, whenever it calls the producer or disposer.
Test producer method
Coverage
No tests exist for this assertion
Test producer field
Coverage
No tests exist for this assertion
If any observer method of a ProcessProducer event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire an event for each enabled bean, interceptor or decorator deployed in a bean archive, before registering the Bean object. No event is fired for any @New qualified bean, defined in Section 3.14, "@New qualified beans". The event object must be of type javax.enterprise.inject.spi.ProcessBeanAttributes<T> where T is the bean class of the managed bean or session bean, the return type of the producer method, or the type of the producer field.
Event is fired for enabled bean.
Coverage
Event is fired for enabled interceptor.
Coverage
Event is fired for enabled decorator.
Coverage
No event is fired for any @New qualified bean.
Coverage
getAnnotated() returns the AnnotatedType representing the managed bean class or session bean class, the AnnotatedMethod representing the producer field, or the AnnotatedField representing the producer field.
Test managed bean.
Coverage
Test producer method.
Coverage
Test producer field.
Coverage
getBeanAttributes() returns the BeanAttributes object that will be used by the container to manage instances of the bean.
Coverage
setBeanAttributes() replaces the BeanAttributes.
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
veto() forces the container to ignore the bean.
Coverage
Any observer of this event is permitted to wrap and/or replace the BeanAttributes. The container must use the final value of this property, after all observers have been called, to manage instances of the bean.
Coverage
If any observer method of a ProcessBeanAttributes event throws an exception, the exception is treated as a definition error by the container.
Coverage
The container must fire an event for each enabled bean, interceptor or decorator deployed in a bean archive, after firing the ProcessBeanAttributes for the bean and before registering the Bean object. No event is fired for any @New qualified bean, defined in Section 3.12, "@New qualified beans".
For a managed bean with bean class X, the container must raise an event of type ProcessManagedBean<X>.
Test ProcessManagedBean is fired after ProcessBeanAttributes.
Coverage
For a session bean with bean class X, the container must raise an event of type ProcessSessionBean<X>.
Coverage
Test ProcessSessionBean is fired after ProcessBeanAttributes.
Coverage
For a producer method with method return type X of a bean with bean class T, the container must raise an event of type ProcessProducerMethod<T, X>.
Coverage
Test ProcessProducerMethod is fired after ProcessBeanAttributes.
Coverage
For a producer field with field type X of a bean with bean class T, the container must raise an event of type ProcessProducerField<T, X>.
Coverage
Test ProcessProducerField is fired after ProcessBeanAttributes.
Coverage
Resources are considered to be producer fields.
Coverage
The interface javax.enterprise.inject.spi.ProcessBean is a supertype of all these event types.
Test ProcessManagedBean
Coverage
Test ProcessSessionBean
Coverage
Test ProcessProducerMethod
Coverage
Test ProcessProducerField
Coverage
getAnnotated() returns the AnnotatedType representing the bean class, the AnnotatedMethod representing the producer method, or the AnnotatedField representing the producer field.
Test ProcessManagedBean
Coverage
Test ProcessSessionBean
Coverage
Test ProcessProducerMethod
Coverage
Test ProcessProducerField
Coverage
getBean() returns the Bean object that is about to be registered. The Bean may implement Interceptor or Decorator.
Test ProcessManagedBean
Coverage
Test ProcessSessionBean
Coverage
Test ProcessProducerMethod
Coverage
Test ProcessProducerField
Coverage
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
getSessionBeanType() returns a javax.enterprise.inject.spi.SessionBeanType representing the kind of session bean.
If any observer method of a ProcessBean event throws an exception, the exception is treated as a definition error by the container.
Coverage
Check the getAnnotatedProducerMethod()
Coverage
Check the getAnnotatedDisposesParameter()
Coverage
Check the getAnnotatedSessionBeanClass()
Coverage
Check the getAnnotatedBeanClass()
Check for managed bean
Coverage
Check for session bean
Coverage
Check the getAnnotatedProducerField()
Coverage
The container must fire an event for each observer method of each enabled bean, before registering the ObserverMethod object. The event object must be of type javax.enterprise.inject.spi.ProcessObserverMethod<T, X> where T is the bean class of the bean that declares the observer method and X is the observed event type of the observer method.
Coverage
getAnnotatedEventParameter() returns the AnnotatedParameter representing the event parameter.
Coverage
getObserverMethod() returns the ObserverMethod object that will be used by the container to call the observer method.
Coverage
addDefinitionError() registers a definition error with the container, causing the container to abort deployment after bean discovery is complete.
Coverage
If any observer method of a ProcessObserverMethod event throws an exception, the exception is treated as a definition error by the container.
Coverage
Bean classes of enabled beans must be deployed in bean archives.
A library jar, EJB jar, application client jar or rar archive is a bean archive if it has a file named beans.xml in the META-INF directory.
The WEB-INF/classes directory of a war is a bean archive if there is a file named beans.xml in the WEB-INF directory or in the WEB-INF/classes/META-INF directory of the war.
Test the beans.xml file in the WEB-INF directory.
Test the beans.xml file in the WEB-INF/classes/META-INF directory.
Coverage
The WEB-INF/classes directory of a war is a bean archive if there is a file named beans.xml in the WEB-INF directory or in the WEB-INF/classes/META-INF directory of the war.
A directory in the JVM classpath is a bean deployment archive if it has a file named beans.xml in the META-INF directory.
The container is not required to support application client jar bean archives.
The container searches for beans in all bean archives in the application classpath.
In an application deployed as an ear, the container searches every bean archive bundled with or referenced by the ear, including bean archives bundled with or referenced by wars and EJB jars contained in the ear. The bean archives might be library jars, EJB jars, rars or war WEB-INF/classes directories.
Check an EJB jar in an EAR
Coverage
Check a bundled library in an EAR
Check a bundled library in a WAR
Coverage
In an application deployed as a war, the container searches every bean archive bundled with or referenced by the war. The bean archives might be library jars or the WEB-INF/classes directory.
Check bundled libraries in the war
Coverage
In an application deployed as an EJB jar, the container searches the EJB jar, if it is a bean archive, and every bean archive referenced by the EJB jar.
Check classes in the jar.
Coverage
An embeddable EJB container searches each bean archive in the JVM classpath that is listed in the value of the embeddable container initialization property javax.ejb.embeddable.modules, or every bean archive in the JVM classpath if the property is not specified. The bean archives might be directories, library jars or EJB jars.
Check modules specified by javax.ejb.embeddable.modules
Check libraries
Check directories
Check ejb jars
When searching for beans, the container considers any Java class in any bean archive, any ejb-jar.xml file in the metadata directory of any EJB bean archive, any Java class referenced by the @New qualifier of an injection point of another bean, and any interceptor or decorator class declared in the beans.xml file of any bean archive.
If a bean class is deployed in two different bean archives, non-portable behaviour results. Portable applications must deploy each bean class in no more than one bean archive.
If an enum declaring injection points is defined in installed library jars, non-portable behavior results.
An extension may be deployed in any archive, including those that are not bean archives.
When an application is started, the container performs the following steps.
First, the container must search for service providers for the service javax.enterprise.inject.spi.Extension defined in Section 11.5, "Container lifecycle events", instantiate a single instance of each service provider, and search the service provider class for observer methods of initialization events.
Coverage
Next, the container must fire an event of type BeforeBeanDiscovery, as defined in Section 11.5.1, "BeforeBeanDiscovery event".
Next, the container must fire an event of type ProcessModule for every bean archive, as defined in Section 11.5.5, “ProcessModule event”.
Coverage
Next, the container must perform bean discovery, and abort initialization of the application if any definition errors exist, as defined in Section 2.8, "Problems detected automatically by the container". Additionally, for every Java EE component class supporting injection that may be instantiated by the container at runtime, the container must create an InjectionTarget for the class, as defined in 11.2, "The Producer and InjectionTarget interfaces", and fire an event of type ProcessInjectionTarget, as defined in Section 11.5.6, "ProcessInjectionTarget event".
Check definitions error occurs.
Coverage
Next, the container must fire an event of type AfterBeanDiscovery, as defined in Section 11.5.2, "AfterBeanDiscovery event", and abort initialization of the application if any observer registers a definition error.
Coverage
Next, the container must detect deployment problems by validating bean dependencies and specialization and abort initialization of the application if any deployment problems exist, as defined in Section 2.8, "Problems detected automatically by the container".
Coverage
Next, the container must fire an event of type AfterDeploymentValidation, as defined in Section 11.5.3, "AfterDeploymentValidation event", and abort initialization of the application if any observer registers a deployment problem.
Coverage
Next, the container must inject any enums declaring injection points.
Coverage
Finally, the container begins directing requests to the application.
Coverage
When an application is stopped, the container performs the following steps:
First, the container must destroy all contexts.
Coverage
Next, the container must destroy dependent objects injected into enums.
Coverage
Finally, the container must fire an event of type BeforeShutdown, as defined in Section 11.5.4, "BeforeShutdown event".
Coverage
The container automatically discovers managed beans (according to the rules of Section 3.1.1, "Which Java classes are managed beans?") and session beans in bean archives and searches the bean classes for producer methods, producer fields, disposer methods and observer methods.
For each Java class or interface deployed in a bean archive, the container must create an AnnotatedType representing the type and fire an event of type ProcessAnnotatedType, as defined in Section 11.5.5, "ProcessAnnotatedType event".
Check managed bean
Coverage
Check session bean
Coverage
Check JSF managed beans
Coverage
Check servlet listener
Coverage
Check tag handler
Coverage
Check tag library listener
Coverage
Check EJB Interceptor
Coverage
Check WS endpoint
Coverage
Check servlet
Coverage
Check filter
Coverage
For each Java class in any bean archive, the container must inspect the type metadata to determine if it is a bean or other Java EE component class supporting injection.
For each Java class in any bean archive, the container must detect definition errors by validating the class and its metadata.
For each Java class in any bean archive, the container must, if the class is a managed bean, session bean, or other Java EE component class supporting injection, create an InjectionTarget for the class, as defined in Section 11.2, "The Producer and InjectionTarget interfaces", and fire an event of type ProcessInjectionTarget, as defined in Section 11.5.6, "ProcessInjectionTarget event"
Check managed bean
Coverage
Check session bean
Coverage
Check JSF managed beans
Coverage
Check servlet listener
Coverage
Check tag handler
Coverage
Check tag library listener
Coverage
Check EJB Interceptor
Coverage
Check WS endpoint
Coverage
Check servlet
Coverage
Check filter
Coverage
For each Java class in any bean archive, the container must, if the class is an enabled bean, interceptor or decorator, create a Bean object that implements the rules defined in Section 7.3.1, "Lifecycle of managed beans", Section 7.3.2, "Lifecycle of stateful session beans" or Section 7.3.3, "Lifecycle of stateless session and singleton beans", and fire an event which is a subtype of ProcessBean, as defined in Section 11.5.8, "ProcessBean event".
Check a managed bean
Coverage
Check a session bean
Coverage
For each enabled bean, the container must search the class for producer methods and fields, including resources, and for each producer method or field create a Producer, as defined in Section 11.2, "The Producer and InjectionTarget interfaces", and fire an event of type ProcessProducer, as defined in Section 11.5.7, "ProcessProducer event", and then if the producer method or field is enabled, create a Bean object that implements the rules defined in Section 7.3.4, "Lifecycle of producer methods", Section 7.3.5, "Lifecycle of producer fields" or Section 7.3.6, "Lifecycle of resources", and fire an event which is a subtype of ProcessBean, as defined in Section 11.5.8, "ProcessBean event".
For each enabled bean, the container must search the class for observer methods, and for each observer method create an ObserverMethod object, as defined in Section 11.1.3, "The ObserverMethod interface" and fire an event of type ProcessObserverMethod, as defined in Section 11.5.9, "ProcessObserverMethod event".
The container determines which alternatives, interceptors and decorators are enabled, according to the rules defined in Section 5.1.2, "Enabled and disabled beans", Section 9.4, "Interceptor enablement and ordering" and Section 8.2, "Decorator enablement and ordering", taking into account any <enable>, <interceptors> and <decorators> declarations in the beans.xml files, and registers the Bean and ObserverMethod objects.
Check only beans for enabled policies registered
Coverage
Check only enabled interceptors registered
Coverage
Check only enabled decorators registered
Coverage
For each enabled bean that is not an interceptor or decorator, the container registers an instance of the Bean interface defined in Section 11.1, "The Bean interface".
For each enabled interceptor, the container registers an instance of the Interceptor interface as defined in Section 11.1.2, "The Interceptor interface".
For each enabled decorator, the container registers an instance of the Decorator interface defined in Section 11.1.1, "The Decorator interface".
For each observer method of every enabled bean, the container registers an instance of the ObserverMethod interface defined in Section 11.1.3, "The ObserverMethod interface".
The container must provide a Unified EL ELResolver to the servlet engine and JSF implementation that resolves bean EL names using the rules of name resolution defined in 5.3, "EL name resolution" and resolving ambiguities according to Section 5.3.1, "Ambiguous EL names".
If a name used in an EL expression does not resolve to any bean, the ELResolver must return a null value.
Coverage
Otherwise, if a name used in an EL expression resolves to exactly one bean, the ELResolver must return a contextual instance of the bean, as defined in Section 6.5.2, "Contextual instance of a bean".
Coverage
The following 2 tests do not match any known assertions:
| Section | Assertion | Test Class | Test Method |
|---|---|---|---|
| 11.5.11 | c | org.jboss.cdi.tck.tests.extensions.container.event ContainerEventTest | testProcessSessionBeanFiredForStatefulSessionBean() |
| 11.5.11 | c | org.jboss.cdi.tck.tests.extensions.container.event ContainerEventTest | testProcessSessionBeanFiredForStatelessSessionBean() |
| Test Class | Test method |
|---|---|
broken (0) | |
incontainer-broken (0) | |
rewrite (6) | |
org.jboss.cdi.tck.tests.event.fires FireEventTest | testEventSelectedFiresAndObserversNotified() |
org.jboss.cdi.tck.tests.event.fires FireEventTest | testInjectedAnyEventCanFireEvent() |
org.jboss.cdi.tck.tests.event.fires FireEventTest | testInjectedEventAcceptsEventObject() |
org.jboss.cdi.tck.tests.event.fires FireEventTest | testInjectedEventCanHaveBindings() |
org.jboss.cdi.tck.tests.event.fires FireEventTest | testInjectedEventCanSpecifyBindingsDynamically() |
org.jboss.cdi.tck.tests.implementation.builtin BuiltInBeansTest | testPrincipalBean() |
jboss-as-broken (0) | |
ri-broken (0) | |