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.

A stereotype may declare one 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 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 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 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.

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

When searching for disposer methods for a producer method, the container considers the type and qualifiers of the disposed parameter. If a disposed parameter resolves to a producer method declared by the same bean class, according to the rules of typesafe resolution defined in Section 5.2 "Typesafe resolution", the container must call this method when destroying an instance returned by that producer method.

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.

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

If there is no producer method declared by the bean class that is assignable to the disposed parameter of a dispose method, the container automatically detects the problem and treats it as a definition error.

The default name for a producer method is the method name, unless the method follows the JavaBeans property getter naming convention, in which case the default name is the JavaBeans property name

A producer field must be a field of a 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 a producer field type contains a wildcard type parameter 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.

The default name for a producer field is the field name

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.ValidationFactory, allowing injection of the default Bean Validation ValidationFactory.

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

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 the bean is a session bean, the initializer method is not required to be a business method of the session bean.

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

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

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.

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

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.

When an enabled bean specializes a second bean, we can be certain that the second bean is never instantiated or called by the container.

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.

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()

The container must validate all injection points of all enabled beans and of 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.

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.

If an injection point of primitive type resolves to a bean that may have null values, such as a producer method with a nonprimitive return type or a producer field with a non-primitive type, the container automatically detects the problem and treats it as a deployment problem.

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.

An annotation member may be excluded from consideration using the @NonBinding annotation.

A bean class may declare multiple qualifiers.

A producer method may declare multiple qualifiers.

A producer field may declare multiple qualifiers.

A bean must declare all of the qualifiers that are specified at the injection point to be considered a candidate for injection.

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.

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.

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.

Client proxies are serializable

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.

Classes which don't have a non-private constructor with no parameters cannot be proxied by the container. If an injection point whose declared type cannot be proxied by the container resolves to a bean with a normal scope, the container automatically detects the problem and treats it as a deployment problem.

Primitive types cannot be proxied by the container. If an injection point whose declared type cannot be proxied by the container resolves to a bean with a normal scope, the container automatically detects the problem and treats it as a deployment problem.

Array types cannot be proxied by the container. If an injection point whose declared type cannot be proxied by the container resolves to a bean with a normal scope, the container automatically detects the problem and treats it as a deployment problem.

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.

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 container is required to perform dependency injection whenever it creates a contextual instance of a session bean.

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

The container is required to perform dependency injection whenever it instantiates non-contextual instances of managed beans.