JSR-299: Contexts and Dependency Injection for Java Enterprise Edition TCK Coverage

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 an optional bean EL name.

A bean comprises of a bean implementation.

A bean may have multiple bean types.

All beans have the bean type java.lang.Object.

A bean type may be an interface.

A bean type may be a concrete class.

A bean type may be an abstract class.

A bean type may be declared final.

A bean type may have final methods.

A bean type may be a parameterized type with actual type parameters.

A bean type may be a parameterized type with type variables.

A bean type may be an array type. Two array types are considered identical only if the element type is identical.

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.

A type variable is not a legal bean type.

A parameterized type that contains a wildcard type parameter is not a legal bean type.

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.

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.

The default qualifier is also assumed for any injection point that does not explicitly declare a qualifier.

A qualifier type may be declared by specifying the @javax.inject.Qualifier meta-annotation.

Any bean may declare multiple qualifier types.

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".

A bean may only be injected to an injection point if it has all the qualifiers of the injection point.

All beans have a scope.

The set of scope types is extensible.

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.

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.

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.

There are five standard scope types defined by this specification, all defined in the package javax.enterprise.context. The @ConversationScoped annotation represents the conversation scope defined in Section 6.7.4, "Conversation context lifecycle".

There are five standard scope types defined by this specification, all defined in the package javax.enterprise.context. The @Dependent pseudo-scope is for dependent objects, as defined in Section 6.4, "Dependent pseudo-scope"

A scope type is a Java annotation defined as @Target({TYPE, METHOD, FIELD}) and @Retention(RUNTIME).

All scope types must specify the @javax.inject.Scope or @javax.enterprise.context.NormalScope meta-annotation.

The scope of a bean is defined by annotating the bean class or producer method or field with a scope type.

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.

A scope type may be specified using a stereotype annotation, as defined in Section 2.7.2, "Declaring the stereotypes for a bean"

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.

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

If the @Named annotation does not specify the value member, the EL name is defaulted.

A default EL 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 EL name.

If @Named is not declared by the bean, nor by its stereotypes, a bean has no EL name.

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.

A stereotype may specify that all beans with the stereotype have defaulted bean EL names.

A stereotype may specify that all beans with the stereotype are alternatives.

A stereotype may be declared by specifying the @javax.enterprise.inject.Stereotype meta-annotation.

The interceptor bindings of a stereotype are defined by annotating the stereotype with the interceptor binding types.

A stereotype may declare zero interceptor bindings.

A stereotype may declare one interceptor bindings.

A stereotype may declare multiple interceptor bindings.

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.

If a stereotype declares a non-empty @Named annotation, the container automatically detects the problem and treats it as a definition error.

A stereotype may declare an @Alternative annotation, which specifies that every bean with the stereotype is an alternative.

A stereotype may declare other stereotypes.

Stereotype declarations are transitive - a stereotype declared by a second stereotype is inherited by all beans and other stereotypes that declare the second stereotype.

The default scope declared by the stereotype may be overridden by the bean.

Multiple stereotypes may be applied to the same bean.

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 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.

If a managed bean has a public field, it must have scope @Dependent.

If a managed bean with a public field declares any scope other than @Dependent, the container automatically detects the problem and treats it as a definition error.

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.

A top-level Java class is not a managed bean if it is a non-static inner class.

A top-level Java class that is a static inner class can be a managed bean.

A top-level Java class is not a managed bean if it is an abstract class, unless it is annotated @Decorator.

A top-level Java class is not a managed bean if it is an interface, unless it is annotated @Decorator.

A top-level Java class is not a managed bean if it is annotated with any of the EJB component-defining annotations

A top-level Java class is not a managed bean if it implements javax.enterprise.inject.spi.Extension.

A top-level Java class is not a managed bean if it is declared as an EJB bean class in ejb-jar.xml

A top-level Java class is only a managed bean if it has an appropriate constructor - a constructor with no parameters.

A top-level Java class is only a managed bean if it has an appropriate constructor - a constructor annotated @Inject.

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

A managed bean may extend another managed bean.

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 stateless session bean must belong to the @Dependent pseudo-scope

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.

A stateful session bean may have any scope.

If the bean class of a session bean is annotated @Interceptor, the container automatically detects the problem and treats it as a definition error.

If the bean class of a session bean is annotated @Decorator, the container automatically detects the problem and treats it as a definition error.

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.

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.

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

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.

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"

The unrestricted set of bean types for a session bean contains all local interfaces of the bean and their superinterfaces.

If the session bean has a bean class local view, the set of bean types contains the bean class and all superclasses.

java.lang.Object is a bean type of every session bean

Remote interfaces are not included in the set of bean types

A session bean does not require any special annotations apart from the component-defining annotation (or XML declaration) required by the EJB specification.

A session bean class may extend another bean class.

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".

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.

The default name for a managed bean is the unqualified class name of the session bean class, after converting the first character to lower case.

A producer method must be a non-abstract method of a managed bean class or session bean class.

A producer method may be static.

A producer method may be non-static.

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

If a producer method sometimes returns a null value, then the producer method must have scope @Dependent.

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".

If the producer method return type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter.

If a producer method return type contains a wildcard type parameter the container automatically detects the problem and treats it as a definition error.

If the producer method return type is a parameterized type with a type variable, it must have scope @Dependent.

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.

If a producer method return type is a type variable the container automatically detects the problem and treats it as a definition error.

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.

A bean may declare multiple producer methods.

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

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.

A producer method may be declared by annotating a method with the @javax.enterprise.inject.Produces annotation

A producer method may specify a scope.

A producer method may specify a name.

A producer method may specify stereotypes.

A producer method may specify qualifiers.

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.

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.

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.

A producer method may have any number of parameters.

