4:55 p.m.
Author: shane.bryzak(a)jboss.com
Date: 2009-01-27 17:55:53 -0500 (Tue, 27 Jan 2009)
New Revision: 1254
Modified:
tck/trunk/impl/tck-audit.xml
tck/trunk/impl/tck-audit.xsd
Log:
renamed code attribute to id
Modified: tck/trunk/impl/tck-audit.xml
===================================================================
--- tck/trunk/impl/tck-audit.xml 2009-01-27 22:05:24 UTC (rev 1253)
+++ tck/trunk/impl/tck-audit.xml 2009-01-27 22:55:53 UTC (rev 1254)
@@ -3,223 +3,223 @@
version="Revised Public Review Draft">
<section id="3" title="Bean implementation">
- <assertion code="a">
+ <assertion id="a">
<text>The container provides built-in support for simple beans (Java
classes)</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The container provides built-in support for session beans</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>The container provides built-in support for producer methods and
fields</text>
</assertion>
- <assertion code="d">
+ <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 code="e">
+ <assertion id="e">
<text>The container provides built-in support for JMS resources (topics and
queues)</text>
</assertion>
</section>
<section id="3.1" title="Restriction upon bean
instantiation">
- <assertion code="a">
+ <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>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If the application calls a producer method directly, instead of letting
the container call it, the returned object is not a contextual instance and the
capabilities listed in Section 2.1, "Functionality provided by the container to the
bean" will not be available to the returned object.</text>
</assertion>
</section>
<section id="3.2" title="Simple beans">
- <assertion code="a">
+ <assertion id="a">
<text>The bean class of a simple bean may not be a non-static inner class or
a parameterized type</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The bean class of a simple bean may not be an abstract class, unless
the simple bean is a decorator</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a simple bean is annotated with both the
@Interceptor and @Decorator stereotypes, a DefinitionException is thrown by the container
at deployment time.</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>Multiple simple beans may share the same bean class. This occurs when
beans are defined using XML. Only one simple bean per bean class may be defined using
annotations.</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>If a simple bean has a public field, it must have scope @Dependent. If
a simple bean with a public field declares any scope other than @Dependent, a
DefinitionException is thrown by the container at deployment time.</text>
</assertion>
</section>
<section id="3.2.1" title="Which Java classes are beans?">
- <assertion code="a">
+ <assertion id="a">
<text>A top-level Java class is not a simple bean if it is a parameterized
type</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A top-level Java class is not a simple bean if it is a non-static inner
class</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A top-level Java class is only a simple bean if it is a concrete class,
or annotated @Decorator.</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>A top-level Java class is not a simple bean if it is annotated with the
JPA @Entity annotation</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>A top-level Java class is not a simple bean if it is annotated with any
of the EJB component-defining annotations</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>A top-level Java class is not a simple bean if it implements the
javax.servlet.Servlet interface</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>A top-level Java class is not a simple bean if it implements the
javax.servlet.Filter interface</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>A top-level Java class is not a simple bean if it implements the
javax.servlet.ServletContextListener interface</text>
</assertion>
- <assertion code="i">
+ <assertion id="i">
<text>A top-level Java class is not a simple bean if it implements the
javax.servlet.http.HttpSessionListener interface</text>
</assertion>
- <assertion code="j">
+ <assertion id="j">
<text>A top-level Java class is not a simple bean if it implements the
javax.servlet.ServletRequestListener interface</text>
</assertion>
- <assertion code="k">
+ <assertion id="k">
<text>A top-level Java class is not a simple bean if it implements the
javax.ejb.EnterpriseBean interface</text>
</assertion>
- <assertion code="l">
+ <assertion id="l">
<text>A top-level Java class is not a simple bean if it extends
javax.faces.component.UIComponent</text>
</assertion>
- <assertion code="m">
+ <assertion id="m">
<text>A top-level Java class is not a simple bean if it is declared as an EJB
bean class in ejb-jar.xml</text>
</assertion>
- <assertion code="n">
+ <assertion id="n">
<text>A top-level Java class is not a simple bean if it is declared as a JPA
entity in orm.xml</text>
</assertion>
- <assertion code="o">
+ <assertion id="o">
<text>A top-level Java class is only a simple bean if it has an appropriate
constructor - either a constructor with no parameters, or declares a constructor annotated
@Initializer</text>
</assertion>
- <assertion code="p">
+ <assertion id="p">
<text>Additional simple beans with the same bean class may be defined using
XML, by specifying the class in beans.xml.</text>
</assertion>
</section>
<section id="3.2.2" title="Bean types of a simple bean">
- <assertion code="a">
+ <assertion id="a">
<text>The set of bean types for a simple bean contains the bean class, every
superclass and all interfaces it implements directly or indirectly.</text>
</assertion>
</section>
<section id="3.2.3" title="Declaring a simple bean using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>A simple bean with a constructor that takes no parameters does not
require any special annotations</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A bean class may also specify a scope, name, deployment type,
stereotypes and/or bindings</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A simple bean may extend another simple bean</text>
</assertion>
</section>
<section id="3.2.4" title="Declaring a simple bean using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>Simple beans may be declared in beans.xml using the bean class
name</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A simple bean may even be declared at any injection point declared in
XML, as defined in Section 9.9, "Inline bean declarations", in which case no
bindings are specified.</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a simple bean defined in XML is a parameterized
type or a non-static inner class, a DefinitionException is thrown by the container at
deployment time.</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If the bean class of a simple bean defined in XML is an abstract class,
and the simple bean is not a decorator, a DefinitionException
is thrown by the container at deployment time</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>If the bean class of a simple bean defined in XML is annotated
@Interceptor, then the bean must be explicitly declared as an interceptor in XML, as
defined in Section A.3.5.2, "Declaring an interceptor using XML". If a simple
bean defined in XML has a bean class annotated @Interceptor and is not declared as an
interceptor in XML, a DefinitionException is
thrown by the container at deployment time.</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>If the bean class of a simple bean defined in XML is annotated
@Interceptor, then the bean must be explicitly declared as an interceptor in XML, as
defined in Section A.3.5.2, "Declaring an interceptor using XML". If a simple
bean defined in XML has a bean class annotated @Interceptor and is not declared as an
interceptor in XML, a DefinitionException is
thrown by the container at deployment time.</text>
</assertion>
</section>
<section id="3.2.5" title="Simple beans with the @New
binding">
- <assertion code="a">
+ <assertion id="a">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has the same
bean class</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has the same
bean constructor, initializer methods and injected fields defined by
annotations</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has the same
interceptor bindings defined by annotations</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has scope
@Dependent</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has deployment
type @Standard</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has
@javax.inject.New as the only binding</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has no bean
name</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has no
stereotypes</text>
</assertion>
- <assertion code="i">
+ <assertion id="i">
<text>Every class that satisfies the requirements of Section 3.2.1,
"Which Java classes are beans?" is a bean, with scope, deployment type and
bindings defined using annotations.
Additionally, for each such simple bean, a second simple bean exists which has no
observer methods, producer methods or fields or disposal methods</text>
</assertion>
</section>
<section id="3.2.6" title="Bean constructors">
- <assertion code="a">
+ <assertion id="a">
<text>When the container instantiates a simple bean, it calls the bean
constructor. The bean constructor is a constructor of the bean class</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The application may call bean constructors directly. However, if the
application directly instantiates the bean, no parameters are passed to the constructor by
the container; the returned object is not bound to any context; no dependencies are
injected by the container; and the lifecycle of the new instance is not managed by the
container</text>
</assertion>
</section>
<section id="3.2.6.1" title="Declaring a bean constructor using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>The bean constructor may be identified by annotating the constructor
@Initializer</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If a simple bean defined using annotations does not explicitly declare
a constructor using @Initializer, the constructor that accepts no parameters is the bean
constructor</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If a simple bean defined using annotations has more than one
constructor annotated @Initializer, a DefinitionException is thrown by the container at
deployment time</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a bean constructor has a parameter annotated @Disposes, or
@Observes, a DefinitionException is thrown by the container at deployment
time</text>
</assertion>
@@ -227,206 +227,206 @@
<section id="3.2.6.2" title="Declaring a bean constructor using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For a simple bean defined using XML, the bean constructor may be
specified by listing the parameter types of the constructer, in order, as direct children
of the element that declares the bean</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If a simple bean defined using XML does not explicitly declare
constructor parameters in XML, the constructor that accepts no parameters is the bean
constructor</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If a simple bean declared in XML does not have a constructor with the
parameter types declared in XML, a DefinitionException is thrown by the container at
deployment time</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>When a bean constructor is declared in XML, the container ignores
binding annotations applied to Java constructor parameters</text>
</assertion>
</section>
<section id="3.2.6.3" title="Bean constructor parameters">
- <assertion code="a">
+ <assertion id="a">
<text>If the bean constructor has parameters, the container calls the method
Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies"
to determine a value for each parameter and calls the constructor with those parameter
values.</text>
</assertion>
</section>
<section id="3.2.7" title="Specializing a simple bean">
- <assertion code="a">
+ <assertion id="a">
<text>If a bean class of a simple bean X defined using annotations is
annotated @Specializes, then the bean class of X must directly extend the bean class of
another simple bean Y defined using annotations. Then X inherits all bindings of Y, and if
Y has a name, X has the same name as Y.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>We say that X directly specializes Y, and we can be certain that Y will
never be instantiated or called by the container if X is enabled.</text>
<note>This assertion relates to specialized beans declared using
annotations</note>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of X does not directly extend the bean class of
another simple bean, a DefinitionException is thrown by the container at deployment
time.</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a simple bean X defined in XML declares the
<Specializes> element, then the bean class of X must be the bean class of
another simple bean Y defined using annotations. Then X inherits all bindings of Y, and if
Y has a name, X has the same name as Y</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>We say that X directly specializes Y, and we can be certain that Y will
never be instantiated or called by the container if X is enabled</text>
<note>This assertion relates to specialized beans declared in
XML</note>
</assertion>
</section>
<section id="3.2.8" title="Default name for a simple bean">
- <assertion code="a">
+ <assertion id="a">
<text>The default name for a simple bean is the unqualified class name of the
bean class, after converting the first character to lower case</text>
</assertion>
</section>
<section id="3.3" title="Session beans">
- <assertion code="a">
+ <assertion id="a">
<text>A session bean is a bean that is implemented by an EJB 3-style session
bean</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A stateless session bean must belong to the @Dependent
pseudo-scope</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A singleton bean must belong to either the @ApplicationScoped scope or
to the @Dependent pseudo-scope</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a session bean specifies an illegal scope, a DefinitionException is
thrown by the container at deployment time</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>Note that multiple session beans may share the same bean class. This
occurs when beans are defined using XML</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>If the bean class of a session bean is annotated @Interceptor or
@Decorator, a DefinitionException is thrown by the container at deployment
time</text>
</assertion>
</section>
<section id="3.3.1" title="EJB remove methods of session
beans">
- <assertion code="a">
+ <assertion id="a">
<text>If a session bean is a stateful session bean, and the scope is
@Dependent, the application may call any EJB remove method of an instance of the session
bean.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>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</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the application directly calls an EJB remove method of an instance
of a session bean that is a stateful session bean and declares any scope other than
@Dependent, an UnsupportedOperationException is thrown</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If the application directly calls an EJB remove method of an 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. Furthermore, the container ignores
the instance instead of destroying it when Bean.destroy() is called, as defined in Section
6.5, "Lifecycle of stateful session beans"</text>
</assertion>
</section>
<section id="3.3.2" title="Which EJBs are beans?">
- <assertion code="a">
+ <assertion id="a">
<text>All session beans exposing an EJB 3.x client view and declared via an
EJB component defining annotation on the EJB bean class are beans, and thus no special
declaration is required. Additional beans for these EJBs may be defined using XML, by
specifying the bean class in beans.xml</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>All session beans exposing an EJB 3.x client view and declared in
ejb-jar.xml are also beans. Additional beans for these EJBs may be defined using XML, by
specifying the bean class and EJB name in beans.xml</text>
</assertion>
</section>
<section id="3.3.3" title="Bean types of a session bean">
- <assertion code="a">
+ <assertion id="a">
<text>The set of bean types for a session bean contains all local interfaces
of the bean that do not have wildcard type parameters or type variables and their
superinterfaces.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If the EJB has a bean class local view and the bean class is not a
parameterized
type, the set of bean types contains the bean class and all superclasses.</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>java.lang.Object is a bean type of every session bean</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>Remote interfaces are not included in the set of bean
types</text>
</assertion>
</section>
<section id="3.3.4" title="Declaring a session bean using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>A session bean does not require any special annotations</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A bean class may also specify a scope, name, deployment type,
stereotypes and/or bindings</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A session bean class may extend another bean class</text>
</assertion>
</section>
<section id="3.3.5" title="Declaring a session bean using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>Session beans may be declared in beans.xml using the bean class name
(for EJBs defined using a component-defining annotation) or bean class and EJB name (for
EJBs defined in ejb-jar.xml)</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The ejbName attribute declares the EJB name of an EJB defined in
ejb-jar.xml</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If an entity or message-driven bean class is declared in XML, a
DefinitionException is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="3.3.6" title="Session beans with the @New
binding">
- <assertion code="a">
+ <assertion id="a">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has the same bean
class</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has the initializer
methods and injected fields defined by annotations</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has the same
interceptor bindings defined by annotations</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has scope
@Dependent,</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has deployment type
@Standard</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has
@javax.inject.New as the only binding</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has no bean
name</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has no
stereotypes</text>
</assertion>
- <assertion code="i">
+ <assertion id="i">
<text>Every EJB that satisfies the requirements of Section 3.3.2, "Which
EJBs are beans?" is a bean, with scope, deployment type and bindings defined using
annotations.
Additionally, for each such session bean, a second bean exists which has no observer
methods, producer methods or fields or disposal methods</text>
</assertion>
@@ -434,387 +434,387 @@
<section id="3.3.7" title="Specializing a session bean">
- <assertion code="a">
+ <assertion id="a">
<text>If a bean class of a session bean X defined using annotations is
annotated @Specializes, then the bean class of X must directly extend the bean class of
another session bean Y defined using annotations. Then X inherits all bindings of Y, and
if Y has a name, X has the same name as Y. Also, X must support all local interfaces
supported by Y, and
if Y supports a bean-class local view, X must also support a bean-class local view.
Otherwise, a DefinitionException is thrown by the container at deployment
time.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>We say that X directly specializes Y, and we can be certain that Y will
never be instantiated or called by the container if X is enabled</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of X does not directly extend the bean class of
another session bean, a DefinitionException is thrown by the container at deployment
time</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a session bean X defined in XML declares the
<Specializes> element, then the bean class of X must be the bean class of
another session bean Y defined using annotations. Then X inherits all bindings of Y, and
if Y has a name, X has the same name as Y.</text>
</assertion>
</section>
<section id="3.3.8" title="Default name for a session bean">
- <assertion code="a">
+ <assertion id="a">
<text>The default name for a session bean is the unqualified class name of
the bean class, after converting the first character to lower case</text>
</assertion>
</section>
<section id="3.3.9" title="Session bean proxies">
- <assertion code="a">
+ <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>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>All session bean proxies must be serializable</text>
</assertion>
</section>
<section id="3.4" title="Producer methods">
- <assertion code="a">
+ <assertion id="a">
<text>A producer method must be a method of a simple bean class or session
bean class</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A producer method may be either static or non-static</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>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</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a producer method sometimes returns a null value, then the producer
method must have scope @Dependent</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>If a producer method returns a null value at runtime, and the producer
method 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".</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>If the producer method return type is a parameterized type, it must
specify actual type parameters for each type parameter</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>If a producer method return type contains a wildcard type parameter or
type variable, a DefinitionException is thrown by the container at deployment
time</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>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</text>
</assertion>
- <assertion code="i">
+ <assertion id="i">
<text>A bean may declare multiple producer methods</text>
</assertion>
</section>
<section id="3.4.1" title="Bean types of a producer method">
- <assertion code="a">
+ <assertion id="a">
<text>If the return type of a producer method is an interface, the set of
bean types contains the return type, all interfaces it extends directly or indirectly and
java.lang.Object</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If a return type of a producer method is primitive or is a Java array
type, the set of bean types contains exactly two types: the method return type and
java.lang.Object</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the return type of a producer method is a class, the set of bean
types contains the return type, every superclass and all interfaces it implements directly
or indirectly</text>
</assertion>
</section>
<section id="3.4.2" title="Declaring a producer method using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>A producer method may be declared by annotating a method with the
@javax.inject.Produces annotation</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A producer method may also specify scope, name, deployment type,
stereotypes and/or bindings</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If a producer method is annotated @Initializer, has a parameter
annotated @Disposes, or has a parameter annotated @Observes, a DefinitionException is
thrown by the container at deployment time</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a non-static method of a session bean class is annotated @Produces,
and the method is not a business method of the EJB, a DefinitionException is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="3.4.3" title="Declaring a producer method using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For a bean defined in XML, a producer method may be declared using the
method name, the <Produces> element, the return type, and the parameter
types of the method</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When a producer method is declared in XML, the container ignores
binding annotations applied to the Java method or method parameters</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a bean declared in XML does not have a method with
the name and parameter types declared in XML, a DefinitionException is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="3.4.4" title="Producer method parameters">
- <assertion code="a">
+ <assertion id="a">
<text>If the producer method has parameters, the container calls the method
Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies"
to determine a value for each parameter and calls the producer method with those parameter
values</text>
</assertion>
</section>
<section id="3.4.5" title="Specializing a producer method">
- <assertion code="a">
+ <assertion id="a">
<text>If a producer method X is annotated @Specializes, then it must be
non-static and directly override another producer method Y. Then X inherits all bindings
of Y, and if Y has a name, X has the same name as Y.
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If the method is static or does not directly override another producer
method, a DefinitionException is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="3.4.6" title="Disposal methods">
- <assertion code="a">
+ <assertion id="a">
<text>A disposal method must be a method of a simple bean class or session
bean class.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A disposal method may be either static or non-static</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean is a session bean, the disposal method must be a business
method of the EJB or a static method of the bean class</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>A bean may declare multiple disposal methods</text>
</assertion>
</section>
<section id="3.4.7" title="Disposed parameter of a disposal
method">
- <assertion code="a">
+ <assertion id="a">
<text>Each disposal method must have exactly one disposed parameter, of the
same type as the corresponding producer method return type</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When searching for disposal methods for a producer method, the
container considers the type and bindings of the disposed parameter. If a disposed
parameter resolves to a producer method according to the typesafe resolution algorithm,
the container must call this method when destroying an instance returned by that producer
method</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the disposed parameter does not resolve to any producer method
according to the typesafe resolution algorithm, an UnsatisfiedDependencyException is
thrown by the container at deployment time</text>
</assertion>
</section>
<section id="3.4.8" title="Declaring a disposal method using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>A disposal method may be declared using annotations by annotating a
parameter @javax.inject.Disposes. That parameter is the disposed parameter</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If a method has more than one parameter annotated @Disposes, a
DefinitionException is thrown by the container</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If a disposal method is annotated @Produces, or @Initializer or has a
parameter annotated @Observes, a DefinitionException is thrown by the container at
deployment time</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>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 EJB, a
DefinitionException is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="3.4.9" title="Declaring a disposal method using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For a bean defined in XML, a disposal method may be declared using the
method name, the <Disposes> element, and the parameter types of the
method</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When a disposal method is declared in XML, the container ignores
binding annotations applied to the Java method parameter</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a bean declared in XML does not have a method with
the name and parameter types declared in XML, a DefinitionException is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="3.4.10" title="Disposal method parameters">
- <assertion code="a">
+ <assertion id="a">
<text>In addition to the disposed parameter, a disposal method may declare
additional parameters, which may also specify bindings. The container calls
Manager.getInstanceToInject() to determine a value for each parameter of a disposal method
and calls the disposal method with those parameter values</text>
</assertion>
</section>
<section id="3.4.11" title="Disposal method resolution">
- <assertion code="a">
+ <assertion id="a">
<text>When searching for disposal methods for a producer method, the
container searches for disposal methods which are declared by an enabled bean, and for
which the disposed parameter must resolve to the producer method, according to the
typesafe resolution algorithm</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If there are multiple disposal methods for a producer method, a
DefinitionException is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="3.4.12" title="Default name for a producer
method">
- <assertion code="a">
+ <assertion id="a">
<text>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</text>
</assertion>
</section>
<section id="3.5" title="Producer fields">
- <assertion code="a">
+ <assertion id="a">
<text>A producer field must be a field of a simple bean class or session bean
class</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A producer field may be either static or nonstatic</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If a producer field sometimes contains a null value when accessed, then
the producer field must have scope @Dependent</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>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"</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>If the producer field return type is a parameterized type, it must
specify actual type parameters for each type parameter</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>If a producer field return type contains a wildcard type parameter or
type variable, a DefinitionException is thrown by the container at deployment
time</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>The application may access producer fields directly. However, if the
application accesses a producer field directly, the returned object is not bound to any
context; and its lifecycle is not managed by the container</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>A bean may declare multiple producer fields</text>
</assertion>
</section>
<section id="3.5.1" title="Bean types of a producer field">
- <assertion code="a">
+ <assertion id="a">
<text>The bean types of a producer field depend upon the field type. If the
field type is an interface, the set of bean types contains the field type, all interfaces
it extends directly or indirectly and java.lang.Object</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The bean types of a producer field depend upon the field type. If a
field type is primitive or is a Java array type, the set of bean types contains exactly
two types: the field type and java.lang.Object</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>The bean types of a producer field depend upon the field type. If the
field type is a class, the set of bean types contains the field type, every superclass and
all interfaces it implements directly or indirectly</text>
</assertion>
</section>
<section id="3.5.2" title="Declaring a producer field using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>A producer field may be declared by annotating a field with the
@javax.inject.Produces annotation</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A producer field may also specify scope, name, deployment type,
stereotypes and/or bindings</text>
</assertion>
</section>
<section id="3.5.3" title="Declaring a producer field using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For a bean defined in XML, a producer field may be declared using the
field name, the <Produces> element, and the type</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When a producer field is declared in XML, the container ignores binding
annotations applied to the Java field</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a bean declared in XML does not have a field with
the name and type declared in XML, a DefinitionException is thrown by the container at
deployment time</text>
</assertion>
</section>
<section id="3.5.4" title="Default name for a producer
field">
- <assertion code="a">
+ <assertion id="a">
<text>The default name for a producer field is the field name</text>
</assertion>
</section>
<section id="3.6" title="Resources">
- <assertion code="a">
+ <assertion id="a">
<text>Resources may be declared in beans.xml, allowing direct injection of an
EE resource, entity manager, entity manager factory, EJB remote object or web service
reference</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @Resource, @PersistenceContext, @PersistenceUnit, @EJB or
@WebServiceRef</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A resource always has scope @Dependent</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>A resource may not declare a bean name</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>Resources are always declared using XML</text>
</assertion>
</section>
<section id="3.6.1" title="Declaring a resource using XML">
- <assertion code="a">
+ <assertion id="a">
<text>A resource may be declared in beans.xml using an element that
represents the Java type of the resource. For a Java EE resource, the EE resource type
must be specified�for example javax.sql.Datasource for a JDBC datasource. The bean type
of the resource is this specified type</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>A resource may be declared in beans.xml using an element that
represents the Java type of the resource. For a persistence context,
javax.persistence.EntityManager must be specified. The bean type of the resource is this
specified type</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>A resource may be declared in beans.xml using an element that
represents the Java type of the resource. For a persistence unit,
javax.persistence.EntityManagerFactory must be specified. The bean type of the resource
is this specified type</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>A resource may be declared in beans.xml using an element that
represents the Java type of the resource. For a remote EJB, an EJB remote interface type
must be specified. The bean type of the resource is this specified type</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>A resource may be declared in beans.xml using an element that
represents the Java type of the resource. For a web service, a web service type must be
specified. The bean type of the resource is this specified type</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>Each resource declaration must contain a child
<Resource>, <PersistenceContext>,
<PersistenceUnit>, <EJB> or
<WebServiceRef> element. For a Java EE resource, a JNDI name or mapped
name must be specified using the <name> or <mappedName> child
elements
of the <Resource> element</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>Each resource declaration must contain a child
<Resource>, <PersistenceContext>,
<PersistenceUnit>, <EJB> or
<WebServiceRef> element. For a persistence context, a persistence unit
name must be specified using the <unitName> child element of the
<PersistenceContext> element</text>
</assertion>
- <assertion code="h">
+ <assertion id="h">
<text>Each resource declaration must contain a child
<Resource>, <PersistenceContext>,
<PersistenceUnit>, <EJB> or
<WebServiceRef> element. For a persistence unit, a persistence unit name
must be specified using the <unitName> child element of the
<PersistenceUnit> element</text>
</assertion>
- <assertion code="i">
+ <assertion id="i">
<text>Each resource declaration must contain a child
<Resource>, <PersistenceContext>,
<PersistenceUnit>, <EJB> or
<WebServiceRef> element. For a remote EJB, a JNDI name, mapped name or EJB
link must be specified using the <name>, <mappedName> or
<ejbLink> child elements of the <EJB> element</text>
</assertion>
- <assertion code="j">
+ <assertion id="j">
<text>Each resource declaration must contain a child
<Resource>, <PersistenceContext>,
<PersistenceUnit>, <EJB> or
<WebServiceRef> element. For a web service, a JNDI name or mapped name
must be specified using the <name> or <mappedName> child
elements of the <WebServiceRef> element. Optionally, a URL pointing to a
WSDL document may be specified using the <wsdlLocation> child
element</text>
</assertion>
@@ -830,141 +830,141 @@
</section>
<section id="3.7" title="JMS resources">
- <assertion code="a">
+ <assertion id="a">
<text>JMS resources may be declared in beans.xml</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>JMS queue resources must allow the direct injection of the Queue,
QueueConnection, QueueSession, QueueReceiver and/or QueueSender</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>JMS topic resources must allow the direct injection of the Topic,
TopicConnection, TopicSession, TopicSubscriber and/or TopicPublisher</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>The lifecycles of the injected objects are managed by the container,
and therefore the application need not explicitly close() any injected JMS object. If the
application calls close() on an instance of a JMS resource, an
UnsupportedOperationException is thrown by the container.</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>A JMS resource always has scope @Dependent</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>A JMS resource may not declare a bean name</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>JMS resources are always declared using XML</text>
</assertion>
</section>
<section id="3.7.1" title="Bean types of a JMS resource">
- <assertion code="a">
+ <assertion id="a">
<text>For JMS resources that represent a queue, the bean types are Queue,
QueueConnection, QueueSession and QueueSender</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>For JMS resources that represent a topic, the bean types are Topic,
TopicConnection, TopicSession and TopicPublisher</text>
</assertion>
</section>
<section id="3.7.2" title="Declaring a JMS resource using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>A JMS resource may be declared using the <Topic> or
<Queue> elements in beans.xml</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>Each JMS resource declaration must contain a child <Resource>
element. A JNDI name or mapped name must be specified using the <name> or
<mappedName> child elements of the <Resource>
element</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>One or more bindings may be specified. If no binding is explicitly
specified, the default binding @Current is assumed</text>
</assertion>
</section>
<section id="3.8" title="Injected fields">
- <assertion code="a">
+ <assertion id="a">
<text>An injected field is a non-static, non-final field of a bean class, of
a servlet, or of any EJB session or message driven bean class.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>Injected fields are initialized by the container immediately after
instantiation and before any methods of the instance are invoked. The container calls the
method Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving
dependencies" to determine a value for each injected field</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>Any EJB session or message driven bean may declare injected fields and
have those fields injected by the container</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If a field is a producer field or a decorator delegate attribute, it is
not an injected field</text>
</assertion>
</section>
<section id="3.8.1" title="Declaring an injected field using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>An injected field may be declared by annotating the field with any
binding type</text>
</assertion>
</section>
<section id="3.8.2" title="Declaring an injected field using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For bean defined in XML, an injected field may be declared using the
field name and a child element representing the type of the field</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When an injected field is declared in XML, the container ignores
binding annotations applied to the Java field</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the type element does not declare any binding, the default binding
@Current is assumed</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>If the bean class of a bean declared in XML does not have a field with
the name and type declared in XML, a DefinitionException is thrown by the container at
deployment time</text>
</assertion>
</section>
<section id="3.9" title="Initializer methods">
- <assertion code="a">
+ <assertion id="a">
<text>An initializer method is a non-static method of a bean class, of a
servlet, or of any EJB session or message driven bean class.</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>Initializer methods are called by the container immediately after
injected fields have been initialized by the container and before any other methods of the
instance are invoked.</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean is a session bean, the initializer method is not required
to be a business method of the session bean</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>Method interceptors are never called when the container calls an
initializer method</text>
</assertion>
- <assertion code="e">
+ <assertion id="e">
<text>A bean class may declare multiple (or zero) initializer
methods</text>
</assertion>
- <assertion code="f">
+ <assertion id="f">
<text>The application may call initializer methods directly, but then no
parameters will be passed to the method by the container</text>
</assertion>
- <assertion code="g">
+ <assertion id="g">
<text>Any EJB session or message driven bean may declare initializer methods
and have the methods called by the container</text>
</assertion>
</section>
<section id="3.9.1" title="Declaring an initializer method using
annotations">
- <assertion code="a">
+ <assertion id="a">
<text>An initializer method may be declared by annotating the method
@javax.inject.Initializer</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>If an initializer method is annotated @Produces, has a parameter
annotated @Disposes, or has a parameter annotated @Observes, a DefinitionException is
thrown by the container at deployment time</text>
</assertion>
@@ -972,53 +972,53 @@
<section id="3.9.2" title="Declaring an initializer method using
XML">
- <assertion code="a">
+ <assertion id="a">
<text>For a bean defined in XML, an initializer method may be declared using
the method name, the <Initializer> element and the parameter types of the
method</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>When an initializer method is declared in XML, the container ignores
binding annotations applied to the Java method parameters</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>If the bean class of a bean declared in XML does not have a method with
the name and parameter types declared in XML, a DefinitionException is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="3.9.3" title="Initializer method parameters">
- <assertion code="a">
+ <assertion id="a">
<text>An initializer method may have any number of parameters. If the
initializer method has parameters, the container calls Manager.getInstanceToInject() to
determine a value for each parameter and calls the initializer method with those parameter
values</text>
</assertion>
</section>
<section id="3.10" title="Support for Common Annotations">
- <assertion code="a">
+ <assertion id="a">
<text>Dependency injection via @EJB, @Resource, @PersistenceUnit and
@PersistenceContext is provided by the container when annotations are applied to the bean
class of a simple bean</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>@PostConstruct and @PreDestroy callbacks are provided by the container
when annotations are applied to the bean class of a simple bean</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<text>Interception, as defined in javax.interceptor is provided by the
container when annotations are applied to the bean class of a simple bean</text>
</assertion>
- <assertion code="d">
+ <assertion id="d">
<text>@PersistenceContext(type=EXTENDED) is not supported for simple
beans</text>
</assertion>
</section>
<section id="3.11" title="The Bean object for a bean">
- <assertion code="a">
+ <assertion id="a">
<text>Concrete subclasses of Bean must implement the operations defined by
the Contextual interface defined in Section 6.1, "The Contextual
interface".</text>
</assertion>
- <assertion code="b">
+ <assertion id="b">
<text>An instance of Bean exists for every enabled bean in a
deployment</text>
</assertion>
- <assertion code="c">
+ <assertion id="c">
<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>
Modified: tck/trunk/impl/tck-audit.xsd
===================================================================
--- tck/trunk/impl/tck-audit.xsd 2009-01-27 22:05:24 UTC (rev 1253)
+++ tck/trunk/impl/tck-audit.xsd 2009-01-27 22:55:53 UTC (rev 1254)
@@ -40,7 +40,7 @@
</xs:element>
<xs:attributeGroup name="attlist.assertion">
- <xs:attribute name="code" type="xs:string"/>
+ <xs:attribute name="id" type="xs:string"/>
</xs:attributeGroup>
<xs:element name="text">