Author: shane.bryzak(a)jboss.com
Date: 2009-01-29 02:26:05 -0500 (Thu, 29 Jan 2009)
New Revision: 1279
Modified:
tck/trunk/impl/tck-audit.xml
Log:
chapter 4 assertions
Modified: tck/trunk/impl/tck-audit.xml
===================================================================
--- tck/trunk/impl/tck-audit.xml 2009-01-29 06:51:30 UTC (rev 1278)
+++ tck/trunk/impl/tck-audit.xml 2009-01-29 07:26:05 UTC (rev 1279)
@@ -1,29 +1,11 @@
<specification
xmlns="http://jboss.com/products/webbeans/tck/audit"
name="JSR-299: Java Contexts and Dependency Injection"
version="Revised Public Review Draft">
-
- <section id="3" title="Bean implementation">
- <assertion id="a">
- <text>The container provides built-in support for simple beans (Java
classes)</text>
- </assertion>
-
- <assertion id="b">
- <text>The container provides built-in support for session beans</text>
- </assertion>
-
- <assertion id="c">
- <text>The container provides built-in support for producer methods and
fields</text>
- </assertion>
-
- <assertion id="d">
- <text>The container provides built-in support for Resources (Java EE
resources, persistence contexts, persistence units, remote EJBs and web
services)</text>
- </assertion>
-
- <assertion id="e">
- <text>The container provides built-in support for JMS resources (topics and
queues)</text>
- </assertion>
+
+ <section id="3" title="Bean Implementation">
+
</section>
-
+
<section id="3.1" title="Restriction upon bean
instantiation">
<assertion id="a">
<text>The bean class is a concrete class and is not required to implement any
special interface or extend any special superclass</text>
@@ -461,7 +443,7 @@
<section id="3.3.9" title="Session bean proxies">
<assertion id="a">
- <text>EJB local object references do not implement all local interfaces of
the EJB. A local object reference may not be typecast to different local interface type,
as required by Section 2.2, �Bean types�. Therefore, the container proxies the local
object reference. A session bean proxy implements all local interfaces of the
EJB.</text>
+ <text>EJB local object references do not implement all local interfaces of
the EJB. A local object reference may not be typecast to different local interface type,
as required by Section 2.2, "Bean types". Therefore, the container proxies the
local object reference. A session bean proxy implements all local interfaces of the
EJB.</text>
</assertion>
<assertion id="b">
@@ -1022,5 +1004,301 @@
<text>An application or third party framework may add support for new kinds
of beans beyond those defined by the this specification (simple beans, session beans,
producer methods and fields, resources and JMS resources) by extending Bean and
registering beans with the container, using the mechanism defined in Section 11.3,
"Bean registration".</text>
</assertion>
</section>
+
+ <section id="4" title="Inheritance, specialization and
realization">
+
+ </section>
+
+ <section id="4.1" title="Inheritance of type-level
metadata">
+
+ <assertion id="a">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X is annotated with a binding 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.</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple 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 metaannotation and neither Y nor any
intermediate class that is a subclass of X and a superclass of Y declares a scope
type.</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X is annotated with a deployment type Z then Y inherits
the annotation if and only if Z declares the @Inherited meta-annotation and neither Y nor
any intermediate class that is a subclass of X and a superclass of Y declares a deployment
type.</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, the scope types and deployment types explicitly declared by
and inherited from the class X take precedence over default scopes and deployment types
declared by stereotypes.</text>
+ </assertion>
+
+ <assertion id="e">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X is annotated with a binding type, stereotype or interceptor
binding type Z then Y inherits the annotation if and only if Z declares the @Inherited
meta-annotation and Y does not explicitly declare an annotation of type Z using
XML.</text>
+ </assertion>
+
+ <assertion id="f">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X is annotated with a scope type Z then Y inherits the annotation
if and only if Z declares the @Inherited metaannotation and Y does not explicitly declare
a scope type using XML.</text>
+ </assertion>
+
+ <assertion id="g">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X is annotated with a deployment type Z then Y inherits the
annotation if and only if Z declares the @Inherited meta-annotation and Y does not
explicitly declare a deployment type using XML.</text>
+ </assertion>
+
+ <assertion id="h">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, the scope types and deployment types explicitly declared by and
inherited from the class X take precedence over default scope and deployment types
declared by stereotypes.</text>
+ </assertion>
+
+ <assertion id="i">
+ <text>For annotations defined by the bean specification, all built-in scope
types are declared @Inherited</text>
+ </assertion>
+
+ <assertion id="j">
+ <text>For annotations defined by the bean specification, all built-in
stereotypes are declared @Inherited</text>
+ </assertion>
+
+ <assertion id="k">
+ <text>For annotations defined by the bean specification, no built-in binding
type is declared @Inherited</text>
+ </assertion>
+
+ <assertion id="l">
+ <text>For annotations defined by the bean specification, the built-in
deployment type is not declared @Inherited</text>
+ </assertion>
+
+ <assertion id="m">
+ <text>the @Named annotation is not declared @Inherited and bean names are not
inherited unless specialization is used</text>
+ </assertion>
+
+ </section>
+
+ <section id="4.2" title="Inheritance of member-level
metadata">
+ <assertion id="a">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X declares an injected field x then Y inherits
x.</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X declares an initializer method, @PostConstruct method
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()</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple 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().</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X declares a non-static producer, disposal, or observer
method x() then Y does not inherit this method unless Y is explicitly declared to
specialize or realize X</text>
+ </assertion>
+
+ <assertion id="e">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if X declares a non-static producer field x then Y does not
inherit this field unless Y is explicitly declared to specialize or realize
X.</text>
+ </assertion>
+
+ <assertion id="f">
+ <text>For class X which is extended directly or indirectly by the bean class
of a simple or session bean Y, if Y is a decorator and X declares a delegate attribute x
then Y inherits x if and only if neither Y nor any intermediate class that is a subclass
of X and a superclass of Y defines a delegate attribute</text>
+ </assertion>
+
+ <assertion id="g">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X declares an injected field x then Y inherits x, unless Y
explicitly declares x using XML.</text>
+ </assertion>
+
+ <assertion id="h">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X declares an initializer method, @PostConstruct method or
@PreDestroy method x() then Y inherits x(), unless Y explicitly declares x() using
XML</text>
+ </assertion>
+
+ <assertion id="i">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X declares a non-static method x() annotated with an interceptor
binding type Z then Y inherits the binding, unless Y explicitly declares x() using
XML.</text>
+ </assertion>
+
+ <assertion id="j">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X declares a non-static producer, disposal, or observer method x()
then Y does not inherit this method, unless Y is explicitly declared to specialize or
realize X.</text>
+ </assertion>
+
+ <assertion id="k">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if X declares a non-static producer field x then Y does not inherit
this method, unless Y is explicitly declared to specialize or realize X.</text>
+ </assertion>
+
+ <assertion id="l">
+ <text>For class X which is the bean class of a simple or session bean Y
declared using XML, if Y is a decorator and X declares a delegate attribute x then Y
inherits x, unless Y explicitly declares a delegate attribute using XML.</text>
+ </assertion>
+ </section>
+
+ <section id="4.3" title="Specialization">
+
+ <assertion id="a">
+ <text>If two beans both support a certain bean type, and share at least one
binding, then they are both eligible for injection to any injection point with that
declared type and binding. The container will choose the bean with the highest priority
enabled deployment type.</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>If the bean with the lower priority deployment type declares a binding
that is not declared by the bean with the higher priority deployment type, then the bean
with the higher priority deployment type will not be eligible for injection to an
injection point with that binding.</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>The only way one bean can completely override a lower-priority bean at
all injection points is if it implements all the bean types and declares all the bindings
of the lower-priority bean. However, if the lower-priority bean declares a producer
method, then even this is not enough to ensure that the lower-priority bean is never
called</text>
+ </assertion>
+
+ </section>
+
+ <section id="4.3.1" title="Using specialization">
+
+ <assertion id="a">
+ <text>A bean declared using annotations may declare that it specializes a
lower-priority bean using the @Specializes annotation</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>A bean declared using XML may declare that it specializes a
lower-priority bean using the <Specializes> element</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>The bindings of a bean X that specializes a lower-priority bean Y
include all bindings of Y, together with all bindings declared explicitly by
X.</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>If a bean X specializes a lower-priority bean Y with a name, the name
of X is the same as the name of Y. If X declares a name explicitly, a DefinitionException
is thrown by the container at deployment time</text>
+ </assertion>
+
+ <assertion id="e">
+ <text>When an enabled bean specializes a lower-priority bean, we can be
certain that the lower-priority bean is never instantiated or called by the container.
Even if the lower-priority bean defines a producer method, the method will be called upon
an instance of the first bean</text>
+ </assertion>
+
+ <assertion id="f">
+ <text>Specialization applies only to simple beans, as defined in Section
3.2.7, "Specializing a simple bean", session beans, as defined in Section 3.3.7,
"Specializing a session bean" and producer methods, as defined in Section 3.4.5,
"Specializing a producer method".</text>
+ </assertion>
+ </section>
+
+ <section id="4.3.2" title="Direct and indirect
specialization">
+ <assertion id="a">
+ <text>The @javax.inject.Specializes annotation or <Specializes>
XML element is used to indicate that one bean directly specializes another
bean</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>A bean X is said to specialize another bean Y if X directly specializes
Y, or a bean Z exists, such that X directly specializes Z and Z specializes
Y</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>Any non-static producer methods (see Section 3.4, "Producer
methods"), producer fields (see Section 3.5, "Producer fields"), disposal
methods (see Section 3.4.6, "Disposal methods") or observer methods (see Section
7.5, "Observer methods") of any bean are invoked upon an instance of the most
specialized enabled bean that specializes the bean, as defined by Section 6.7,
"Lifecycle of producer methods", Section 6.8, "Lifecycle of producer
fields" and Section 7.4, "Observer notification".</text>
+ </assertion>
+ </section>
+
+ <section id="4.3.3" title="Inconsistent specialization">
+ <assertion id="a">
+ <text>If, in a particular deployment, either some enabled bean X specializes
another enabled bean Y and X does not have a higher precedence than Y, or more than one
enabled bean directly specializes the same bean we say that inconsistent specialization
exists, and an InconsistentSpecializationException is thrown by the container at
deployment time</text>
+ </assertion>
+ </section>
+
+ <section id="4.4" title="Realization">
+ <assertion id="a">
+ <text>Any bean that extends a generic class may directly extend the generic
class, in the case of a bean declared using annotations</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>Any bean that extends a generic class may declare that the generic
class is the bean class, in the case of a bean declared using XML, and then explicitly
declare that it realizes the generic class.</text>
+ </assertion>
+
+ </section>
+
+ <section id="4.4.1" title="Using realization">
+ <assertion id="a">
+ <text>A bean declared using annotations may declare that it realizes a
generic class by annotating the bean class with the @javax.inject.Realizes
annotation</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>A bean declared using XML may declare that it realizes a generic class
using the <Realizes> element.</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>If a generic class Y declares a non-static producer method or field
with a certain combination of scope, stereotypes, bindings and interceptor bindings, then
every bean X that realizes Y also has a producer method or field with the same scope,
stereotypes and interceptor bindings. The bindings for this inherited producer method or
field consist of all bindings declared by the producer method or field of Y, excluding all
bindings of Y, together with the bindings declared explicitly by X. The deployment type of
the inherited producer method or field is the deployment type of X</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>If a generic class Y declares a non-static disposal method with a
disposed parameter with a certain combination of bindings, then every bean X that realizes
Y also has a disposal method. The bindings of the disposed parameter of this
+inherited disposal method consist of all bindings declared by the disposed parameter of
the disposal method of Y, excluding all bindings of Y, together with the bindings declared
explicitly by X.</text>
+ </assertion>
+
+ <assertion id="e">
+ <text>If a generic class Y declares a non-static observer method with an
event parameter with a certain combination of event bindings, then every bean X that
realizes Y also has an observer method. The event bindings of the event parameter of
+this inherited observer method consist of all event bindings declared by the event
parameter of the observer method of Y.</text>
+ </assertion>
+
+ <assertion id="f">
+ <text>Realization applies only to simple beans and session
beans</text>
+ </assertion>
+ </section>
+
+ <section id="5" title="Lookup, dependency injection and EL
resolution">
+ <assertion id="a">
+ <text>The container is required to ensure that any injected reference to a
contextual instance of a bean may be cast to any bean type of the bean.</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>The container is required to support circularities in the bean
dependency graph</text>
+ </assertion>
+ </section>
+
+ <section id="5.1" title="Unsatisfied and ambiguous
dependencies">
+ <assertion id="a">
+ <text>The container must validate all injection points of all enabled beans
at deployment time to ensure that there are no unsatisfied or ambiguous dependencies. If
an unsatisfied or ambiguous dependency exists, an UnsatisfiedDependencyException
+or AmbiguousDependencyException is thrown by the container at deployment time, as defined
in Section 5.7.1, "Resolving dependencies".</text>
+ </assertion>
+ </section>
+
+ <section id="5.2" title="Primitive types and null values">
+ <assertion id="a">
+ <text>If an injection point of primitive type resolves to a bean that may be
null, such as a producer method with a nonprimitive return type or a producer field with a
non-primitive type, a NullableDependencyException is thrown by the container at deployment
time</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>The method Bean.isNullable() may be used to detect if a bean has null
values</text>
+ </assertion>
+ </section>
+
+ <section id="5.3" title="Injected reference validity">
+ <assertion id="a">
+ <text>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</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>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</text>
+ </assertion>
+ </section>
+
+ <section id="5.4" title="Client proxies">
+
+ </section>
+
+ <section id="5.4.1" title="Unproxyable bean types">
+
+ </section>
+
+ <section id="5.4.2" title="Client proxy invocation">
+
+ </section>
+
+ <section id="5.5" title="The default binding at injection
points">
+
+ </section>
+
+ <section id="5.6" title="Injection point metadata">
+
+ </section>
+
+ <section id="5.6.1" title="Injecting InjectionPoint">
+
+ </section>
+
+ <section id="5.7" title="The Manager object">
+
+ </section>
+
+ <section id="5.7.1" title="Resolving dependencies">
+
+ </section>
+
+ <section id="5.7.2" title="Obtaining contextual instances">
+
+ </section>
+
+ <section id="5.8" title="Dynamic lookup">
+
+ </section>
+
+ <section id="5.9" title="Typesafe resolution algorithm">
+
+ </section>
+
+
+
</specification>