JSR 365: Contexts and Dependency Injection for Java 2.0 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 name.

A bean comprises of a set of interceptor bindings.

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.

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

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.

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

Note that to ensure compatibility with other JSR-330 implementations, all pseudo-scope annotations except @Dependent are not bean defining annotations.

However, a stereotype annotation including a pseudo-scope annotation is a bean defining annotation.

A valid bean name is a period-separated list of valid EL identifiers

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.

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

A stereotype may specify that all beans with the stereotype have defaulted bean 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.

A @Named qualifier declared by a stereotype is not added to the qualifiers of a bean with the stereotype.

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 a definition error exists, the container must throw a subclass of javax.enterprise.inject.spi.DefinitionException.

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.

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 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 implements javax.enterprise.inject.spi.Extension.

A top-level Java class is not a managed bean if it is annotated @Vetoed or placed in a package annotated @Vetoed.

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 producer method must be a default-access, public, protected or private, non-abstract method of a managed bean class.

A producer method may be static.

A producer method may be non-static.

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 an array type whose component 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.

If a producer method return type is an array type whose component 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.

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 default-access, public, protected or private, field of a managed bean class~

A producer field may be static.

A producer field may be non-static.

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

If a producer field 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 a producer field type is an array type whose component type contains a wildcard 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.

If a producer field type is an array type whose component 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.

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 default-access, public, protected or private, non-abstract method of a managed bean class.

A disposer method may be static.

A disposer method may be non-static.

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

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.

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.

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.

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.

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

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 managed bean, a second bean exists which has the same interceptor bindings.

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.