All producer method parameters are injection points.

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".

If a producer method is static, the container automatically detects the problem and treats it as a definition error.

If a producer method does not directly override another producer method, the container automatically detects the problem and treats it as a definition error.

A producer field must be a field of a managed bean class or session bean class

A producer field must be a field of a managed bean class or session bean class

A producer field may be static.

A producer field may be non-static.

If the bean is a session bean, the producer field must be a static field of the bean class.

If a producer field sometimes contains a null value when accessed, then the producer field must have scope @Dependent

If a producer method contains a null value at runtime, and the producer field declares any other scope, an IllegalProductException is thrown by the container. This restriction allows the container to use a client proxy, as defined in Section 5.4, "Client proxies"

If the producer field type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter

If the producer field type is a parameterized type, it must specify an actual type parameter or type variable for each type parameter

If a producer field type contains a wildcard type parameter the container automatically detects the problem and treats it as a definition error.

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.

If a producer field type is a type variable the container automatically detects the problem and treats it as a definition error.

A bean may declare multiple producer fields

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.

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

A producer field may be declared by annotating a field with the @javax.enterprise.inject.Produces annotation.

A producer field may specify a scope.

A producer field may specify a name.

A producer field may specify stereotypes.

A producer field may specify qualifiers.

If a producer field is annotated @Inject, the container automatically detects the problem and treats it as a definition error.

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.

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.

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.

The default name for a producer field is the field name

A disposer method must be a non-abstract method of a managed bean class or session bean class.

A disposer method may be static.

A disposer method may be non-static.

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.

A bean may declare multiple disposer methods.

Each disposer method must have exactly one disposed parameter, of the same type as the corresponding producer method return type or producer field type.

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.

A disposer method may be declared by annotating a parameter @javax.enterprise.inject.Disposes. That parameter is the disposed parameter

Qualifiers may be declared by annotating the disposed parameter.

If a method has more than one parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.

If a disposer method is annotated @Produces, the container automatically detects the problem and treats it as a definition error.

If a disposer method is annotated @Inject, the container automatically detects the problem and treats it as a definition error.

If a disposer method has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.

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.

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.

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.

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".

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".

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.

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.

For a Java EE resource, @Resource must be specified.

For a persistence context, @PersistenceContext must be specified.

For a persistence unit, @PersistenceUnit must be specified.

For a remote EJB, @EJB must be specified.

The bean type and qualifiers of the resource are determined by the producer field declaration.

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.

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 Java EE or embeddable EJB container must provide a bean with qualifier @Default and bean type javax.validation.ValidatorFactory, allowing injection of the default Bean Validation ValidatorFactory.

A Java EE or embeddable EJB container must provide a bean with qualifier @Default and bean type javax.validation.Validator, allowing injection of a Validator for the default Bean Validation ValidatorFactory.

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".

When the container instantiates a bean, it calls the bean constructor. The bean constructor is a constructor of the bean class

If a bean class does not explicitly declare a constructor using @Inject, the constructor that accepts no parameters is the bean constructor.

If a bean class has more than one constructor annotated @Inject, the container automatically detects the problem and treats it as a definition error.

If a bean constructor has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.

If a bean constructor has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.

A bean constructor may have any number of parameters.

All parameters of a bean constructor are injection points.

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.

If the bean is a session bean, the initializer method is not required to be a business method of the session bean.

Method interceptors are never called when the container calls an initializer method

A bean class may declare multiple (or zero) initializer methods

An initializer method may be declared by annotating the method @javax.inject.Inject

If a generic method of a bean is annotated @Inject, the container automatically detects the problem and treats it as a definition error.

If an initializer method is annotated @Produces, the container automatically detects the problem and treats it as a definition error.

If an initializer method has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.

If an initializer method has a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.

An initializer method may have any number of parameters.

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.

Any class or package may be prevented from providing bean definitions by adding the @Veto annotation on the class or package.

Any class or package may be prevented from providing bean definitions based on the availability of other classes by adding the @Requires annotation on the class or package.

If an injected field declares a @Named annotation that does not specify the value member, the name of the field is assumed.

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.

For each managed bean, a second bean exists which has the same bean class.

For each managed bean, a second bean exists which has the same bean constructor.

For each managed bean, a second bean exists which has the same initializer methods.

For each managed bean, a second bean exists which has the same injected fields.

For each session bean, a second bean exists which has the same bean class.

For each session bean, a second bean exists which has the same bean types.

For each session bean, a second bean exists which has the same bean constructor.

For each session bean, a second bean exists which has the same initializer methods.

This second bean has scope @Dependent.

This second bean has no stereotypes.

This second bean has no observer methods.

This second bean has no producer methods.

This second bean has no producer fields.

This second bean has no disposer methods.

This second bean is not an alternative.

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.

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.

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.

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.

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.

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.

A bean X is said to specialize another bean Y if X directly specializes Y.

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.

A bean X that specializes bean Y will include all qualifiers of Y, together with all qualifiers declared explicitly by X.

A bean X that specializes bean Y will have the same name as Y if Y has a name.

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.

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".

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.

By default, a bean deployment archive has no selected alternatives. An alternative must be explicitly declared using the <alternatives> element of the beans.xml file of the bean deployment archive.

An alternative is selected for the bean deployment archive if any @Alternative stereotype of the alternative is listed.

Each child <class> element must specify the name of a alternative bean class. If there is no class with the specified name, or if the class with the specified name is not an alternative bean class, the container automatically detects the problem and treats it as a deployment problem.

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.

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.

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.

Check multiple types resolve to a single getBeans()

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.

The required type of an injection point may contain a wildcard type parameter. However, a type variable is not a legal injection point type.

If an injection point type is a type variable, the container automatically detects the problem and treats it as a definition error.