Author: shane.bryzak(a)jboss.com
Date: 2009-03-19 05:01:39 -0400 (Thu, 19 Mar 2009)
New Revision: 2106
Modified:
tck/trunk/impl/src/main/resources/tck-audit.xml
Log:
format literals
Modified: tck/trunk/impl/src/main/resources/tck-audit.xml
===================================================================
--- tck/trunk/impl/src/main/resources/tck-audit.xml 2009-03-19 07:47:47 UTC (rev 2105)
+++ tck/trunk/impl/src/main/resources/tck-audit.xml 2009-03-19 09:01:39 UTC (rev 2106)
@@ -51,11 +51,11 @@
</assertion>
<assertion id="c">
- <text>Bean types may not declare a type variable. If the type of an injection
point is a parameterized type with a type variable, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>Bean types may not declare a type variable. If the type of an injection
point is a parameterized type with a type variable, a |DefinitionException| is thrown by
the container at deployment time.</text>
</assertion>
<assertion id="d">
- <text>Bean types may not declare a wildcard. If the type of an injection
point is a parameterized type with a wildcard, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>Bean types may not declare a wildcard. If the type of an injection
point is a parameterized type with a wildcard, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="e">
@@ -103,7 +103,7 @@
<section id="2.3.1" title="Default binding type">
<assertion id="a">
- <text>If a bean does not explicitly declare a binding, the bean has exactly
one binding, of type @javax.inject.Current</text>
+ <text>If a bean does not explicitly declare a binding, the bean has exactly
one binding, of type |(a)javax.inject.Current|</text>
</assertion>
<assertion id="b">
@@ -113,20 +113,20 @@
<section id="2.3.2" title="Defining new binding types">
<assertion id="aa" testable="false">
- <text>A binding type is a Java annotation defined as @Target({METHOD, FIELD,
PARAMETER, TYPE})~ and @Retention(RUNTIME)~.</text>
+ <text>A binding type is a Java annotation defined as |@Target({METHOD, FIELD,
PARAMETER, TYPE})|~ and |(a)Retention(RUNTIME)|~.</text>
</assertion>
<assertion id="ab" testable="false">
- <text>A binding type is a Java annotation defined as ~@Target({METHOD, FIELD,
PARAMETER, TYPE}) and ~(a)Retention(RUNTIME).</text>
+ <text>A binding type is a Java annotation defined as ~|@Target({METHOD,
FIELD, PARAMETER, TYPE})| and ~|(a)Retention(RUNTIME)|.</text>
<note>Non-runtime retention annotations are discarded by the
compiler</note>
</assertion>
<assertion id="b">
- <text>A binding type may be declared by specifying the
@javax.inject.BindingType meta-annotation</text>
+ <text>A binding type may be declared by specifying the
|(a)javax.inject.BindingType| meta-annotation</text>
</assertion>
<assertion id="c">
- <text>The @BindingType meta-annotation may be omitted, and the binding type
may be declared in beans.xml</text>
+ <text>The |@BindingType| meta-annotation may be omitted, and the binding type
may be declared in beans.xml</text>
</assertion>
<assertion id="d" testable="false">
@@ -226,35 +226,35 @@
<section id="2.4.1" title="Built-in scope types">
<assertion id="a" testable="false">
- <text>The @RequestScoped, @ApplicationScoped and @SessionScoped annotations
defined in Section 8.5, "Context management for built-in scopes" represent the
standard scopes defined by the Java Servlets specification</text>
+ <text>The |@RequestScoped|, |@ApplicationScoped| and |@SessionScoped|
annotations defined in Section 8.5, "Context management for built-in scopes"
represent the standard scopes defined by the Java Servlets specification</text>
<note>This is a statement of intent</note>
</assertion>
<assertion id="b" testable="false">
- <text>The @ConversationScoped annotation represents the conversation scope
defined in Section 8.5.4, "Conversation context lifecycle".</text>
+ <text>The |@ConversationScoped| annotation represents the conversation scope
defined in Section 8.5.4, "Conversation context lifecycle".</text>
<note>This is a statement of intent</note>
</assertion>
<assertion id="c" testable="false">
- <text>The @Dependent pseudo-scope is for dependent objects, as defined in
Section 8.3, "Dependent pseudo-scope"</text>
+ <text>The |@Dependent| pseudo-scope is for dependent objects, as defined in
Section 8.3, "Dependent pseudo-scope"</text>
<note>This is a statement of intent</note>
</assertion>
</section>
<section id="2.4.2" title="Defining new scope types">
<assertion id="aa">
- <text>A scope type is a Java annotation defined as @Target({TYPE, METHOD,
FIELD})~ and @Retention(RUNTIME)~</text>
+ <text>A scope type is a Java annotation defined as |@Target({TYPE, METHOD,
FIELD})|~ and |@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="ab" testable="false">
- <text>A scope type is a Java annotation defined as ~@Target({TYPE, METHOD,
FIELD}) and ~@Retention(RUNTIME)</text>
+ <text>A scope type is a Java annotation defined as ~|@Target({TYPE, METHOD,
FIELD})| and ~|@Retention(RUNTIME)|</text>
<note>Non-runtime retention annotations are discarded by the
compiler</note>
</assertion>
<assertion id="b">
- <text>All scope types must specify the @javax.context.ScopeType
meta-annotation</text>
+ <text>All scope types must specify the |(a)javax.context.ScopeType|
meta-annotation</text>
</assertion>
</section>
@@ -265,7 +265,7 @@
</assertion>
<assertion id="b">
- <text>A bean class or producer method or field may specify at most one scope
type annotation. If a bean class or producer method or field specifies multiple scope type
annotations, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>A bean class or producer method or field may specify at most one scope
type annotation. If a bean class or producer method or field specifies multiple scope type
annotations, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="c">
@@ -279,7 +279,7 @@
</assertion>
<assertion id="b">
- <text>If more than one scope type is specified in XML, a DefinitionException
is thrown by the container at deployment time</text>
+ <text>If more than one scope type is specified in XML, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
@@ -293,7 +293,7 @@
</assertion>
<assertion id="b">
- <text>If the bean does not declare any stereotype with a declared default
scope, the default scope for the bean is @Dependent</text>
+ <text>If the bean does not declare any stereotype with a declared default
scope, the default scope for the bean is |@Dependent|</text>
</assertion>
<assertion id="c">
@@ -301,7 +301,7 @@
</assertion>
<assertion id="d">
- <text>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, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>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, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
@@ -319,16 +319,16 @@
<section id="2.5.1" title="Built-in deployment types">
<assertion id="a">
- <text>All standard beans defined by this specification, and provided by the
container, are defined using the @Standard deployment type</text>
+ <text>All standard beans defined by this specification, and provided by the
container, are defined using the |@Standard| deployment type</text>
<note>This is tested in the test for each bean defined. See 5.6.1.za,
5.7.2.ca, 8.5.4.i</note>
</assertion>
<assertion id="b">
- <text>No bean may be declared with the @Standard deployment type unless
explicitly required by this specification</text>
+ <text>No bean may be declared with the |@Standard| deployment type unless
explicitly required by this specification</text>
</assertion>
<assertion id="c" testable="false">
- <text>Application beans may be defined using the @Production deployment
type</text>
+ <text>Application beans may be defined using the |@Production| deployment
type</text>
<note>This is a statement of intent</note>
</assertion>
@@ -337,16 +337,16 @@
<section id="2.5.2" title="Defining new deployment types">
<assertion id="a">
- <text>A deployment type is a Java annotation defined as @Target({TYPE,
METHOD, FIELD})</text>
+ <text>A deployment type is a Java annotation defined as |@Target({TYPE,
METHOD, FIELD})|</text>
</assertion>
<assertion id="bb" testable="false">
- <text>A deployment type is a Java annotation defined with
@Retention(RUNTIME)</text>
+ <text>A deployment type is a Java annotation defined with
|@Retention(RUNTIME)|</text>
<note>Non-runtime retention annotations are discarded by the
compiler</note>
</assertion>
<assertion id="c">
- <text>All deployment types must also specify the @javax.inject.DeploymentType
meta-annotation.</text>
+ <text>All deployment types must also specify the
|(a)javax.inject.DeploymentType| meta-annotation.</text>
</assertion>
<assertion id="d">
@@ -370,15 +370,15 @@
</assertion>
<assertion id="d">
- <text>An bean class may specify at most one deployment type. If multiple
deployment type annotations are specified, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>An bean class may specify at most one deployment type. If multiple
deployment type annotations are specified, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="e">
- <text>A producer method may specify at most one deployment type. If multiple
deployment type annotations are specified, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>A producer method may specify at most one deployment type. If multiple
deployment type annotations are specified, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="f">
- <text>A field may specify at most one deployment type. If multiple deployment
type annotations are specified, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>A field may specify at most one deployment type. If multiple deployment
type annotations are specified, a |DefinitionException| is thrown by the container at
deployment time.</text>
</assertion>
<assertion id="g">
@@ -401,7 +401,7 @@
</assertion>
<assertion id="b">
- <text>If more than one deployment type is specified in XML, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If more than one deployment type is specified in XML, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
@@ -412,7 +412,7 @@
<section id="2.5.5" title="Default deployment type">
<assertion id="a">
- <text>The default deployment type for a bean which does not explicitly
declare a deployment type depends upon its declared stereotypes - if a bean does not
declare any stereotype with a declared default deployment type, then the default
deployment type is@Production</text>
+ <text>The default deployment type for a bean which does not explicitly
declare a deployment type depends upon its declared stereotypes - if a bean does not
declare any stereotype with a declared default deployment type, then the default
deployment type is |@Production|</text>
</assertion>
<assertion id="b">
@@ -432,19 +432,19 @@
</assertion>
<assertion id="b">
- <text>If a <Deploy> element is specified, only the explicitly
declared deployment types are enabled.</text>
+ <text>If a |<Deploy>| element is specified, only the explicitly
declared deployment types are enabled.</text>
</assertion>
<assertion id="c">
- <text>The @Standard deployment type must be declared. If the @Standard
deployment type is not declared, a DeploymentException is thrown by the container at
deployment time.</text>
+ <text>The |@Standard| deployment type must be declared. If the |@Standard|
deployment type is not declared, a |DeploymentException| is thrown by the container at
deployment time.</text>
</assertion>
<assertion id="d">
- <text>If no <Deploy> element is specified in any beans.xml
file, only the @Standard and @Production deployment types are enabled.</text>
+ <text>If no |<Deploy>| element is specified in any |beans.xml|
file, only the |@Standard| and |@Production| deployment types are enabled.</text>
</assertion>
<assertion id="e">
- <text>If the <Deploy> element is specified in more than one
beans.xml document, a DeploymentException is thrown by the container at deployment time.
</text>
+ <text>If the |<Deploy>| element is specified in more than one
|beans.xml| document, a |DeploymentException| is thrown by the container at deployment
time. </text>
</assertion>
</section>
@@ -459,60 +459,60 @@
<section id="2.6.1" title="Declaring the bean name using
annotations">
<assertion id="a">
- <text>To specify the name of a bean, the @javax.annotation.Named annotation
is applied to the bean class.</text>
+ <text>To specify the name of a bean, the |(a)javax.annotation.Named| annotation
is applied to the bean class.</text>
</assertion>
<assertion id="b">
- <text>To specify the name of a bean, the @javax.annotation.Named annotation
is applied to the producer method.</text>
+ <text>To specify the name of a bean, the |(a)javax.annotation.Named| annotation
is applied to the producer method.</text>
</assertion>
<assertion id="c">
- <text>To specify the name of a bean, the @javax.annotation.Named annotation
is applied to the producer field.</text>
+ <text>To specify the name of a bean, the |(a)javax.annotation.Named| annotation
is applied to the producer field.</text>
</assertion>
<assertion id="d">
- <text>If the @Named annotation does not specify the value member, the default
name is assumed</text>
+ <text>If the |@Named| annotation does not specify the value member, the
default name is assumed</text>
</assertion>
</section>
<section id="2.6.2" title="Declaring the bean name using
XML">
<assertion id="a">
- <text>If the bean is declared in beans.xml, the name may be specified using
<Named></text>
+ <text>If the bean is declared in beans.xml, the name may be specified using
|<Named>|</text>
</assertion>
<assertion id="b">
- <text>If the <Named> element is empty, the default name is
assumed</text>
+ <text>If the |<Named>| element is empty, the default name is
assumed</text>
</assertion>
</section>
<section id="2.6.3" title="Default bean names">
<assertion id="a">
- <text>A default name must be assigned by the container when a bean class
defined using annotations declares a @Named annotation and no name is explicitly specified
by the value member</text>
+ <text>A default name must be assigned by the container when a bean class
defined using annotations declares a |@Named| annotation and no name is explicitly
specified by the value member</text>
</assertion>
<assertion id="b">
- <text>A default name must be assigned by the container when a producer method
of a bean defined using annotations declares a @Named annotation and no name is explicitly
specified by the value member</text>
+ <text>A default name must be assigned by the container when a producer method
of a bean defined using annotations declares a |@Named| annotation and no name is
explicitly specified by the value member</text>
</assertion>
<assertion id="c">
- <text>A default name must be assigned by the container when a producer field
of a bean defined using annotations declares a @Named annotation and no name is explicitly
specified by the value member</text>
+ <text>A default name must be assigned by the container when a producer field
of a bean defined using annotations declares a |@Named| annotation and no name is
explicitly specified by the value member</text>
</assertion>
<assertion id="d">
- <text>A default name must be assigned by the container when an empty
<Named> element is specified by a bean defined in XML</text>
+ <text>A default name must be assigned by the container when an empty
|<Named>| element is specified by a bean defined in XML</text>
</assertion>
<assertion id="e">
- <text>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 a name.</text>
+ <text>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 a name.</text>
</assertion>
</section>
<section id="2.6.4" title="Beans with no name">
<assertion id="a">
- <text>If neither <Named> nor @Named is specified, by the bean
or its stereotypes, a bean has no name</text>
+ <text>If neither |<Named>| nor |@Named| is specified, by the
bean or its stereotypes, a bean has no name</text>
</assertion>
</section>
@@ -539,48 +539,46 @@
<section id="2.7.1" title="Defining new stereotypes">
<assertion id="aa" testable="false">
- <text>A beans stereotype is a Java annotation defined as @Target({TYPE,
METHOD, FIELD})~, @Target(TYPE), @Target(METHOD), @Target(FIELD) or @Target({METHOD,
FIELD}) and @Retention(RUNTIME)~</text>
+ <text>A beans stereotype is a Java annotation defined as |@Target({TYPE,
METHOD, FIELD})|~, |@Target(TYPE)|, |@Target(METHOD)|, |@Target(FIELD)| or
|@Target({METHOD, FIELD})| and |@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="ab" testable="false">
- <text>A beans stereotype is a Java annotation defined as ~@Target({TYPE,
METHOD, FIELD}),~ @Target(TYPE)~, @Target(METHOD), @Target(FIELD) or @Target({METHOD,
FIELD}) and @Retention(RUNTIME)~</text>
+ <text>A beans stereotype is a Java annotation defined as ~|@Target({TYPE,
METHOD, FIELD})|,~ |@Target(TYPE)|~, |@Target(METHOD)|, |@Target(FIELD)| or
|@Target({METHOD, FIELD})| and |@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="ac" testable="false">
- <text>A beans stereotype is a Java annotation defined as ~@Target({TYPE,
METHOD, FIELD}), @Target(TYPE), @Target(METHOD), ~@Target(FIELD) ~or @Target({METHOD,
FIELD}) and @Retention(RUNTIME)~</text>
+ <text>A beans stereotype is a Java annotation defined as ~|@Target({TYPE,
METHOD, FIELD})|, |@Target(TYPE)|, |@Target(METHOD)|, ~|@Target(FIELD)| ~or
|@Target({METHOD, FIELD})| and |@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="ad" testable="false">
- <text>A beans stereotype is a Java annotation defined as ~@Target({TYPE,
METHOD, FIELD}), @Target(TYPE), @Target(METHOD), @Target(FIELD) or~ @Target({METHOD,
FIELD})~ and @Retention(RUNTIME)~</text>
+ <text>A beans stereotype is a Java annotation defined as ~|@Target({TYPE,
METHOD, FIELD})|, |@Target(TYPE)|, |@Target(METHOD)|, |@Target(FIELD)| or~
|@Target({METHOD, FIELD})|~ and |@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="ae" testable="false">
- <text>A beans stereotype is a Java annotation defined as ~@Target({TYPE,
METHOD, FIELD}), @Target(TYPE), @Target(METHOD), @Target(FIELD) or @Target({METHOD,
FIELD}) and~ @Retention(RUNTIME)</text>
+ <text>A beans stereotype is a Java annotation defined as ~|@Target({TYPE,
METHOD, FIELD})|, |@Target(TYPE)|, |@Target(METHOD)|, |@Target(FIELD)| or
|@Target({METHOD, FIELD})| and~ |@Retention(RUNTIME)|</text>
<note>Non-runtime retention annotations are discarded by the
compiler</note>
</assertion>
-
-
<assertion id="b">
- <text>A stereotype may be declared by specifying the
@javax.annotation.Stereotype meta-annotation</text>
+ <text>A stereotype may be declared by specifying the
|(a)javax.annotation.Stereotype| meta-annotation</text>
</assertion>
<assertion id="c">
- <text>The @Stereotype meta-annotation may be omitted, and the stereotype may
be declared in beans.xml</text>
+ <text>The |@Stereotype| meta-annotation may be omitted, and the stereotype
may be declared in beans.xml</text>
</assertion>
<assertion id="d">
- <text>A stereotype may not declare any binding annotation. If a stereotype
declares a binding annotation, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>A stereotype may not declare any binding annotation. If a stereotype
declares a binding annotation, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
<section id="2.7.1.1" title="Declaring the default scope and
deployment type for a stereotype">
<assertion id="a">
- <text>A stereotype may declare at most one scope. If a stereotype declares
more than one scope, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>A stereotype may declare at most one scope. If a stereotype declares
more than one scope, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="b">
- <text>A stereotype may declare at most one deployment type. If a stereotype
declares more than one deployment type, a DefinitionException is thrown by the container
at deployment time</text>
+ <text>A stereotype may declare at most one deployment type. If a stereotype
declares more than one deployment type, a |DefinitionException| is thrown by the container
at deployment time</text>
</assertion>
</section>
@@ -602,7 +600,7 @@
<section id="2.7.1.3" title="Specifying name defaulting for a
stereotype">
<assertion id="a">
- <text>A stereotype may declare an empty @Named annotation. If a stereotype
declares a non-empty @Named annotation, a DefinitionException is thrown by the container
at deployment time</text>
+ <text>A stereotype may declare an empty |@Named| annotation. If a stereotype
declares a non-empty |@Named| annotation, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
<assertion id="b">
@@ -634,19 +632,19 @@
</assertion>
<assertion id="c" >
- <text>Stereotypes declared @Target(TYPE) may not be applied to stereotypes
declared @Target({TYPE, METHOD, FIELD})</text>
+ <text>Stereotypes declared |@Target(TYPE)| may not be applied to stereotypes
declared |@Target({TYPE, METHOD, FIELD})|</text>
</assertion>
<assertion id="d">
- <text>Stereotypes declared @Target(TYPE) may not be applied to stereotypes
declared @Target(METHOD)</text>
+ <text>Stereotypes declared |@Target(TYPE)| may not be applied to stereotypes
declared |@Target(METHOD)|</text>
</assertion>
<assertion id="e">
- <text>Stereotypes declared @Target(TYPE) may not be applied to stereotypes
declared @Target(FIELD)</text>
+ <text>Stereotypes declared |@Target(TYPE)| may not be applied to stereotypes
declared |@Target(FIELD)|</text>
</assertion>
<assertion id="f">
- <text>Stereotypes declared @Target(TYPE) may not be applied to stereotypes
declared @Target({METHOD, FIELD})</text>
+ <text>Stereotypes declared |@Target(TYPE)| may not be applied to stereotypes
declared |@Target({METHOD, FIELD})|</text>
</assertion>
</section>
@@ -685,11 +683,11 @@
<section id="2.7.4" title="Stereotype restrictions">
<assertion id="a">
- <text>If a stereotype declares a requiredType, and the bean types do not
include the type, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If a stereotype declares a requiredType, and the bean types do not
include the type, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="b">
- <text>If a stereotype explicitly declares a set of scope types using
supportedScopes, and the bean scope is not in that set, a DefinitionException is thrown by
the container at deployment time</text>
+ <text>If a stereotype explicitly declares a set of scope types using
supportedScopes, and the bean scope is not in that set, a |DefinitionException| is thrown
by the container at deployment time</text>
</assertion>
<assertion id="c">
@@ -699,7 +697,7 @@
<section id="2.7.5" title="Built-in stereotypes">
<assertion id="a" testable="false">
- <text>The built-in @Model stereotype is intended for use with beans that
define the model layer of an MVC web application architecture such as JSF</text>
+ <text>The built-in |@Model| stereotype is intended for use with beans that
define the model layer of an MVC web application architecture such as JSF</text>
<note>Tested by API signature test</note>
</assertion>
@@ -737,7 +735,7 @@
</assertion>
<assertion id="d">
- <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>
+ <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 id="e">
@@ -745,12 +743,12 @@
</assertion>
<assertion id="fa">
- <text>If a simple bean has a public field, it must have scope
@Dependent.</text>
+ <text>If a simple bean has a public field, it must have scope
|(a)Dependent|.</text>
<note>Check that a dependent scoped bean with a public field does
work</note>
</assertion>
<assertion id="fb">
- <text>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>
+ <text>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>
@@ -775,49 +773,49 @@
<text>A top-level Java class can be a simple bean if it is static inner
class</text>
</assertion>
<assertion id="da">
- <text>A top-level abstract Java class is a simple bean if it is annotated
@Decorator.</text>
+ <text>A top-level abstract Java class is a simple bean if it is annotated
|(a)Decorator|.</text>
</assertion>
<assertion id="e">
- <text>A top-level Java class is not a simple bean if it is annotated with the
JPA @Entity annotation</text>
+ <text>A top-level Java class is not a simple bean if it is annotated with the
JPA |@Entity| annotation</text>
</assertion>
<assertion id="f">
<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 id="g">
- <text>A top-level Java class is not a simple bean if it implements the
javax.servlet.Servlet interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.servlet.Servlet| interface</text>
</assertion>
<assertion id="h">
- <text>A top-level Java class is not a simple bean if it implements the
javax.servlet.Filter interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.servlet.Filter| interface</text>
</assertion>
<assertion id="i">
- <text>A top-level Java class is not a simple bean if it implements the
javax.servlet.ServletContextListener interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.servlet.ServletContextListener| interface</text>
</assertion>
<assertion id="j">
- <text>A top-level Java class is not a simple bean if it implements the
javax.servlet.http.HttpSessionListener interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.servlet.http.HttpSessionListener| interface</text>
</assertion>
<assertion id="k">
- <text>A top-level Java class is not a simple bean if it implements the
javax.servlet.ServletRequestListener interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.servlet.ServletRequestListener| interface</text>
</assertion>
<assertion id="l">
- <text>A top-level Java class is not a simple bean if it implements the
javax.ejb.EnterpriseBean interface</text>
+ <text>A top-level Java class is not a simple bean if it implements the
|javax.ejb.EnterpriseBean| interface</text>
</assertion>
<assertion id="m">
- <text>A top-level Java class is not a simple bean if it extends
javax.faces.component.UIComponent</text>
+ <text>A top-level Java class is not a simple bean if it extends
|javax.faces.component.UIComponent|</text>
</assertion>
<assertion id="n">
- <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>
+ <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 id="o">
- <text>A top-level Java class is not a simple bean if it is declared as a JPA
entity in orm.xml</text>
+ <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 id="p">
<text>A top-level Java class is only a simple bean if it has an appropriate
constructor - a constructor with no parameters</text>
</assertion>
<assertion id="q">
- <text>A top-level Java class is only a simple bean if it has an appropriate
constructor - a constructor annotated @Initializer</text>
+ <text>A top-level Java class is only a simple bean if it has an appropriate
constructor - a constructor annotated |@Initializer|</text>
</assertion>
<assertion id="r">
- <text>Additional simple beans with the same bean class may be defined using
XML, by specifying the class in beans.xml.</text>
+ <text>Additional simple beans with the same bean class may be defined using
XML, by specifying the class in |beans.xml|.</text>
</assertion>
</section>
@@ -860,7 +858,7 @@
<section id="3.2.4" title="Declaring a simple bean using
XML">
<assertion id="a">
- <text>Simple beans may be declared in beans.xml using the bean class
name</text>
+ <text>Simple beans may be declared in |beans.xml| using the bean class
name</text>
</assertion>
<assertion id="b">
@@ -868,29 +866,29 @@
</assertion>
<assertion id="c">
- <text>If the bean class of a simple bean defined in XML is a parameterized
type , a DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the bean class of a simple bean defined in XML is a parameterized
type , a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="d">
- <text>If the bean class of a simple bean defined in XML is a non-static inner
class, a DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the bean class of a simple bean defined in XML is a non-static inner
class, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="da">
- <text>If the bean class of a simple bean defined in XML is a static inner
class, a DefinitionException is not thrown.</text>
+ <text>If the bean class of a simple bean defined in XML is a static inner
class, a |DefinitionException| is not thrown.</text>
</assertion>
<assertion id="e">
- <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
+ <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 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
+ <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 id="g">
- <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
+ <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>
@@ -965,23 +963,23 @@
<section id="3.2.6.1" title="Declaring a bean constructor using
annotations">
<assertion id="a">
- <text>The bean constructor may be identified by annotating the constructor
@Initializer</text>
+ <text>The bean constructor may be identified by annotating the constructor
|@Initializer|</text>
</assertion>
<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>
+ <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 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>
+ <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 id="d">
- <text>If a bean constructor has a parameter annotated @Disposes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a bean constructor has a parameter annotated |@Disposes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
- <text>If a bean constructor has a parameter annotated @Observes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a bean constructor has a parameter annotated |@Observes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
@@ -997,7 +995,7 @@
</assertion>
<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>
+ <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 id="d">
@@ -1028,11 +1026,11 @@
</assertion>
<assertion id="d">
- <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>
+ <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 id="e">
- <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>
+ <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>
</section>
@@ -1049,15 +1047,15 @@
</assertion>
<assertion id="b">
- <text>A stateless session bean must belong to the @Dependent
pseudo-scope</text>
+ <text>A stateless session bean must belong to the |@Dependent|
pseudo-scope</text>
</assertion>
<assertion id="c">
- <text>A singleton bean must belong to either the @ApplicationScoped scope or
to the @Dependent pseudo-scope</text>
+ <text>A singleton bean must belong to either the |@ApplicationScoped| scope
or to the |@Dependent| pseudo-scope</text>
</assertion>
<assertion id="d">
- <text>If a session bean specifies an illegal scope, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If a session bean specifies an illegal scope, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
@@ -1065,33 +1063,33 @@
</assertion>
<assertion id="f">
- <text>If the bean class of a session bean is annotated @Interceptor, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the bean class of a session bean is annotated |@Interceptor|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="g">
- <text>If the bean class of a session bean is annotated @Decorator, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the bean class of a session bean is annotated |@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 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>
+ <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 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>
+ <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 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>
+ <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 id="da">
- <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.</text>
+ <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.</text>
</assertion>
<assertion id="db">
- <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 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>
+ <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 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>
@@ -1102,7 +1100,7 @@
</assertion>
<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>
+ <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>
@@ -1118,7 +1116,7 @@
</assertion>
<assertion id="c">
- <text>java.lang.Object is a bean type of every session bean</text>
+ <text>|java.lang.Object| is a bean type of every session bean</text>
</assertion>
<assertion id="d">
@@ -1158,26 +1156,26 @@
<section id="3.3.5" title="Declaring a session bean using
XML">
<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>
+ <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 id="b">
- <text>The ejbName attribute declares the EJB name of an EJB defined in
ejb-jar.xml</text>
+ <text>The ejbName attribute declares the EJB name of an EJB defined in
|ejb-jar.xml|</text>
</assertion>
<assertion id="c">
- <text>If an entity bean class is declared in XML, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If an entity bean class is declared in XML, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If a message-driven bean class is declared in XML, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a 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 id="aa">
- <text>Check that all enterprise beans have a @New bean</text>
+ <text>Check that all enterprise beans have a |@New| bean</text>
<note>Sanity check</note>
</assertion>
@@ -1194,15 +1192,15 @@
</assertion>
<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>
+ <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 |(a)Dependent|.</text>
</assertion>
<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>
+ <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 |(a)Standard|.</text>
</assertion>
<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>
+ <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
|(a)javax.inject.New| as the only binding</text>
</assertion>
<assertion id="g">
@@ -1233,7 +1231,7 @@
<section id="3.3.7" title="Specializing a session bean">
<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>
+ <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 id="b">
@@ -1245,11 +1243,11 @@
</assertion>
<assertion id="d">
- <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>
+ <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 id="e">
- <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>
+ <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>
@@ -1287,11 +1285,11 @@
</assertion>
<assertion id="e">
- <text>If a producer method sometimes returns a null value, then the producer
method must have scope @Dependent</text>
+ <text>If a producer method sometimes returns a null value, then the producer
method must have scope |@Dependent|</text>
</assertion>
<assertion id="f">
- <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>
+ <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 id="g">
@@ -1299,11 +1297,11 @@
</assertion>
<assertion id="h">
- <text>If a producer method return type contains a wildcard type parameter, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer method return type contains a wildcard type parameter, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="i">
- <text>If a producer method return type contains a type variable, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer method return type contains a type variable, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="j" testable="false">
@@ -1318,11 +1316,11 @@
<section id="3.4.1" title="Bean types of a producer method">
<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>
+ <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 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>
+ <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 id="c">
@@ -1333,7 +1331,7 @@
<section id="3.4.2" title="Declaring a producer method using
annotations">
<assertion id="a">
- <text>A producer method may be declared by annotating a method with the
@javax.inject.Produces annotation</text>
+ <text>A producer method may be declared by annotating a method with the
|(a)javax.inject.Produces| annotation</text>
</assertion>
<assertion id="ba">
@@ -1357,26 +1355,26 @@
</assertion>
<assertion id="c">
- <text>If a producer method is annotated @Initializer, a DefinitionException
is thrown by the container at deployment time</text>
+ <text>If a producer method is annotated |@Initializer|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If a producer method has a parameter annotated @Disposes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer method has a parameter annotated |@Disposes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
- <text>If a producer method has a parameter annotated @Observes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer method has a parameter annotated |@Observes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="f">
- <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>
+ <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 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>
+ <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 id="b">
@@ -1384,28 +1382,28 @@
</assertion>
<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>
+ <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 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>
+ <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 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.</text>
+ <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.</text>
</assertion>
<assertion id="b">
- <text>If the method is static, a DefinitionException is thrown by the
container at deployment time</text>
+ <text>If the method is static, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If the method does not directly override another producer method, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the method does not directly override another producer method, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
@@ -1454,27 +1452,27 @@
<section id="3.4.8" title="Declaring a disposal method using
annotations">
<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>
+ <text>A disposal method may be declared using annotations by annotating a
parameter |(a)javax.inject.Disposes|. That parameter is the disposed parameter</text>
</assertion>
<assertion id="b">
- <text>If a method has more than one parameter annotated @Disposes, a
DefinitionException is thrown by the container</text>
+ <text>If a method has more than one parameter annotated |@Disposes|, a
|DefinitionException| is thrown by the container</text>
</assertion>
<assertion id="c">
- <text>If a disposal method is annotated @Produces, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If a disposal method is annotated |@Produces|, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If a disposal method is annotated @Initializer, a DefinitionException
is thrown by the container at deployment time</text>
+ <text>If a disposal method is annotated |@Initializer|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
- <text>If a disposal method has a parameter annotated @Observes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a disposal method has a parameter annotated |@Observes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="f">
- <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>
+ <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>
@@ -1489,14 +1487,14 @@
</assertion>
<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>
+ <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 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>
+ <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>
@@ -1507,7 +1505,7 @@
</assertion>
<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>
+ <text>If there are multiple disposal methods for a producer method, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
@@ -1533,11 +1531,11 @@
</assertion>
<assertion id="d">
- <text>If a producer field sometimes contains a null value when accessed, then
the producer field must have scope @Dependent</text>
+ <text>If a producer field sometimes contains a null value when accessed, then
the producer field must have scope |@Dependent|</text>
</assertion>
<assertion id="e">
- <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>
+ <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 id="f">
@@ -1545,11 +1543,11 @@
</assertion>
<assertion id="g">
- <text>If a producer field return type contains a wildcard type parameter, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer field return type contains a wildcard type parameter, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="h">
- <text>If a producer field return type contains a type variable, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a producer field return type contains a type variable, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="i" testable="false">
@@ -1580,7 +1578,7 @@
<section id="3.5.2" title="Declaring a producer field using
annotations">
<assertion id="a">
- <text>A producer field may be declared by annotating a field with the
@javax.inject.Produces annotation</text>
+ <text>A producer field may be declared by annotating a field with the
|(a)javax.inject.Produces| annotation</text>
</assertion>
<assertion id="b">
@@ -1607,7 +1605,7 @@
<section id="3.5.3" title="Declaring a producer field using
XML">
<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>
+ <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 id="b">
@@ -1615,7 +1613,7 @@
</assertion>
<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>
+ <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>
@@ -1648,27 +1646,27 @@
</assertion>
<assertion id="f">
- <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @Resource</text>
+ <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using |@Resource|</text>
</assertion>
<assertion id="g">
- <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @PersistenceContext</text>
+ <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using |@PersistenceContext|</text>
</assertion>
<assertion id="h">
- <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @PersistenceUnit</text>
+ <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using |@PersistenceUnit|</text>
</assertion>
<assertion id="i">
- <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @EJB</text>
+ <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using |@EJB|</text>
</assertion>
<assertion id="j">
- <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using @WebServiceRef</text>
+ <text>The lifecycle of an injected reference is identical to the semantics of
Java EE injection using |@WebServiceRef|</text>
</assertion>
<assertion id="k">
- <text>A resource always has scope @Dependent</text>
+ <text>A resource always has scope |@Dependent|</text>
</assertion>
<assertion id="l">
@@ -1684,216 +1682,211 @@
<section id="3.6.1" title="Declaring a resource using XML">
<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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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 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>
+ <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>
<assertion id="k">
- <text>The JNDI name specified by the <name> element must be a
name in the global java:global or application java:app naming context</text>
+ <text>The JNDI name specified by the |<name>| element must be a
name in the global |java:global| or application |java:app| naming context</text>
</assertion>
<assertion id="l">
- <text>Optionally, one or more bindings may be specified for resources in XML.
If no binding is explicitly specified, the default binding @Current is
assumed.</text>
+ <text>Optionally, one or more bindings may be specified for resources in XML.
If no binding is explicitly specified, the default binding |@Current| is
assumed.</text>
</assertion>
</section>
<section id="3.7" title="JMS resources">
<assertion id="a">
- <text>JMS resources may be declared in beans.xml</text>
+ <text>JMS resources may be declared in |beans.xml|</text>
</assertion>
<assertion id="b">
- <text>JMS queue resources must allow the direct injection of the
Queue</text>
+ <text>JMS queue resources must allow the direct injection of the
|Queue|</text>
</assertion>
<assertion id="c">
- <text>JMS queue resources must allow the direct injection of the
QueueConnection</text>
+ <text>JMS queue resources must allow the direct injection of the
|QueueConnection|</text>
</assertion>
<assertion id="d">
- <text>JMS queue resources must allow the direct injection of the
QueueSession</text>
+ <text>JMS queue resources must allow the direct injection of the
|QueueSession|</text>
</assertion>
<assertion id="e">
- <text>JMS queue resources must allow the direct injection of the
QueueReceiver</text>
+ <text>JMS queue resources must allow the direct injection of the
|QueueReceiver|</text>
</assertion>
<assertion id="f">
- <text>JMS queue resources must allow the direct injection of the
QueueSender</text>
+ <text>JMS queue resources must allow the direct injection of the
|QueueSender|</text>
</assertion>
<assertion id="g">
- <text>JMS topic resources must allow the direct injection of the
Topic</text>
+ <text>JMS topic resources must allow the direct injection of the
|Topic|</text>
</assertion>
<assertion id="h">
- <text>JMS topic resources must allow the direct injection of the
TopicConnection</text>
+ <text>JMS topic resources must allow the direct injection of the
|TopicConnection|</text>
</assertion>
<assertion id="i">
- <text>JMS topic resources must allow the direct injection of the
TopicSession</text>
+ <text>JMS topic resources must allow the direct injection of the
|TopicSession|</text>
</assertion>
<assertion id="j">
- <text>JMS topic resources must allow the direct injection of the
TopicSubscriber</text>
+ <text>JMS topic resources must allow the direct injection of the
|TopicSubscriber|</text>
</assertion>
<assertion id="k">
- <text>JMS topic resources must allow the direct injection of the
TopicPublisher</text>
+ <text>JMS topic resources must allow the direct injection of the
|TopicPublisher|</text>
</assertion>
<assertion id="l">
- <text>If the application calls close() on an instance of a QueueConnection,
an UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a
|QueueConnection|, an |UnsupportedOperationException| is thrown by the
container.</text>
</assertion>
<assertion id="m">
- <text>If the application calls close() on an instance of a QueueSession, an
UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a |QueueSession|,
an |UnsupportedOperationException| is thrown by the container.</text>
</assertion>
<assertion id="n">
- <text>If the application calls close() on an instance of a QueueReceiver, an
UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a |QueueReceiver|,
an |UnsupportedOperationException| is thrown by the container.</text>
</assertion>
<assertion id="o">
- <text>If the application calls close() on an instance of a QueueSender, an
UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a |QueueSender|,
an |UnsupportedOperationException| is thrown by the container.</text>
</assertion>
<assertion id="p">
- <text>If the application calls close() on an instance of a TopicConnection,
an UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a
|TopicConnection|, an |UnsupportedOperationException| is thrown by the
container.</text>
</assertion>
<assertion id="q">
- <text>If the application calls close() on an instance of a TopicSession, an
UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a |TopicSession|,
an |UnsupportedOperationException| is thrown by the container.</text>
</assertion>
<assertion id="r">
- <text>If the application calls close() on an instance of a TopicSubscriber,
an UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a
|TopicSubscriber|, an |UnsupportedOperationException| is thrown by the
container.</text>
</assertion>
<assertion id="s">
- <text>If the application calls close() on an instance of a TopicPublisher, an
UnsupportedOperationException is thrown by the container.</text>
+ <text>If the application calls |close()| on an instance of a
|TopicPublisher|, an |UnsupportedOperationException| is thrown by the
container.</text>
</assertion>
<assertion id="t">
- <text>A JMS Queue resource always has scope @Dependent</text>
+ <text>A JMS |Queue| resource always has scope |@Dependent|</text>
</assertion>
<assertion id="u">
- <text>A JMS QueueConnection resource always has scope
@Dependent</text>
+ <text>A JMS |QueueConnection| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="v">
- <text>A JMS QueueSession resource always has scope @Dependent</text>
+ <text>A JMS |QueueSession| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="w">
- <text>A JMS QueueReceiver resource always has scope @Dependent</text>
+ <text>A JMS |QueueReceiver| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="x">
- <text>A JMS QueueSender resource always has scope @Dependent</text>
+ <text>A JMS |QueueSender| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="y">
- <text>A JMS Topic resource always has scope @Dependent</text>
+ <text>A JMS |Topic| resource always has scope |@Dependent|</text>
</assertion>
<assertion id="z">
- <text>A JMS TopicConnection resource always has scope
@Dependent</text>
+ <text>A JMS |TopicConnection| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="aa">
- <text>A JMS TopicSession resource always has scope @Dependent</text>
+ <text>A JMS |TopicSession| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="ab">
- <text>A JMS TopicSubscriber resource always has scope
@Dependent</text>
+ <text>A JMS |TopicSubscriber| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="ac">
- <text>A JMS TopicPublisher resource always has scope @Dependent</text>
+ <text>A JMS |TopicPublisher| resource always has scope
|@Dependent|</text>
</assertion>
<assertion id="ad">
- <text>A JMS Queue resource may not declare a bean name</text>
+ <text>A JMS |Queue| resource may not declare a bean name</text>
</assertion>
<assertion id="ae">
- <text>A JMS QueueConnection resource may not declare a bean
name</text>
+ <text>A JMS |QueueConnection| resource may not declare a bean
name</text>
</assertion>
<assertion id="af">
- <text>A JMS QueueSession resource may not declare a bean name</text>
+ <text>A JMS |QueueSession| resource may not declare a bean name</text>
</assertion>
<assertion id="ag">
- <text>A JMS QueueReceiver resource may not declare a bean name</text>
+ <text>A JMS |QueueReceiver| resource may not declare a bean
name</text>
</assertion>
<assertion id="ah">
- <text>A JMS QueueSender resource may not declare a bean name</text>
+ <text>A JMS |QueueSender| resource may not declare a bean name</text>
</assertion>
<assertion id="ai">
- <text>A JMS Topic resource may not declare a bean name</text>
+ <text>A JMS |Topic| resource may not declare a bean name</text>
</assertion>
<assertion id="aj">
- <text>A JMS TopicConnection resource may not declare a bean
name</text>
+ <text>A JMS |TopicConnection| resource may not declare a bean
name</text>
</assertion>
<assertion id="ak">
- <text>A JMS TopicSession resource may not declare a bean name</text>
+ <text>A JMS |TopicSession| resource may not declare a bean name</text>
</assertion>
<assertion id="al">
- <text>A JMS TopicSubscriber resource may not declare a bean
name</text>
+ <text>A JMS |TopicSubscriber| resource may not declare a bean
name</text>
</assertion>
<assertion id="am">
- <text>A JMS TopicPublisher resource may not declare a bean name</text>
+ <text>A JMS |TopicPublisher| resource may not declare a bean
name</text>
</assertion>
<assertion id="an">
@@ -1904,26 +1897,26 @@
<section id="3.7.1" title="Bean types of a JMS resource">
<assertion id="a">
- <text>For JMS resources that represent a queue, the bean types are Queue,
QueueConnection, QueueSession and QueueSender</text>
+ <text>For JMS resources that represent a queue, the bean types are |Queue|,
|QueueConnection|, |QueueSession| and |QueueSender|</text>
</assertion>
<assertion id="b">
- <text>For JMS resources that represent a topic, the bean types are Topic,
TopicConnection, TopicSession and TopicPublisher</text>
+ <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 id="a">
- <text>A JMS resource may be declared using the <Topic> or
<Queue> elements in beans.xml</text>
+ <text>A JMS resource may be declared using the |<Topic>| or
|<Queue>| elements in |beans.xml|</text>
</assertion>
<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>
+ <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 id="c">
- <text>One or more bindings may be specified. If no binding is explicitly
specified, the default binding @Current is assumed</text>
+ <text>One or more bindings may be specified. If no binding is explicitly
specified, the default binding |@Current| is assumed</text>
</assertion>
</section>
@@ -1951,7 +1944,7 @@
</assertion>
<assertion id="e">
- <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>
+ <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 id="f">
@@ -1988,11 +1981,11 @@
</assertion>
<assertion id="c">
- <text>If the type element does not declare any binding, the default binding
@Current is assumed</text>
+ <text>If the type element does not declare any binding, the default binding
|@Current| is assumed</text>
</assertion>
<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>
+ <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>
<assertion id="e">
@@ -2050,19 +2043,19 @@
<section id="3.9.1" title="Declaring an initializer method using
annotations">
<assertion id="a">
- <text>An initializer method may be declared by annotating the method
@javax.inject.Initializer</text>
+ <text>An initializer method may be declared by annotating the method
|(a)javax.inject.Initializer|</text>
</assertion>
<assertion id="b">
- <text>If an initializer method is annotated @Produces, a DefinitionException
is thrown by the container at deployment time</text>
+ <text>If an initializer method is annotated |@Produces|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If an initializer method has a parameter annotated @Disposes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If an initializer method has a parameter annotated |@Disposes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If an initializer method has a parameter annotated @Observes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If an initializer method has a parameter annotated |@Observes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
@@ -2070,7 +2063,7 @@
<section id="3.9.2" title="Declaring an initializer method using
XML">
<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>
+ <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 id="b">
@@ -2078,47 +2071,47 @@
</assertion>
<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>
+ <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 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>
+ <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 id="a">
- <text>Dependency injection via @EJB is provided by the container when
annotations are applied to the bean class of a simple bean</text>
+ <text>Dependency injection via |@EJB| is provided by the container when
annotations are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="b">
- <text>Dependency injection via @Resource is provided by the container when
annotations are applied to the bean class of a simple bean</text>
+ <text>Dependency injection via |@Resource| is provided by the container when
annotations are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="c">
- <text>Dependency injection via @PersistenceUnit is provided by the container
when annotations are applied to the bean class of a simple bean</text>
+ <text>Dependency injection via |@PersistenceUnit| is provided by the
container when annotations are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="d">
- <text>Dependency injection via @PersistenceContext is provided by the
container when annotations are applied to the bean class of a simple bean</text>
+ <text>Dependency injection via |@PersistenceContext| is provided by the
container when annotations are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="e">
- <text>@PostConstruct callbacks are provided by the container when annotations
are applied to the bean class of a simple bean</text>
+ <text>|@PostConstruct| callbacks are provided by the container when
annotations are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="f">
- <text>@PreDestroy callbacks are provided by the container when annotations
are applied to the bean class of a simple bean</text>
+ <text>|@PreDestroy| callbacks are provided by the container when annotations
are applied to the bean class of a simple bean</text>
</assertion>
<assertion id="g">
- <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>
+ <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 id="h">
- <text>@PersistenceContext(type=EXTENDED) is not supported for simple
beans</text>
+ <text>|@PersistenceContext(type=EXTENDED)| is not supported for simple
beans</text>
</assertion>
</section>
@@ -2146,83 +2139,83 @@
<section id="4.1" title="Inheritance of type-level
metadata">
<assertion id="aa">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _binding type_ Z then Y inherits the annotation
if and only if Z declares the @Inherited meta-annotation and Y does not declare an
annotation of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _binding type_ Z then Y inherits the annotation
if and only if Z declares the |@Inherited| meta-annotation and Y does not declare an
annotation of type Z.</text>
</assertion>
<assertion id="ab">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _stereotype_ Z then Y inherits the annotation if
and only if Z declares the @Inherited meta-annotation and Y does not declare an annotation
of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _stereotype_ Z then Y inherits the annotation if
and only if Z declares the |@Inherited| meta-annotation and Y does not declare an
annotation of type Z.</text>
</assertion>
<assertion id="ac">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _interceptor binding type_ Z then Y inherits the
annotation if and only if Z declares the @Inherited meta-annotation and Y does not declare
an annotation of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _interceptor binding type_ Z then Y inherits the
annotation if and only if Z declares the |@Inherited| meta-annotation and Y does not
declare an annotation of type Z.</text>
</assertion>
<assertion id="ad">
- <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _binding type_ Z then Y inherits the annotation
if and only if Z declares the @Inherited meta-annotation and Y does not declare an
annotation of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _binding type_ Z then Y inherits the annotation
if and only if Z declares the |@Inherited| meta-annotation and Y does not declare an
annotation of type Z.</text>
</assertion>
<assertion id="ae">
- <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _stereotype_ Z then Y inherits the annotation
if and only if Z declares the @Inherited meta-annotation and Y does not declare an
annotation of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _stereotype_ Z then Y inherits the annotation
if and only if Z declares the |@Inherited| meta-annotation and Y does not declare an
annotation of type Z.</text>
</assertion>
<assertion id="af">
- <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _interceptor binding type_ Z then Y inherits
the annotation if and only if Z declares the @Inherited meta-annotation and Y does not
declare an annotation of type Z.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X is annotated with a _interceptor binding type_ Z then Y inherits
the annotation if and only if Z declares the |@Inherited| meta-annotation and Y does not
declare an annotation of type Z.</text>
</assertion>
<assertion id="ag">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _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="ah">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _stereotype_ 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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _stereotype_ 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="ai">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a _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="aj">
- <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _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="ak">
- <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _stereotype_ 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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _stereotype_ 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="al">
- <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X is annotated with a _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="ba">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a scope type Z then Y inherits the annotation if
and only if Z declares the @Inherited meta-annotation and Y does not declare a scope
type.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X is annotated with a scope type Z then Y inherits the annotation if
and only if Z declares the |@Inherited| meta-annotation and Y does not declare a scope
type.</text>
</assertion>
<assertion id="bb">
- <text>For class X which is extended _directly_ by the bean class of a
_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 meta-annotation and Y does not declare a scope
type.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_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| meta-annotation and Y does not declare a scope
type.</text>
</assertion>
<assertion id="bc">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a scope 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 scope type.</text>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X is annotated with a scope 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 scope type.</text>
</assertion>
<assertion id="bd">
- <text>For class X which is extended _indirectly_ by the bean class of a
_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 meta-annotation and neither Y nor any intermediate
class that is a subclass of X and a superclass of Y declares a scope type.</text>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_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| meta-annotation 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="ca">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ 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 Y does not declare a
deployment type.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ 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 Y does not declare a
deployment type.</text>
</assertion>
<assertion id="cb">
- <text>For class X which is extended _directly_ by the bean class of a
_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 Y does not declare
a deployment type.</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_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 Y does not
declare a deployment type.</text>
</assertion>
<assertion id="cc">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ 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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ 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="cd">
- <text>For class X which is extended _indirectly_ by the bean class of a
_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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_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="da">
@@ -2242,43 +2235,43 @@
</assertion>
<assertion id="ea">
- <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with a _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>
+ <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with a _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="eb">
- <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with a _stereotype_ 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>
+ <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with a _stereotype_ 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="ec">
- <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with an _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>
+ <text>For class X which is the bean class of a _simple_ bean Y declared using
XML, if X is annotated with an _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="ed">
- <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with a _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>
+ <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with a _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="ee">
- <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with a _stereotype_ 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>
+ <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with a _stereotype_ 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="ef">
- <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with an _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>
+ <text>For class X which is the bean class of a _session_ bean Y declared
using XML, if X is annotated with an _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="fa">
- <text>For class X which is the bean class of a _simple_ 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 meta-annotation and Y does not explicitly declare a scope type
using XML.</text>
+ <text>For class X which is the bean class of a _simple_ 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| meta-annotation and Y does not explicitly declare a scope type
using XML.</text>
</assertion>
<assertion id="fb">
- <text>For class X which is the bean class of a _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 meta-annotation and Y does not explicitly declare a
scope type using XML.</text>
+ <text>For class X which is the bean class of a _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| meta-annotation and Y does not explicitly declare a
scope type using XML.</text>
</assertion>
<assertion id="ga">
- <text>For class X which is the bean class of a _simple_ 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>
+ <text>For class X which is the bean class of a _simple_ 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="gb">
- <text>For class X which is the bean class of a _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>
+ <text>For class X which is the bean class of a _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="ha">
@@ -2290,27 +2283,27 @@
</assertion>
<assertion id="i" testable="false">
- <text>For annotations defined by the bean specification, all built-in _scope
types_ are declared @Inherited</text>
+ <text>For annotations defined by the bean specification, all built-in _scope
types_ are declared |@Inherited|</text>
<note>sigtest</note>
</assertion>
<assertion id="j" testable="false">
- <text>For annotations defined by the bean specification, all built-in
_stereotypes_ are declared @Inherited</text>
+ <text>For annotations defined by the bean specification, all built-in
_stereotypes_ are declared |@Inherited|</text>
<note>sigtest</note>
</assertion>
<assertion id="k" testable="false">
- <text>For annotations defined by the bean specification, _no built-in binding
type is declared @Inherited_</text>
+ <text>For annotations defined by the bean specification, _no built-in binding
type is declared |@Inherited|_</text>
<note>sigtest</note>
</assertion>
<assertion id="l" testable="false">
- <text>For annotations defined by the bean specification, _the built-in
deployment type is not declared @Inherited_</text>
+ <text>For annotations defined by the bean specification, _the built-in
deployment type is not declared |@Inherited|_</text>
<note>sigtest</note>
</assertion>
<assertion id="m" testable="false">
- <text>the @Named annotation is not declared @Inherited and bean names are not
inherited unless specialization is used</text>
+ <text>the |@Named| annotation is not declared |@Inherited| and bean names are
not inherited unless specialization is used</text>
<note>sigtest</note>
</assertion>
@@ -2335,35 +2328,35 @@
</assertion>
<assertion id="baa">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X declares a _@PostConstruct_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X declares a _|@PostConstruct|_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
</assertion>
<assertion id="bab">
- <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X declares a _@PostConstruct_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X declares a _|@PostConstruct|_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
</assertion>
<assertion id="bac">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X declares a _@PostConstruct_ 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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X declares a _|@PostConstruct|_ 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="bad">
- <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X declares a _@PostConstruct_ 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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X declares a _|@PostConstruct|_ 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="bba">
- <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X declares a _@PreDestroy_ method x() then Y inherits x() if and only
if Y does not override the method x()</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_simple_ bean Y, if X declares a _|@PreDestroy|_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
</assertion>
<assertion id="bbb">
- <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X declares a _@PreDestroy_ method x() then Y inherits x() if and only
if Y does not override the method x()</text>
+ <text>For class X which is extended _directly_ by the bean class of a
_session_ bean Y, if X declares a _|@PreDestroy|_ method x() then Y inherits x() if and
only if Y does not override the method x()</text>
</assertion>
<assertion id="bbc">
- <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X declares a _@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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_simple_ bean Y, if X declares a _|@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="bbd">
- <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X declares a _@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>
+ <text>For class X which is extended _indirectly_ by the bean class of a
_session_ bean Y, if X declares a _|@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="ca">
@@ -2594,11 +2587,11 @@
<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>
+ <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>
+ <text>A bean declared using XML may declare that it specializes a
lower-priority bean using the |<Specializes>| element</text>
</assertion>
<assertion id="c">
@@ -2610,7 +2603,7 @@
</assertion>
<assertion id="e">
- <text>If a bean X specializes a lower-priority bean Y with a name, and X
declares a name explicitly, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If a bean X specializes a lower-priority bean Y with a name, and X
declares a name explicitly, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="f">
@@ -2629,7 +2622,7 @@
<section id="4.3.2" title="Direct and indirect
specialization">
<assertion id="a" testable="false">
- <text>The @javax.inject.Specializes annotation or <Specializes>
XML element is used to indicate that one bean directly specializes another
bean</text>
+ <text>The |(a)javax.inject.Specializes| annotation or
|<Specializes>| XML element is used to indicate that one bean directly
specializes another bean</text>
<note>A statement of intent</note>
</assertion>
@@ -2657,7 +2650,7 @@
<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>
+ <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>
@@ -2676,12 +2669,12 @@
<section id="4.4.1" title="Using realization">
<assertion id="a" testable="false">
- <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>
+ <text>A bean declared using annotations may declare that it realizes a
generic class by annotating the bean class with the |(a)javax.inject.Realizes|
annotation</text>
<note>A statement of intent</note>
</assertion>
<assertion id="b" testable="false">
- <text>A bean declared using XML may declare that it realizes a generic class
using the <Realizes> element.</text>
+ <text>A bean declared using XML may declare that it realizes a generic class
using the |<Realizes>| element.</text>
<note>A statement of intent</note>
</assertion>
@@ -2722,8 +2715,7 @@
<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>
+ <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>
<note>These need expanding out - one for each assertion that results in an
exception in 5.7.1</note>
</assertion>
</section>
@@ -2739,27 +2731,27 @@
</assertion>
<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>
+ <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>
+ <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>
+ <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>
+ <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">
<assertion id="a">
- <text>Client proxies are never required for a bean whose scope is a
pseudo-scope such as @Dependent</text>
+ <text>Client proxies are never required for a bean whose scope is a
pseudo-scope such as |@Dependent|</text>
</assertion>
<assertion id="b">
@@ -2777,50 +2769,50 @@
<section id="5.4.1" title="Unproxyable bean types">
<assertion id="a">
- <text>Classes without a non-private constructor with no parameters cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an UnproxyableDependencyException is
thrown by the container at deployment time.</text>
+ <text>Classes without a non-private constructor with no parameters cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an |UnproxyableDependencyException|
is thrown by the container at deployment time.</text>
</assertion>
<assertion id="ba">
- <text>Classes which are declared final ~or have final methods~ cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an UnproxyableDependencyException is
thrown by the container at deployment time</text>
+ <text>Classes which are declared final ~or have final methods~ cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an |UnproxyableDependencyException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="bb">
- <text>Classes which ~are declared final or ~have final methods cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an UnproxyableDependencyException is
thrown by the container at deployment time</text>
+ <text>Classes which ~are declared final or ~have final methods cannot be
proxied by the container. If an injection point whose declared type cannot be proxied by
the container resolves to a bean with a normal scope, an |UnproxyableDependencyException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>Primitive types cannot be proxied by the container. If an injection
point whose declared type cannot be proxied by the container resolves to a bean with a
normal scope, an UnproxyableDependencyException is thrown by the container at deployment
time</text>
+ <text>Primitive types cannot be proxied by the container. If an injection
point whose declared type cannot be proxied by the container resolves to a bean with a
normal scope, an |UnproxyableDependencyException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="d">
- <text>Array types cannot be proxied by the container. If an injection point
whose declared type cannot be proxied by the container resolves to a bean with a normal
scope, an UnproxyableDependencyException is thrown by the container at deployment
time</text>
+ <text>Array types cannot be proxied by the container. If an injection point
whose declared type cannot be proxied by the container resolves to a bean with a normal
scope, an |UnproxyableDependencyException| is thrown by the container at deployment
time</text>
</assertion>
</section>
<section id="5.4.2" title="Client proxy invocation">
<assertion id="a">
- <text>Every time a method of the bean is invoked upon a client proxy, the
client proxy must obtain the context object by calling Manager.getContext(), passing the
bean scope, then obtain an instance of the bean by calling Context.get(), passing the Bean
instance representing the bean and an instance of CreationalContext, and invoke the method
upon the bean</text>
+ <text>Every time a method of the bean is invoked upon a client proxy, the
client proxy must obtain the context object by calling |Manager.getContext()|, passing the
bean scope, then obtain an instance of the bean by calling |Context.get()|, passing the
Bean instance representing the bean and an instance of |CreationalContext|, and invoke the
method upon the bean</text>
</assertion>
<assertion id="b">
- <text>The behavior of all methods declared by java.lang.Object, except for
toString(), is undefined for a client proxy</text>
+ <text>The behavior of all methods declared by |java.lang.Object|, except for
|toString()|, is undefined for a client proxy</text>
</assertion>
</section>
<section id="5.5" title="The default binding at injection
points">
<assertion id="a">
- <text>If an injection point declares no binding, the default binding @Current
is assumed</text>
+ <text>If an injection point declares no binding, the default binding
|@Current| is assumed</text>
</assertion>
</section>
<section id="5.6" title="Injection point metadata">
<assertion id="a">
- <text>The javax.inject.manager.InjectionPoint.getBean() method returns the
Bean object representing the bean that defines the injection point</text>
+ <text>The |javax.inject.manager.InjectionPoint.getBean()| method returns the
Bean object representing the bean that defines the injection point</text>
</assertion>
<assertion id="ba">
- <text>The javax.inject.manager.InjectionPoint.getType() method returns the
declared type of the injection point.</text>
+ <text>The |javax.inject.manager.InjectionPoint.getType()| method returns the
declared type of the injection point.</text>
</assertion>
<assertion id="bb">
@@ -2828,7 +2820,7 @@
</assertion>
<assertion id="bc">
- <text>The javax.inject.manager.InjectionPoint.getBindings() method returns
the declared bindings of the injection point.</text>
+ <text>The |javax.inject.manager.InjectionPoint.getBindings()| method returns
the declared bindings of the injection point.</text>
</assertion>
<assertion id="bd">
@@ -2836,51 +2828,51 @@
</assertion>
<assertion id="ca">
- <text>The javax.inject.manager.InjectionPoint.getMember() method returns the
Field object in the case of field injection</text>
+ <text>The |javax.inject.manager.InjectionPoint.getMember()| method returns
the |Field| object in the case of field injection</text>
</assertion>
<assertion id="cb">
- <text>The javax.inject.manager.InjectionPoint.getMember() method returns the
Method object in the case of method parameter injection</text>
+ <text>The |javax.inject.manager.InjectionPoint.getMember()| method returns
the |Method| object in the case of method parameter injection</text>
</assertion>
<assertion id="cc">
- <text>The javax.inject.manager.InjectionPoint.getMember() method returns the
Constructor object in the case of constructor parameter injection</text>
+ <text>The |javax.inject.manager.InjectionPoint.getMember()| method returns
the |Constructor| object in the case of constructor parameter injection</text>
</assertion>
<assertion id="da">
- <text>The javax.inject.manager.InjectionPoint.getAnnotation() method returns
annotations of the field in the case of field injection</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotation()| method
returns annotations of the field in the case of field injection</text>
</assertion>
<assertion id="db">
- <text>The javax.inject.manager.InjectionPoint.getAnnotation() method returns
annotations of the parameter in the case of method parameter</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotation()| method
returns annotations of the parameter in the case of method parameter</text>
</assertion>
<assertion id="dc">
- <text>The javax.inject.manager.InjectionPoint.getAnnotation() method returns
annotations annotations of the parameter in the case of constructor parameter
injection.</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotation()| method
returns annotations annotations of the parameter in the case of constructor parameter
injection.</text>
</assertion>
<assertion id="dd">
- <text>The javax.inject.manager.InjectionPoint.getAnnotations() method returns
annotations of the field in the case of field injection</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotations()| method
returns annotations of the field in the case of field injection</text>
</assertion>
<assertion id="de">
- <text>The javax.inject.manager.InjectionPoint.getAnnotations() method returns
annotations of the parameter in the case of method parameter</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotations()| method
returns annotations of the parameter in the case of method parameter</text>
</assertion>
<assertion id="df">
- <text>The javax.inject.manager.InjectionPoint.getAnnotations() method returns
annotations annotations of the parameter in the case of constructor parameter
injection.</text>
+ <text>The |javax.inject.manager.InjectionPoint.getAnnotations()| method
returns annotations annotations of the parameter in the case of constructor parameter
injection.</text>
</assertion>
<assertion id="dg">
- <text>getAnnotation() returns a null value if no annotation of the given type
exists at the field injection point</text>
+ <text>|getAnnotation()| returns a null value if no annotation of the given
type exists at the field injection point</text>
</assertion>
<assertion id="dh">
- <text>getAnnotation() returns a null value if no annotation of the given type
exists at the method parameter injection point</text>
+ <text>|getAnnotation()| returns a null value if no annotation of the given
type exists at the method parameter injection point</text>
</assertion>
<assertion id="di">
- <text>getAnnotation() returns a null value if no annotation of the given type
exists at the constructor injection point</text>
+ <text>|getAnnotation()| returns a null value if no annotation of the given
type exists at the constructor injection point</text>
</assertion>
</section>
@@ -2888,55 +2880,55 @@
<section id="5.6.1" title="Injecting InjectionPoint">
<assertion id="za">
- <text>The container must provide a bean with deployment type
@Standard.</text>
+ <text>The container must provide a bean with deployment type
|(a)Standard|.</text>
</assertion>
<assertion id="zb">
- <text>The container must provide a bean with scope @Dependent.</text>
+ <text>The container must provide a bean with scope
|(a)Dependent|.</text>
</assertion>
<assertion id="zc">
- <text>The container must provide a bean with bean type
InjectionPoint.</text>
+ <text>The container must provide a bean with bean type
|InjectionPoint|.</text>
</assertion>
<assertion id="zd">
- <text>The container must provide a bean with binding @Current.</text>
+ <text>The container must provide a bean with binding
|(a)Current|.</text>
</assertion>
<assertion id="a">
- <text>Whenever a @Dependent scoped object is instantiated by the container
for injection into a second bean, any injection point of type InjectionPoint and binding
@Current receives an instance of InjectionPoint that represents the injection point of the
second bean</text>
+ <text>Whenever a |@Dependent| scoped object is instantiated by the container
for injection into a second bean, any injection point of type |InjectionPoint| and binding
|@Current| receives an instance of |InjectionPoint| that represents the injection point of
the second bean</text>
</assertion>
<assertion id="b">
- <text>When a @Dependent scoped object is instantiated by the container to
receive a producer method, any injection point of type InjectionPoint and binding @Current
receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container to
receive a producer method, any injection point of type |InjectionPoint| and binding
|@Current| receives a null value</text>
</assertion>
<assertion id="c">
- <text>When a @Dependent scoped object is instantiated by the container to
receive a producer field, any injection point of type InjectionPoint and binding @Current
receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container to
receive a producer field, any injection point of type |InjectionPoint| and binding
|@Current| receives a null value</text>
</assertion>
<assertion id="d">
- <text>When a @Dependent scoped object is instantiated by the container to
receive an observer , any injection point of type InjectionPoint and binding @Current
receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container to
receive an observer , any injection point of type |InjectionPoint| and binding |@Current|
receives a null value</text>
</assertion>
<assertion id="e">
- <text>When a @Dependent scoped object is instantiated by the container to
receive a disposal method invocation, any injection point of type InjectionPoint and
binding @Current receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container to
receive a disposal method invocation, any injection point of type |InjectionPoint| and
binding |@Current| receives a null value</text>
</assertion>
<assertion id="f">
- <text>When a @Dependent scoped object is instantiated by the container during
EL expression evaluation, any injection point of type InjectionPoint and binding @Current
receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container
during EL expression evaluation, any injection point of type |InjectionPoint| and binding
|@Current| receives a null value</text>
</assertion>
<assertion id="g">
- <text>When a @Dependent scoped object is instantiated by the container as a
result of a direct call to the Manager API, any injection point of type InjectionPoint and
binding @Current receives a null value</text>
+ <text>When a |@Dependent| scoped object is instantiated by the container as a
result of a direct call to the Manager API, any injection point of type |InjectionPoint|
and binding |@Current| receives a null value</text>
</assertion>
<assertion id="h">
- <text>If a bean that declares any scope other than @Dependent has an
injection point of type InjectionPoint and binding @Current, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If a bean that declares any scope other than |@Dependent| has an
injection point of type |InjectionPoint| and binding |@Current|, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="i">
- <text>If an object that is not a bean has an injection point of type
InjectionPoint and binding @Current, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>If an object that is not a bean has an injection point of type
|InjectionPoint| and binding |@Current|, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
</section>
@@ -2946,127 +2938,126 @@
<section id="5.7.1" title="Resolving dependencies">
<assertion id="a">
- <text>Implementations of Bean maintain a reference to an instance of
Manager</text>
+ <text>Implementations of Bean maintain a reference to an instance of
|Manager|</text>
</assertion>
<assertion id="b">
- <text>When the Bean implementation performs dependency injection, it must
obtain the contextual instances to inject by calling Manager.getInstanceToInject(),
passing an instance of InjectionPoint that represents the injection point and the instance
of CreationalContext that was passed to Bean.create()</text>
+ <text>When the |Bean| implementation performs dependency injection, it must
obtain the contextual instances to inject by calling |Manager.getInstanceToInject()|,
passing an instance of |InjectionPoint| that represents the injection point and the
instance of |CreationalContext| that was passed to |Bean.create()|</text>
</assertion>
<assertion id="c">
- <text>Manager.getInstanceToInject() returns a contextual instance or client
proxy to be injected to the given injection point</text>
+ <text>|Manager.getInstanceToInject()| returns a contextual instance or client
proxy to be injected to the given injection point</text>
</assertion>
<assertion id="d">
- <text>The Manager.getInstanceToInject() method must Identify the bean by
calling Manager.resolveByType(), passing the type and bindings of the injection
point</text>
+ <text>The |Manager.getInstanceToInject()| method must Identify the bean by
calling |Manager.resolveByType()|, passing the type and bindings of the injection
point</text>
</assertion>
<assertion id="e">
- <text>The Manager.getInstanceToInject() method must throw an
UnsatisfiedDependencyException if resolveByType() did not return a bean</text>
+ <text>The |Manager.getInstanceToInject()| method must throw an
|UnsatisfiedDependencyException| if |resolveByType()| did not return a bean</text>
</assertion>
<assertion id="f">
- <text>The Manager.getInstanceToInject() method must throw an
AmbiguousDependencyException if resolveByType() returned more than one bean</text>
+ <text>The |Manager.getInstanceToInject()| method must throw an
|AmbiguousDependencyException| if |resolveByType()| returned more than one
bean</text>
</assertion>
<assertion id="g">
- <text>The Manager.getInstanceToInject() method must throw an
UnproxyableDependencyExceptionif the bean has a normal scope and the type cannot be
proxied by the container, as defined in Section 5.4.1, "Unproxyable bean
types"</text>
+ <text>The |Manager.getInstanceToInject()| method must throw an
|UnproxyableDependencyException| if the bean has a normal scope and the type cannot be
proxied by the container, as defined in Section 5.4.1, "Unproxyable bean
types"</text>
</assertion>
<assertion id="h">
- <text>The Manager.getInstanceToInject() method must obtain an instance of the
bean (or a client proxy) by calling Manager.getInstance(), passing the Bean object
representing the bean, and return it. Alternatively, return an incompletely initialized
instance of the bean that was
-registered by calling CreationalContext.push(), as defined in Section 6.1, "The
Contextual interface"</text>
+ <text>The |Manager.getInstanceToInject()| method must obtain an instance of
the bean (or a client proxy) by calling |Manager.getInstance()|, passing the |Bean| object
representing the bean, and return it. Alternatively, return an incompletely initialized
instance of the bean that was registered by calling |CreationalContext.push()|, as defined
in Section 6.1, "The Contextual interface"</text>
</assertion>
</section>
<section id="5.7.2" title="Obtaining contextual instances">
<assertion id="a">
- <text>Any bean may obtain an instance of Manager by injecting
it</text>
+ <text>Any bean may obtain an instance of |Manager| by injecting
it</text>
</assertion>
<assertion id="aa">
- <text>The container provides a built-in bean with bean type
Manager</text>
+ <text>The container provides a built-in bean with bean type
|Manager|</text>
</assertion>
<assertion id="ab">
- <text>The container-provided Manager bean has a scope type of
@Dependent</text>
+ <text>The container-provided |Manager| bean has a scope type of
|@Dependent|</text>
</assertion>
<assertion id="ac">
- <text>The container-provided Manager bean has a deployment type of
@Standard</text>
+ <text>The container-provided |Manager| bean has a deployment type of
|@Standard|</text>
</assertion>
<assertion id="ad">
- <text>The container-provided Manager bean has a binding of
@Current.</text>
+ <text>The container-provided |Manager| bean has a binding of
|(a)Current|.</text>
</assertion>
<assertion id="b">
- <text>The application may obtain the Manager object from JNDI. The container
must register an instance of Manager with name java:app/Manager in JNDI at deployment
time</text>
+ <text>The application may obtain the |Manager| object from JNDI. The
container must register an instance of |Manager| with name |java:app/Manager| in JNDI at
deployment time</text>
</assertion>
<assertion id="c">
- <text>A contextual instance of a bean may be obtained by calling
Manager.getInstance(), passing the Bean object representing the bean</text>
+ <text>A contextual instance of a bean may be obtained by calling
|Manager.getInstance()|, passing the |Bean| object representing the bean</text>
</assertion>
<assertion id="d">
- <text>Manager.getInstance() returns a contextual instance or client proxy for
the given bean</text>
+ <text>|Manager.getInstance()| returns a contextual instance or client proxy
for the given bean</text>
</assertion>
<assertion id="e">
- <text>If the given Bean instance represents a bean with a normal scope, as
defined in Section 8.2, "Normal scopes and pseudo-scopes", Manager.getInstance()
must return a client proxy</text>
+ <text>If the given Bean instance represents a bean with a normal scope, as
defined in Section 8.2, "Normal scopes and pseudo-scopes",
|Manager.getInstance()| must return a client proxy</text>
</assertion>
<assertion id="f">
- <text>If the Bean instance represents a bean with a pseudo-scope, as defined
in Section 8.2, "Normal scopes and pseudo-scopes", Manager.getInstance() must
obtain the context object by calling Manager.getContext(), passing the bean scope, then
obtain an instance of the bean by calling Context.get(), passing the Bean instance
representing the bean and an instance of CreationalContext</text>
+ <text>If the Bean instance represents a bean with a pseudo-scope, as defined
in Section 8.2, "Normal scopes and pseudo-scopes", |Manager.getInstance()| must
obtain the context object by calling |Manager.getContext()|, passing the bean scope, then
obtain an instance of the bean by calling |Context.get()|, passing the Bean instance
representing the bean and an instance of |CreationalContext|</text>
</assertion>
<assertion id="g" testable="false">
- <text>The Manager.getInstanceByType() methods obtain a contextual instance of
a bean</text>
+ <text>The |Manager.getInstanceByType()| methods obtain a contextual instance
of a bean</text>
<note>A statement of intent</note>
</assertion>
<assertion id="h">
- <text>If no bindings are passed to Manager.getInstanceByType(), the default
binding @Current is assumed</text>
+ <text>If no bindings are passed to |Manager.getInstanceByType()|, the default
binding |@Current| is assumed</text>
</assertion>
<assertion id="ia">
- <text>If a parameterized type with a type parameter ~or wildcard~ is passed
to resolveByType(), an IllegalArgumentException is thrown</text>
+ <text>If a parameterized type with a type parameter ~or wildcard~ is passed
to |resolveByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="ib">
- <text>If a parameterized type with a ~type parameter or~ wildcard is passed
to resolveByType(), an IllegalArgumentException is thrown</text>
+ <text>If a parameterized type with a ~type parameter or~ wildcard is passed
to |resolveByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="j">
- <text>If two instances of the same binding type are passed to
getInstanceByType(), a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to
|getInstanceByType()|, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="k">
- <text>If an instance of an annotation that is not a binding type is passed to
getInstanceByType(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|getInstanceByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="l">
- <text>The getInstanceByType() method must identify the bean by calling
Manager.resolveByType(), passing the given type and bindings</text>
+ <text>The |getInstanceByType()| method must identify the bean by calling
|Manager.resolveByType()|, passing the given type and bindings</text>
</assertion>
<assertion id="m">
- <text>The getInstanceByType() method must throw an
UnsatisfiedDependencyException if resolveByType() did not return a bean</text>
+ <text>The |getInstanceByType()| method must throw an
|UnsatisfiedDependencyException| if |resolveByType()| did not return a bean</text>
</assertion>
<assertion id="n">
- <text>The getInstanceByType() method must throw an
AmbiguousDependencyException if resolveByType() returned more than one bean</text>
+ <text>The |getInstanceByType()| method must throw an
|AmbiguousDependencyException| if |resolveByType()| returned more than one
bean</text>
</assertion>
<assertion id="o">
- <text>The getInstanceByType() method must obtain an instance of the bean (or
a client proxy) by calling Manager.getInstance(), passing the Bean object representing the
bean, and return it</text>
+ <text>The |getInstanceByType()| method must obtain an instance of the bean
(or a client proxy) by calling |Manager.getInstance()|, passing the Bean object
representing the bean, and return it</text>
</assertion>
</section>
<section id="5.8" title="Dynamic lookup">
<assertion id="a">
- <text>An instance of the javax.inject.Instance interface may be injected via
use of the
-(a)javax.inject.Obtains binding</text>
+ <text>An instance of the |javax.inject.Instance| interface may be injected
via use of the
+|(a)javax.inject.Obtains| binding</text>
</assertion>
<assertion id="b">
@@ -3074,94 +3065,94 @@
</assertion>
<assertion id="c">
- <text>The Instance interface provides a method for obtaining instances of
beans of a specific type</text>
+ <text>The |Instance| interface provides a method for obtaining instances of
beans of a specific type</text>
</assertion>
<assertion id="d">
- <text>If two instances of the same binding type are passed to Instance.get(),
a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to
|Instance.get()|, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to
Instance.get(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|Instance.get()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="f">
- <text>The @Obtains annotation or <Obtains> element may be
applied to any injection point of type Instance where an actual type parameter is
specified</text>
+ <text>The |@Obtains| annotation or |<Obtains>| element may be
applied to any injection point of type |Instance| where an actual type parameter is
specified</text>
</assertion>
<assertion id="g">
- <text>If the type of the injection point is not of type Instance a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the type of the injection point is not of type |Instance| a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="h">
- <text>If no actual type parameter is specified a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If no actual type parameter is specified a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="i">
- <text>If the type parameter contains a type variable a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If the type parameter contains a type variable a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="j">
- <text>If the type parameter contains a wildcard a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If the type parameter contains a wildcard a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="k">
- <text>Whenever the @Obtains annotation appears at an injection point, an
implicit bean exists with exactly the bean type and bindings that appear at the injection
point</text>
+ <text>Whenever the |@Obtains| annotation appears at an injection point, an
implicit bean exists with exactly the bean type and bindings that appear at the injection
point</text>
</assertion>
<assertion id="l">
- <text>Whenever the @Obtains annotation appears at an injection point, an
implicit bean exists with deployment type @Standard</text>
+ <text>Whenever the |@Obtains| annotation appears at an injection point, an
implicit bean exists with deployment type |@Standard|</text>
</assertion>
<assertion id="m">
- <text>Whenever the @Obtains annotation appears at an injection point, an
implicit bean exists with @Dependent scope</text>
+ <text>Whenever the |@Obtains| annotation appears at an injection point, an
implicit bean exists with |@Dependent| scope</text>
</assertion>
<assertion id="n">
- <text>Whenever the @Obtains annotation appears at an injection point, an
implicit bean exists with no bean name</text>
+ <text>Whenever the |@Obtains| annotation appears at an injection point, an
implicit bean exists with no bean name</text>
</assertion>
<assertion id="o">
- <text>Whenever the @Obtains annotation appears at an injection point, an
implicit bean exists with an implementation provided automatically by the
container</text>
+ <text>Whenever the |@Obtains| annotation appears at an injection point, an
implicit bean exists with an implementation provided automatically by the
container</text>
</assertion>
<assertion id="p">
- <text>The get() method of the provided implementation of Instance must call
Manager.getInstanceByType(), passing all bindings declared at the injection point, except
@Obtains, and all bindings passed to Instance.get()</text>
+ <text>The |get()| method of the provided implementation of Instance must call
|Manager.getInstanceByType()|, passing all bindings declared at the injection point,
except |@Obtains|, and all bindings passed to |Instance.get()|</text>
</assertion>
<assertion id="q">
- <text>The application may obtain a contextual instance by calling the
Instance.get() method</text>
+ <text>The application may obtain a contextual instance by calling the
|Instance.get()| method</text>
</assertion>
<assertion id="r">
- <text>When the application calls Instance.get() to obtain a contextual
instance dynamically, it may need to pass instances of binding annotation
types</text>
+ <text>When the application calls |Instance.get()| to obtain a contextual
instance dynamically, it may need to pass instances of binding annotation
types</text>
</assertion>
</section>
<section id="5.9" title="Typesafe resolution algorithm">
<assertion id="a">
- <text>The resolveByType() method of the Manager interface returns the result
of the typesafe resolution</text>
+ <text>The |resolveByType()| method of the |Manager| interface returns the
result of the typesafe resolution</text>
<note>Here we just do a general test that resolveByType() is producing
sensible results</note>
</assertion>
<assertion id="b">
- <text>If no bindings are passed to Manager.resolveByType(), the default
binding @Current is assumed</text>
+ <text>If no bindings are passed to |Manager.resolveByType()|, the default
binding |@Current| is assumed</text>
</assertion>
<assertion id="ca">
- <text>If a parameterized type with a type parameter ~or wildcard~ is passed
to Manager.resolveByType(), an IllegalArgumentException is thrown</text>
+ <text>If a parameterized type with a type parameter ~or wildcard~ is passed
to |Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="cb">
- <text>If a parameterized type with a ~type parameter or~ wildcard is passed
to Manager.resolveByType(), an IllegalArgumentException is thrown</text>
+ <text>If a parameterized type with a ~type parameter or~ wildcard is passed
to |Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="d">
- <text>If two instances of the same binding type are passed to
Manager.resolveByType(), a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to
|Manager.resolveByType()|, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to
Manager.resolveByType(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|Manager.resolveByType()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="fa">
@@ -3169,31 +3160,31 @@
</assertion>
<assertion id="fb">
- <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, primitive
types are considered to be identical to their corresponding wrapper types in java.lang~,
array types are considered identical only if their element types are identical and
parameterized types are considered identical only if both the type and all type parameters
are identical~</text>
+ <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, primitive
types are considered to be identical to their corresponding wrapper types in |java.lang|~,
array types are considered identical only if their element types are identical and
parameterized types are considered identical only if both the type and all type parameters
are identical~</text>
</assertion>
<assertion id="fc">
- <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, ~primitive
types are considered to be identical to their corresponding wrapper types in java.lang,~
array types are considered identical only if their element types are identical~ and
parameterized types are considered identical only if both the type and all type parameters
are identical~</text>
+ <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, ~primitive
types are considered to be identical to their corresponding wrapper types in |java.lang|,~
array types are considered identical only if their element types are identical~ and
parameterized types are considered identical only if both the type and all type parameters
are identical~</text>
</assertion>
<assertion id="fd">
- <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, ~primitive
types are considered to be identical to their corresponding wrapper types in java.lang,
array types are considered identical only if their element types are identical and~
parameterized types are considered identical only if both the type and all type parameters
are identical</text>
+ <text>When the container is resolving a bean by type~, it identifies the set
of matching enabled beans which have the given bean type~. For this purpose, ~primitive
types are considered to be identical to their corresponding wrapper types in |java.lang|,
array types are considered identical only if their element types are identical and~
parameterized types are considered identical only if both the type and all type parameters
are identical</text>
</assertion>
<assertion id="ga">
- <text>When the container is resolving a bean by type, it considers the given
bindings. _If no bindings were passed to resolveByType(), the container assumes the
binding @Current_. </text>
+ <text>When the container is resolving a bean by type, it considers the given
bindings. _If no bindings were passed to |resolveByType()|, the container assumes the
binding |@Current|_. </text>
</assertion>
<assertion id="gb">
- <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to resolveByType(), the container assumes the
binding @Current~. The container narrows the set of matching beans to just those where for
each given binding, the bean declares a binding with _(a) the same type_ and (b) the same
annotation member value for each member which is not annotated @NonBinding (see Section
5.9.1, "Binding annotations with members")</text>
+ <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the
binding |@Current|~. The container narrows the set of matching beans to just those where
for each given binding, the bean declares a binding with _(a) the same type_ and (b) the
same annotation member value for each member which is not annotated |@NonBinding| (see
Section 5.9.1, "Binding annotations with members")</text>
</assertion>
<assertion id="gc">
- <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to resolveByType(), the container assumes the
binding @Current~. The container narrows the set of matching beans to just those where for
each given binding, the bean declares a binding with (a) the same type and _(b) the same
annotation member value for each member_ which is not annotated @NonBinding (see Section
5.9.1, "Binding annotations with members")</text>
+ <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the
binding |@Current|~. The container narrows the set of matching beans to just those where
for each given binding, the bean declares a binding with (a) the same type and _(b) the
same annotation member value for each member_ which is not annotated |@NonBinding| (see
Section 5.9.1, "Binding annotations with members")</text>
</assertion>
<assertion id="gd">
- <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to resolveByType(), the container assumes the
binding @Current~. The container narrows the set of matching beans to just those where for
each given binding, the bean declares a binding with (a) the same type and (b) the same
annotation member value for each member which is _not annotated @NonBinding_ (see Section
5.9.1, "Binding annotations with members")</text>
+ <text>When the container is resolving a bean by type, it considers the given
bindings. ~If no bindings were passed to |resolveByType()|, the container assumes the
binding |@Current|~. The container narrows the set of matching beans to just those where
for each given binding, the bean declares a binding with (a) the same type and (b) the
same annotation member value for each member which is _not annotated |@NonBinding|_ (see
Section 5.9.1, "Binding annotations with members")</text>
</assertion>
<assertion id="ha">
@@ -3213,15 +3204,15 @@
</assertion>
<assertion id="b">
- <text>An annotation member may be excluded from consideration using the
@NonBinding annotation</text>
+ <text>An annotation member may be excluded from consideration using the
|@NonBinding| annotation</text>
</assertion>
<assertion id="ca">
- <text>Array-valued ~or annotation-valued~ members of a binding type must be
annotated @NonBinding. If an array-valued ~or annotation-valued~ member of a binding type
is not annotated @NonBinding, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Array-valued ~or annotation-valued~ members of a binding type must be
annotated |@NonBinding|. If an array-valued ~or annotation-valued~ member of a binding
type is not annotated |@NonBinding|, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="cb">
- <text>~Array-valued or ~annotation-valued members of a binding type must be
annotated @NonBinding. If an ~array-valued or ~annotation-valued member of a binding type
is not annotated @NonBinding, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>~Array-valued or ~annotation-valued members of a binding type must be
annotated |@NonBinding|. If an ~array-valued or ~annotation-valued member of a binding
type is not annotated |@NonBinding|, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
@@ -3256,34 +3247,33 @@
</assertion>
<assertion id="b">
- <text>When this resolver is called with a null base object, it calls the
method Manager.getInstanceByName() to obtain an instance of the bean named in the EL
expression</text>
+ <text>When this resolver is called with a null base object, it calls the
method |Manager.getInstanceByName()| to obtain an instance of the bean named in the EL
expression</text>
</assertion>
<assertion id="c">
- <text>The Manager.getInstanceByName() method must identify the bean by
calling Manager.resolveByName(), passing the name</text>
+ <text>The |Manager.getInstanceByName()| method must identify the bean by
calling |Manager.resolveByName()|, passing the name</text>
</assertion>
<assertion id="d">
- <text>The Manager.getInstanceByName() method must return a null value, if
Manager.resolveByName() returned an empty set</text>
+ <text>The |Manager.getInstanceByName()| method must return a null value, if
|Manager.resolveByName()| returned an empty set</text>
</assertion>
<assertion id="e">
- <text>The Manager.getInstanceByName() method must throw an
AmbiguousDependencyException if Manager.resolveByName() returned more than one
bean</text>
+ <text>The |Manager.getInstanceByName()| method must throw an
|AmbiguousDependencyException| if |Manager.resolveByName()| returned more than one
bean</text>
</assertion>
<assertion id="f">
- <text>The Manager.getInstanceByName() method must obtain an instance of the
bean by calling Manager.getInstance(), passing the Bean instance representing the bean if
exactly one bean was returned by Manager.resolveByName(). For each distinct name that
appears in the EL expression, getInstanceByName() must be called at most
once</text>
+ <text>The |Manager.getInstanceByName()| method must obtain an instance of the
bean by calling |Manager.getInstance()|, passing the |Bean| instance representing the bean
if exactly one bean was returned by |Manager.resolveByName()|. For each distinct name that
appears in the EL expression, |getInstanceByName()| must be called at most
once</text>
</assertion>
<assertion id="g">
- <text>Even if a
-name appears more than once in the same expression, the container may not call
getInstanceByName() multiple times with that name. This restriction ensures that there is
a unique instance of each bean with scope @Dependent in any EL evaluation</text>
+ <text>Even if a name appears more than once in the same expression, the
container may not call |getInstanceByName()| multiple times with that name. This
restriction ensures that there is a unique instance of each bean with scope |@Dependent|
in any EL evaluation</text>
</assertion>
</section>
<section id="5.11" title="Name resolution algorithm">
<assertion id="a">
- <text>The resolveByName() method of the Manager interface performs name
resolution</text>
+ <text>The |resolveByName()| method of the |Manager| interface performs name
resolution</text>
</assertion>
<assertion id="b">
@@ -3312,11 +3302,11 @@
</assertion>
<assertion id="b">
- <text>The container is required to perform dependency injection for session
bean instances injected using @EJB</text>
+ <text>The container is required to perform dependency injection for session
bean instances injected using |@EJB|</text>
</assertion>
<assertion id="c">
- <text>The container is required to perform dependency injection for session
bean instances injected using @Resource</text>
+ <text>The container is required to perform dependency injection for session
bean instances injected using |@Resource|</text>
</assertion>
<assertion id="d">
@@ -3332,11 +3322,11 @@
</assertion>
<assertion id="g">
- <text>The container is required to create interceptor stacks for session bean
instances injected using @EJB</text>
+ <text>The container is required to create interceptor stacks for session bean
instances injected using |@EJB|</text>
</assertion>
<assertion id="h">
- <text>The container is required to create interceptor stacks for session bean
instances injected using @Resource</text>
+ <text>The container is required to create interceptor stacks for session bean
instances injected using |@Resource|</text>
</assertion>
<assertion id="i">
@@ -3352,11 +3342,11 @@
</assertion>
<assertion id="l">
- <text>The container is required to create decorator stacks for session bean
instances injected using @EJB</text>
+ <text>The container is required to create decorator stacks for session bean
instances injected using |@EJB|</text>
</assertion>
<assertion id="m">
- <text>The container is required to create decorator stacks for session bean
instances injected using @Resource</text>
+ <text>The container is required to create decorator stacks for session bean
instances injected using |@Resource|</text>
</assertion>
<assertion id="n">
@@ -3368,15 +3358,15 @@
</assertion>
<assertion id="p">
- <text>For the purposes of dependency injection, the container must treat
non-contextual instances of session beans as instances of the most specialized bean that
specializes the bean with binding @New and deployment type @Standard defined in Section
3.3.6, "Session beans with the @New binding"</text>
+ <text>For the purposes of dependency injection, the container must treat
non-contextual instances of session beans as instances of the most specialized bean that
specializes the bean with binding |@New| and deployment type |@Standard| defined in
Section 3.3.6, "Session beans with the |@New| binding"</text>
</assertion>
<assertion id="q">
- <text>For the purposes of interceptor stack creation, the container must
treat non-contextual instances of session beans as instances of the most specialized bean
that specializes the bean with binding @New and deployment type @Standard defined in
Section 3.3.6, "Session beans with the @New binding"</text>
+ <text>For the purposes of interceptor stack creation, the container must
treat non-contextual instances of session beans as instances of the most specialized bean
that specializes the bean with binding |@New| and deployment type |@Standard| defined in
Section 3.3.6, "Session beans with the |@New| binding"</text>
</assertion>
<assertion id="r">
- <text>For the purposes of decorator stack creation, the container must treat
non-contextual instances of session beans as instances of the most specialized bean that
specializes the bean with binding @New and deployment type @Standard defined in Section
3.3.6, "Session beans with the @New binding"</text>
+ <text>For the purposes of decorator stack creation, the container must treat
non-contextual instances of session beans as instances of the most specialized bean that
specializes the bean with binding |@New| and deployment type |@Standard| defined in
Section 3.3.6, "Session beans with the |@New| binding"</text>
</assertion>
</section>
@@ -3445,69 +3435,69 @@
<section id="6.1" title="The Contextual interface">
<assertion id="a" testable="false">
- <text>The interface javax.context.CreationalContext provides an operation
that allows the create() method to register an incompletely initialized contextual
instance with the container. A contextual instance is considered incompletely initialized
until the create() method returns the instance</text>
+ <text>The interface |javax.context.CreationalContext| provides an operation
that allows the |create()| method to register an incompletely initialized contextual
instance with the container. A contextual instance is considered incompletely initialized
until the |create()| method returns the instance</text>
<note>Statement of intent</note>
</assertion>
<assertion id="b">
- <text>If Contextual.create() calls CreationalContext.push(), it must also
return the instance passed to push()</text>
+ <text>If |Contextual.create()| calls |CreationalContext.push()|, it must also
return the instance passed to |push()|</text>
</assertion>
<assertion id="c" testable="false">
- <text>The implementation of Contextual is not required to call
CreationalContext.push()</text>
+ <text>The implementation of |Contextual| is not required to call
|CreationalContext.push()|</text>
<note>No way to test this really</note>
</assertion>
</section>
<section id="6.2" title="Creation">
<assertion id="a">
- <text>The Contextual.create() method obtains an instance of the
bean</text>
+ <text>The |Contextual.create()| method obtains an instance of the
bean</text>
</assertion>
<assertion id="b">
- <text>The Contextual.create() method creates the interceptor stacks and binds
them to the instance</text>
+ <text>The |Contextual.create()| method creates the interceptor stacks and
binds them to the instance</text>
</assertion>
<assertion id="c">
- <text>The Contextual.create() method creates the decorator stacks and binds
them to the instance</text>
+ <text>The |Contextual.create()| method creates the decorator stacks and binds
them to the instance</text>
</assertion>
<assertion id="d">
- <text>The Contextual.create() method injects any dependencies</text>
+ <text>The |Contextual.create()| method injects any dependencies</text>
</assertion>
<assertion id="e">
- <text>The Contextual.create() method sets any initial field values defined in
XML</text>
+ <text>The |Contextual.create()| method sets any initial field values defined
in XML</text>
</assertion>
<assertion id="f">
- <text>The Contextual.create() method calls the @PostConstruct method, if
necessary</text>
+ <text>The |Contextual.create()| method calls the |@PostConstruct| method, if
necessary</text>
</assertion>
<assertion id="g">
- <text>If any exception occurs while creating an instance, the exception is
rethrown by the create() method</text>
+ <text>If any exception occurs while creating an instance, the exception is
rethrown by the |create()| method</text>
</assertion>
<assertion id="h">
- <text>If a checked exception occurs while creating an instance, it is wrapped
and rethrown as an (unchecked) CreationException</text>
+ <text>If a checked exception occurs while creating an instance, it is wrapped
and rethrown as an (unchecked) |CreationException|</text>
</assertion>
</section>
<section id="6.3" title="Destruction">
<assertion id="a">
- <text>The Contextual.destroy() method calls the disposal method, if
necessary</text>
+ <text>The |Contextual.destroy()| method calls the disposal method, if
necessary</text>
</assertion>
<assertion id="b">
- <text>The Contextual.destroy() method calls the @PreDestroy method, if
necessary</text>
+ <text>The |Contextual.destroy()| method calls the |@PreDestroy method|, if
necessary</text>
</assertion>
<assertion id="c">
- <text>The Contextual.destroy() method destroys all dependent objects of the
instance, as defined in Section 8.3.2, "Dependent object
destruction"</text>
+ <text>The |Contextual.destroy()| method destroys all dependent objects of the
instance, as defined in Section 8.3.2, "Dependent object
destruction"</text>
</assertion>
<assertion id="d">
- <text>If any exception occurs while destroying an instance, the exception is
caught by the destroy() method</text>
+ <text>If any exception occurs while destroying an instance, the exception is
caught by the |destroy()| method</text>
</assertion>
<assertion id="e" testable="false">
@@ -3518,62 +3508,62 @@
<section id="6.4" title="Lifecycle of simple beans">
<assertion id="a">
- <text>When the create() method of the Bean object that represents a simple
bean is called, the container first calls the bean constructor to obtain an instance of
the bean. For each constructor parameter, the container passes the object returned by
Manager.getInstanceToInject(). The container is permitted to return an instance of a
container-generated subclass of the bean class, allowing interceptor and decorator
bindings</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, the container first calls the bean constructor to obtain an
instance of the bean. For each constructor parameter, the container passes the object
returned by |Manager.getInstanceToInject()|. The container is permitted to return an
instance of a container-generated subclass of the bean class, allowing interceptor and
decorator bindings</text>
</assertion>
<assertion id="b">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the bean constructor is called the container next initializes the
values of any attributes annotated @EJB</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the bean constructor is called the container next initializes
the values of any attributes annotated |@EJB|</text>
</assertion>
<assertion id="c">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the bean constructor is called the container next initializes the
values of any attributes annotated @PersistenceContext</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the bean constructor is called the container next initializes
the values of any attributes annotated |@PersistenceContext|</text>
</assertion>
<assertion id="d">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the bean constructor is called the container next initializes the
values of any attributes annotated @Resource</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the bean constructor is called the container next initializes
the values of any attributes annotated |@Resource|</text>
</assertion>
<assertion id="e">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the @EJB, @PersistenceContext and @Resource attributes are
initialized the container initializes the values of all injected fields. For each injected
field, the container sets the value to the object returned by
Manager.getInstanceToInject().</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the |@EJB|, |@PersistenceContext| and |@Resource| attributes
are initialized the container initializes the values of all injected fields. For each
injected field, the container sets the value to the object returned by
|Manager.getInstanceToInject()|.</text>
</assertion>
<assertion id="f">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after injected fields are initialized the container initializes the values
of any fields with initial values specified in XML, as defined in Section 9.5.5,
"Field initial value declarations".</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after injected fields are initialized the container initializes the
values of any fields with initial values specified in XML, as defined in Section 9.5.5,
"Field initial value declarations".</text>
</assertion>
<assertion id="g">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the values of fields with initial values specified in XML are
initialized the container calls all initializer methods. For each initializer method
parameter, the container passes the object
-returned by Manager.getInstanceToInject()</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the values of fields with initial values specified in XML are
initialized the container calls all initializer methods. For each initializer method
parameter, the container passes the object
+returned by |Manager.getInstanceToInject()|</text>
</assertion>
<assertion id="h">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after all initializer methods are called the container builds the
interceptor stacks for the instance as defined in Section A.3.10 "Interceptor stack
creation"</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after all initializer methods are called the container builds the
interceptor stacks for the instance as defined in Section A.3.10 "Interceptor stack
creation"</text>
</assertion>
<assertion id="i">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after all initializer methods are called the container builds the
decorator stacks for the instance as defined in Section A.5.8 "Decorator stack
creation"</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after all initializer methods are called the container builds the
decorator stacks for the instance as defined in Section A.5.8 "Decorator stack
creation"</text>
</assertion>
<assertion id="j">
- <text>When the create() method of the Bean object that represents a simple
bean is called, after the interceptor and decorator stacks are built the container calls
the @PostConstruct method, if any</text>
+ <text>When the |create()| method of the |Bean| object that represents a
simple bean is called, after the interceptor and decorator stacks are built the container
calls the |@PostConstruct| method, if any</text>
</assertion>
<assertion id="k">
- <text>When the destroy() method of a Bean object is called, the container
calls the @PreDestroy method, if any</text>
+ <text>When the |destroy()| method of a |Bean| object is called, the container
calls the |@PreDestroy| method, if any</text>
</assertion>
<assertion id="l">
- <text>When the destroy() method of a Bean object is called, after the
container calls the @PreDestroy method, it finally destroys dependent
objects</text>
+ <text>When the |destroy()| method of a |Bean| object is called, after the
container calls the |@PreDestroy| method, it finally destroys dependent
objects</text>
</assertion>
</section>
<section id="6.5" title="Lifecycle of stateful session
beans">
<assertion id="a">
- <text>When the create() method of a Bean object that represents a stateful
session bean that is called, the container creates and returns a session bean proxy, as
defined in Section 3.3.9, "Session bean proxies".</text>
+ <text>When the |create()| method of a |Bean| object that represents a
stateful session bean that is called, the container creates and returns a session bean
proxy, as defined in Section 3.3.9, "Session bean proxies".</text>
</assertion>
<assertion id="b">
- <text>When the destroy() method of a Bean object is called, the container
removes the stateful session bean. The @PreDestroy callback must be invoked by the
container</text>
+ <text>When the |destroy()| method of a |Bean| object is called, the container
removes the stateful session bean. The |@PreDestroy| callback must be invoked by the
container</text>
</assertion>
<assertion id="c">
@@ -3583,11 +3573,11 @@
<section id="6.6" title="Lifecycle of stateless session and singleton
beans">
<assertion id="a">
- <text>When the create() method of a Bean object that represents a stateless
session or singleton session bean is called, the container creates and returns a session
bean proxy, as defined in Section 3.3.9, "Session bean proxies".</text>
+ <text>When the |create()| method of a |Bean| object that represents a
stateless session or singleton session bean is called, the container creates and returns a
session bean proxy, as defined in Section 3.3.9, "Session bean
proxies".</text>
</assertion>
<assertion id="b" testable="false">
- <text>When the destroy() method of a Bean object is called, the container
simply discards the proxy and all underlying EJB local object references</text>
+ <text>When the |destroy()| method of a |Bean| object is called, the container
simply discards the proxy and all underlying EJB local object references</text>
<note>Untestable</note>
</assertion>
</section>
@@ -3613,7 +3603,7 @@
</assertion>
<assertion id="e">
- <text>When the create() method of a Bean object that represents a producer
method is called, the container must invoke the producer method, passing the object
returned by Manager.getInstanceToInject() to each parameter</text>
+ <text>When the |create()| method of a |Bean| object that represents a
producer method is called, the container must invoke the producer method, passing the
object returned by |Manager.getInstanceToInject()| to each parameter</text>
</assertion>
<assertion id="f">
@@ -3621,11 +3611,11 @@
</assertion>
<assertion id="g">
- <text>If a producer method is not static, the container must obtain the Bean
object for the most specialized bean that specializes the bean which declares the producer
method</text>
+ <text>If a producer method is not static, the container must obtain the
|Bean| object for the most specialized bean that specializes the bean which declares the
producer method</text>
</assertion>
<assertion id="h">
- <text>If a producer method is not static, after obtaining the most
specialized Bean object the container must obtain an instance of the most specialized
bean, by calling Manager.getInstance(), passing the Bean object representing the
bean</text>
+ <text>If a producer method is not static, after obtaining the most
specialized |Bean| object the container must obtain an instance of the most specialized
bean, by calling |Manager.getInstance()|, passing the |Bean| object representing the
bean</text>
</assertion>
<assertion id="i">
@@ -3633,19 +3623,19 @@
</assertion>
<assertion id="j">
- <text>The return value of the producer method, after method interception
completes, is the new contextual instance to be returned by Bean.create()</text>
+ <text>The return value of the producer method, after method interception
completes, is the new contextual instance to be returned by |Bean.create()|</text>
</assertion>
<assertion id="k">
- <text>If the producer method returns a null value and the producer method
bean has the scope @Dependent, the create() method returns a null value</text>
+ <text>If the producer method returns a null value and the producer method
bean has the scope |@Dependent|, the |create()| method returns a null value</text>
</assertion>
<assertion id="l">
- <text>If the producer method returns a null value, and the scope of the
producer method is not @Dependent, the create() method throws an
IllegalProductException</text>
+ <text>If the producer method returns a null value, and the scope of the
producer method is not |@Dependent|, the |create()| method throws an
|IllegalProductException|</text>
</assertion>
<assertion id="m">
- <text>When the destroy() method is called, and if there is a disposal method
for this producer method, the container must invoke the disposal method, passing the
instance given to destroy() to the disposed parameter, and the object returned by
Manager.getInstanceToInject() to each of the other parameters</text>
+ <text>When the |destroy()| method is called, and if there is a disposal
method for this producer method, the container must invoke the disposal method, passing
the instance given to |destroy()| to the disposed parameter, and the object returned by
|Manager.getInstanceToInject()| to each of the other parameters</text>
</assertion>
<assertion id="n">
@@ -3653,11 +3643,11 @@
</assertion>
<assertion id="o">
- <text>If a disposal method is non-static, the container must obtain the Bean
object for the most specialized bean that specializes the bean which declares the disposal
method</text>
+ <text>If a disposal method is non-static, the container must obtain the
|Bean| object for the most specialized bean that specializes the bean which declares the
disposal method</text>
</assertion>
<assertion id="p">
- <text>If a disposal method is non-static, after obtaining the Bean object for
the most specialized bean, the container must obtain an instance of the most specialized
bean, by calling Manager.getInstance(), passing the Bean object representing the
bean</text>
+ <text>If a disposal method is non-static, after obtaining the |Bean| object
for the most specialized bean, the container must obtain an instance of the most
specialized bean, by calling |Manager.getInstance()|, passing the |Bean| object
representing the bean</text>
</assertion>
<assertion id="q">
@@ -3699,7 +3689,7 @@
</assertion>
<assertion id="g">
- <text>When the create() method of a Bean object that represents a producer
field is called, the container must access the producer field to obtain the current value
of the field</text>
+ <text>When the |create()| method of a |Bean| object that represents a
producer field is called, the container must access the producer field to obtain the
current value of the field</text>
</assertion>
<assertion id="h">
@@ -3707,11 +3697,11 @@
</assertion>
<assertion id="i">
- <text>If a producer field is non-static, the container must obtain the Bean
object for the most specialized bean that specializes the bean which declares the producer
field</text>
+ <text>If a producer field is non-static, the container must obtain the |Bean|
object for the most specialized bean that specializes the bean which declares the producer
field</text>
</assertion>
<assertion id="j">
- <text>If a producer field is non-static, after obtaining the Bean object for
the most specialized bean the container must obtain an instance of the most specialized
bean, by calling Manager.getInstance(), passing the Bean object representing the
bean</text>
+ <text>If a producer field is non-static, after obtaining the |Bean| object
for the most specialized bean the container must obtain an instance of the most
specialized bean, by calling |Manager.getInstance()|, passing the |Bean| object
representing the bean</text>
</assertion>
<assertion id="k">
@@ -3719,15 +3709,15 @@
</assertion>
<assertion id="l">
- <text>The value of the producer field is the new contextual instance to be
returned by Bean.create()</text>
+ <text>The value of the producer field is the new contextual instance to be
returned by |Bean.create()|</text>
</assertion>
<assertion id="m">
- <text>If the producer field contains a null value and the producer field bean
has the scope @Dependent, the create() method returns a null value</text>
+ <text>If the producer field contains a null value and the producer field bean
has the scope |@Dependent|, the create() method returns a null value</text>
</assertion>
<assertion id="n">
- <text>If the producer field contains a null value, and the scope of the
producer method is not @Dependent, the create() method throws an
IllegalProductException</text>
+ <text>If the producer field contains a null value, and the scope of the
producer method is not |@Dependent|, the |create()| method throws an
|IllegalProductException|</text>
</assertion>
</section>
@@ -3745,7 +3735,7 @@
</assertion>
<assertion id="d">
- <text>When the create() method of a Bean object that represents a JMS
resource is called, the container creates and returns a proxy object that implements the
bean type of the resource</text>
+ <text>When the |create()| method of a |Bean| object that represents a JMS
resource is called, the container creates and returns a proxy object that implements the
bean type of the resource</text>
</assertion>
<assertion id="e">
@@ -3753,27 +3743,27 @@
</assertion>
<assertion id="f">
- <text>A Java EE resource is obtained using the JNDI name or mapped name
specified by <Resource></text>
+ <text>A Java EE resource is obtained using the JNDI name or mapped name
specified by |<Resource>|</text>
</assertion>
<assertion id="g">
- <text>A persistence context is obtained using the persistence unit name
specified by <PersistenceContext></text>
+ <text>A persistence context is obtained using the persistence unit name
specified by |<PersistenceContext>|</text>
</assertion>
<assertion id="h">
- <text>A persistence unit is obtained using the persistence unit name
specified by <PersistenceUnit></text>
+ <text>A persistence unit is obtained using the persistence unit name
specified by |<PersistenceUnit>|</text>
</assertion>
<assertion id="i">
- <text>A remote EJB is obtained using the JNDI name, mapped name or EJB link
specified by <EJB></text>
+ <text>A remote EJB is obtained using the JNDI name, mapped name or EJB link
specified by |<EJB>|</text>
</assertion>
<assertion id="j">
- <text>A web service is obtained using the JNDI name or mapped name specified
by <WebServiceRef></text>
+ <text>A web service is obtained using the JNDI name or mapped name specified
by |<WebServiceRef>|</text>
</assertion>
<assertion id="k">
- <text>When the destroy() method is called, the container discards the proxy
object</text>
+ <text>When the |destroy()| method is called, the container discards the proxy
object</text>
</assertion>
</section>
@@ -3791,7 +3781,7 @@
</assertion>
<assertion id="d">
- <text>When the create() method of a Bean object that represents a JMS
resource is called, the container creates and returns a proxy object that implements all
the bean types of the JMS resource</text>
+ <text>When the |create()| method of a |Bean| object that represents a JMS
resource is called, the container creates and returns a proxy object that implements all
the bean types of the JMS resource</text>
</assertion>
<assertion id="e">
@@ -3799,15 +3789,15 @@
</assertion>
<assertion id="f">
- <text>The Destination is obtained using the JNDI name or mapped name
specified by <Resource></text>
+ <text>The Destination is obtained using the JNDI name or mapped name
specified by |<Resource>|</text>
</assertion>
<assertion id="g">
- <text>The appropriate ConnectionFactory for the topic or queue is obtained
automatically</text>
+ <text>The appropriate |ConnectionFactory| for the topic or queue is obtained
automatically</text>
</assertion>
<assertion id="h">
- <text>The Connection is obtained by calling
QueueConnectionFactory.createQueueConnection() or
TopicConnectionFactory.createTopicConnection()</text>
+ <text>The |Connection| is obtained by calling
|QueueConnectionFactory.createQueueConnection()| or
|TopicConnectionFactory.createTopicConnection()|</text>
</assertion>
<assertion id="i" testable="false">
@@ -3815,23 +3805,23 @@
</assertion>
<assertion id="j">
- <text>The Session object is obtained by calling
QueueConnection.createQueueSession() or TopicConnection.createTopicSession()</text>
+ <text>The |Session| object is obtained by calling
|QueueConnection.createQueueSession()| or
|TopicConnection.createTopicSession()|</text>
</assertion>
<assertion id="k">
- <text>The MessageProducer object is obtained by calling
QueueSession.createSender() or TopicSession.createPublisher()</text>
+ <text>The |MessageProducer| object is obtained by calling
|QueueSession.createSender()| or |TopicSession.createPublisher()|</text>
</assertion>
<assertion id="l">
- <text>The MessageConsumer object is obtained by calling
QueueSession.createReceiver() or TopicSession.createSubscriber()</text>
+ <text>The |MessageConsumer| object is obtained by calling
|QueueSession.createReceiver()| or |TopicSession.createSubscriber()|</text>
</assertion>
<assertion id="m">
- <text>When the destroy() method is called, the container must ensure that all
JMS objects created by the proxy object are destroyed by calling close() if
necessary</text>
+ <text>When the |destroy()| method is called, the container must ensure that
all JMS objects created by the proxy object are destroyed by calling |close()| if
necessary</text>
</assertion>
<assertion id="n">
- <text>The Connection is destroyed by calling Connection.close() if
necessary</text>
+ <text>The |Connection| is destroyed by calling |Connection.close()| if
necessary</text>
</assertion>
<assertion id="o">
@@ -3839,58 +3829,56 @@
</assertion>
<assertion id="p">
- <text>The Session object is destroyed by calling
Session.close()</text>
+ <text>The |Session| object is destroyed by calling
|Session.close()|</text>
</assertion>
<assertion id="q">
- <text>The MessageProducer object is destroyed by calling
MessageProducer.close()</text>
+ <text>The |MessageProducer| object is destroyed by calling
|MessageProducer.close()|</text>
</assertion>
<assertion id="r">
- <text>The MessageConsumer object is destroyed by calling
MessageConsumer.close()</text>
+ <text>The |MessageConsumer| object is destroyed by calling
|MessageConsumer.close()|</text>
</assertion>
<assertion id="s">
- <text>The close() method of a JMS resource proxy object always throws an
UnsupportedOperationException</text>
+ <text>The |close()| method of a JMS resource proxy object always throws an
|UnsupportedOperationException|</text>
</assertion>
</section>
<section id="6.11" title="Lifecycle of EJBs">
<assertion id="a">
- <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the @PostConstruct callback occurs the container
must initialize the values of all injected fields . For each injected field, the
container sets the value to the
-object returned by Manager.getInstanceToInject()</text>
+ <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the |@PostConstruct| callback occurs the container
must initialize the values of all injected fields . For each injected field, the
container sets the value to the object returned by
|Manager.getInstanceToInject()|</text>
</assertion>
<assertion id="b">
- <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the @PostConstruct callback occurs the container
must initialize the values of any fields with initial values specified in XML, as defined
in Section 9.5.5, "Field initial value declarations"</text>
+ <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the |@PostConstruct| callback occurs the container
must initialize the values of any fields with initial values specified in XML, as defined
in Section 9.5.5, "Field initial value declarations"</text>
</assertion>
<assertion id="c">
- <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the @PostConstruct callback occurs the container
calls all initializer methods. For each initializer method parameter, the container passes
the object returned by Manager.getInstanceToInject()</text>
+ <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the |@PostConstruct| callback occurs the container
calls all initializer methods. For each initializer method parameter, the container passes
the object returned by |Manager.getInstanceToInject()|</text>
</assertion>
<assertion id="d">
- <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the @PostConstruct callback occurs the container
builds the interceptor stacks for the instance as defined in Section A.3.10,
"Interceptor stack creation" and Section A.5.8, "Decorator stack
creation" and binds them to the instance</text>
+ <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the |@PostConstruct| callback occurs the container
builds the interceptor stacks for the instance as defined in Section A.3.10,
"Interceptor stack creation" and Section A.5.8, "Decorator stack
creation" and binds them to the instance</text>
</assertion>
<assertion id="e">
- <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the @PostConstruct callback occurs the container
builds the decorator stacks for the instance as defined in Section A.3.10,
"Interceptor stack creation" and Section A.5.8, "Decorator stack
creation" and binds them to the instance</text>
+ <text>When the EJB container creates a new instance of an EJB, after Java EE
injection has been performed and before the |@PostConstruct| callback occurs the container
builds the decorator stacks for the instance as defined in Section A.3.10,
"Interceptor stack creation" and Section A.5.8, "Decorator stack
creation" and binds them to the instance</text>
</assertion>
<assertion id="f">
- <text>When the EJB container removes an instance of an EJB, the container
destroys all dependent objects, after the @PreDestroy callback completes</text>
+ <text>When the EJB container removes an instance of an EJB, the container
destroys all dependent objects, after the |@PreDestroy| callback completes</text>
</assertion>
</section>
<section id="6.12" title="Lifecycle of servlets">
<assertion id="a">
- <text>When the servlet container creates a new instance of a servlet, the
container initializes the values of all injected fields. For each injected field, the
container sets the value to the object returned by
Manager.getInstanceToInject()</text>
+ <text>When the servlet container creates a new instance of a servlet, the
container initializes the values of all injected fields. For each injected field, the
container sets the value to the object returned by
|Manager.getInstanceToInject()|</text>
</assertion>
<assertion id="b">
- <text>When the servlet container creates a new instance of a servlet, the
container calls all initializer methods. For each initializer method parameter, the
container passes the object
-returned by Manager.getInstanceToInject()</text>
+ <text>When the servlet container creates a new instance of a servlet, the
container calls all initializer methods. For each initializer method parameter, the
container passes the object returned by |Manager.getInstanceToInject()|</text>
</assertion>
<assertion id="c">
@@ -3921,20 +3909,20 @@
</assertion>
<assertion id="d">
- <text>An event binding type is a Java annotation defined as @Target({FIELD,
PARAMETER}) ~or @Target({METHOD, FIELD, PARAMETER, TYPE}) and
@Retention(RUNTIME)~</text>
+ <text>An event binding type is a Java annotation defined as |@Target({FIELD,
PARAMETER})| ~or |@Target({METHOD, FIELD, PARAMETER, TYPE})| and
|@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="e">
- <text>An event binding type is a Java annotation defined as ~@Target({FIELD,
PARAMETER}) or~ @Target({METHOD, FIELD, PARAMETER, TYPE}) ~and
@Retention(RUNTIME)~</text>
+ <text>An event binding type is a Java annotation defined as ~|@Target({FIELD,
PARAMETER})| or~ |@Target({METHOD, FIELD, PARAMETER, TYPE})| ~and
|@Retention(RUNTIME)|~</text>
</assertion>
<assertion id="f" testable="false">
- <text>An event binding type is a Java annotation defined as ~@Target({FIELD,
PARAMETER}) or @Target({METHOD, FIELD, PARAMETER, TYPE}) and
~@Retention(RUNTIME)</text>
+ <text>An event binding type is a Java annotation defined as ~|@Target({FIELD,
PARAMETER})| or |@Target({METHOD, FIELD, PARAMETER, TYPE})| and
~|@Retention(RUNTIME)|</text>
<note>The compiler discards non-runtime-retention annotation</note>
</assertion>
<assertion id="g">
- <text>All event binding types must specify the @javax.inject.BindingType
meta-annotation</text>
+ <text>All event binding types must specify the |(a)javax.inject.BindingType|
meta-annotation</text>
</assertion>
<assertion id="h">
@@ -3946,35 +3934,34 @@
<section id="7.2" title="Firing an event via the Manager
interface">
<assertion id="a">
- <text>The Manager interface provides the fireEvent() method for firing
events</text>
+ <text>The |Manager| interface provides the |fireEvent()| method for firing
events</text>
</assertion>
<assertion id="b">
- <text>If the type of the event object passed to fireEvent() contains [type
variables] or wildcards, an IllegalArgumentException is thrown</text>
+ <text>If the type of the event object passed to |fireEvent()| contains [type
variables] or wildcards, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="c">
- <text>If the type of the event object passed to fireEvent() contains type
variables or [wildcards], an IllegalArgumentException is thrown</text>
+ <text>If the type of the event object passed to |fireEvent()| contains type
variables or [wildcards], an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="d">
- <text>If an instance of an annotation that is not a binding type is passed to
fireEvent(), an IllegalArgumentException is thrown. (Not in PRD2, but should appear in
next revision)</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|fireEvent()|, an |IllegalArgumentException| is thrown. (Not in PRD2, but should appear in
next revision)</text>
</assertion>
</section>
<section id="7.3" title="Observing events via the Observer
interface">
<assertion id="a">
- <text>Observers of events implement the javax.event.Observer
interface</text>
+ <text>Observers of events implement the |javax.event.Observer|
interface</text>
</assertion>
<assertion id="b">
- <text>An observer instance may be registered with the container by calling
Manager.addObserver()</text>
+ <text>An observer instance may be registered with the container by calling
|Manager.addObserver()|</text>
</assertion>
<assertion id="c">
- <text>In the signature of Manager.addObserver(), the first parameter is the
observer object, the second parameter is the observed event type, and the remaining
parameters are
-optional observed event bindings</text>
+ <text>In the signature of |Manager.addObserver()|, the first parameter is the
observer object, the second parameter is the observed event type, and the remaining
parameters are optional observed event bindings</text>
</assertion>
<assertion id="d">
@@ -3982,58 +3969,58 @@
</assertion>
<assertion id="e">
- <text>An observer instance may be deregistered by calling
Manager.removeObserver()</text>
+ <text>An observer instance may be deregistered by calling
|Manager.removeObserver()|</text>
</assertion>
<assertion id="f">
- <text>If the observed event type passed to ~addObserver()~ or
removeObserver() contains ~type variables~ or wildcards, an IllegalArgumentException is
thrown</text>
+ <text>If the observed event type passed to ~|addObserver()|~ or
|removeObserver()| contains ~type variables~ or wildcards, an |IllegalArgumentException|
is thrown</text>
</assertion>
<assertion id="g">
- <text>If the observed event type passed to ~addObserver()~ or
removeObserver() contains type variables or ~wildcards~, an IllegalArgumentException is
thrown</text>
+ <text>If the observed event type passed to ~|addObserver()|~ or
|removeObserver()| contains type variables or ~wildcards~, an |IllegalArgumentException|
is thrown</text>
</assertion>
<assertion id="h">
- <text>If the observed event type passed to addObserver() or
~removeObserver()~ contains ~type variables~ or wildcards, an IllegalArgumentException is
thrown</text>
+ <text>If the observed event type passed to |addObserver()| or
~|removeObserver()|~ contains ~type variables~ or wildcards, an |IllegalArgumentException|
is thrown</text>
</assertion>
<assertion id="i">
- <text>If the observed event type passed to addObserver() or
~removeObserver()~ contains type variables or ~wildcards~, an IllegalArgumentException is
thrown</text>
+ <text>If the observed event type passed to |addObserver()| or
~|removeObserver()|~ contains type variables or ~wildcards~, an |IllegalArgumentException|
is thrown</text>
</assertion>
<assertion id="j">
- <text>If two instances of the same binding type are passed to ~addObserver()~
or removeObserver(), a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to
~|addObserver()|~ or |removeObserver()|, a |DuplicateBindingTypeException| is
thrown</text>
</assertion>
<assertion id="k">
- <text>If two instances of the same binding type are passed to addObserver()
or ~removeObserver()~, a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to |addObserver()|
or ~|removeObserver()|~, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="l">
- <text>If an instance of an annotation that is not a binding type is passed to
~addObserver()~ or removeObserver(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
~|addObserver()|~ or |removeObserver()|, an |IllegalArgumentException| is
thrown</text>
</assertion>
<assertion id="m">
- <text>If an instance of an annotation that is not a binding type is passed to
addObserver() or ~removeObserver()~, an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|addObserver()| or ~|removeObserver()|~, an |IllegalArgumentException| is
thrown</text>
</assertion>
</section>
<section id="7.4" title="Observer notification">
<assertion id="a">
- <text>When an event is fired by the application the container must determine
the observers for that event by calling Manager.resolveObservers(), passing the event
object and all event bindings</text>
+ <text>When an event is fired by the application the container must determine
the observers for that event by calling |Manager.resolveObservers()|, passing the event
object and all event bindings</text>
</assertion>
<assertion id="b">
- <text>When an event is fired by the application the container must, for each
observer, call the notify() method of the Observer interface, passing the event
object</text>
+ <text>When an event is fired by the application the container must, for each
observer, call the |notify()| method of the Observer interface, passing the event
object</text>
</assertion>
<assertion id="c">
- <text>If an observer throws an exception, the exception aborts processing of
the event. No other observers of that event will be called. The fireEvent() method
rethrows the exception</text>
+ <text>If an observer throws an exception, the exception aborts processing of
the event. No other observers of that event will be called. The |fireEvent()| method
rethrows the exception</text>
</assertion>
<assertion id="d">
- <text>Any observer called before completion of a transaction may call
setRollbackOnly() to force a transaction rollback</text>
+ <text>Any observer called before completion of a transaction may call
|setRollbackOnly()| to force a transaction rollback</text>
</assertion>
<assertion id="e">
@@ -4086,35 +4073,33 @@
</assertion>
<assertion id="c">
- <text>If the type of the event parameter contains type variables or
wildcards, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If the type of the event parameter contains type variables or
wildcards, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
</section>
<section id="7.5.2" title="Declaring an observer method using
annotations">
<assertion id="a">
- <text>A observer method may be declared using annotations by annotating a
parameter @javax.event.Observes. That parameter is the event parameter.</text>
+ <text>A observer method may be declared using annotations by annotating a
parameter |(a)javax.event.Observes|. That parameter is the event parameter.</text>
</assertion>
<assertion id="b">
- <text>If a method has more than one parameter annotated @Observes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a method has more than one parameter annotated |@Observes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If an observer method is annotated @Produces a DefinitionException
-is thrown by the container at deployment time</text>
+ <text>If an observer method is annotated |@Produces| a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If an observer method is annotated @Initializer a DefinitionException
-is thrown by the container at deployment time</text>
+ <text>If an observer method is annotated |@Initializer| a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
- <text>If an observer method has a parameter annotated @Disposes, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If an observer method has a parameter annotated |@Disposes|, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="f">
- <text>If a non-static method of a session bean class has a parameter
annotated @Observes, and the method is not a business method of the EJB, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If a non-static method of a session bean class has a parameter
annotated |@Observes|, and the method is not a business method of the EJB, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="g">
@@ -4124,7 +4109,7 @@
<section id="7.5.3" title="Declaring an observer method using
XML">
<assertion id="a">
- <text>For a beans defined in XML, an observer method may be declared using
the method name, the <Observes> element, and the parameter types of the
method</text>
+ <text>For a beans defined in XML, an observer method may be declared using
the method name, the |<Observes>| element, and the parameter types of the
method</text>
</assertion>
<assertion id="b">
@@ -4132,13 +4117,13 @@
</assertion>
<assertion id="c">
- <text>If the bean class of a bean declared in XML does not have a method with
parameters that match those declared in XML, a DefinitionException is thrown by the
container at deployment time</text>
+ <text>If the bean class of a bean declared in XML does not have a method with
parameters that match those declared in XML, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="7.5.4" title="Observer method parameters">
<assertion id="a">
- <text>In addition to the event parameter, observer methods may declare
additional parameters, which may declare bindings. The container calls the method
Manager.getInstanceToInject() defined in Section 5.7.1, "Resolving dependencies"
to determine a value for each parameter of an observer method and calls the observer
method with those parameter values</text>
+ <text>In addition to the event parameter, observer methods may declare
additional parameters, which may declare bindings. The container calls the method
|Manager.getInstanceToInject()| defined in Section 5.7.1, "Resolving
dependencies" to determine a value for each parameter of an observer method and calls
the observer method with those parameter values</text>
</assertion>
</section>
@@ -4148,11 +4133,11 @@
</assertion>
<assertion id="b">
- <text>A conditional observer methods may be declared by annotating the event
parameter with the @javax.event.IfExists annotation</text>
+ <text>A conditional observer methods may be declared by annotating the event
parameter with the |(a)javax.event.IfExists| annotation</text>
</assertion>
<assertion id="c">
- <text>Conditional observer methods may be declared in XML by adding a child
<IfExists> element to the <Observes> element</text>
+ <text>Conditional observer methods may be declared in XML by adding a child
|<IfExists>| element to the |<Observes>| element</text>
</assertion>
</section>
@@ -4182,37 +4167,37 @@
</assertion>
<assertion id="g">
- <text>A transactional observer method may be declared by annotating the event
parameter of the observer method or ~in XML by a child element of the
<Observes> element~</text>
+ <text>A transactional observer method may be declared by annotating the event
parameter of the observer method or ~in XML by a child element of the
|<Observes>| element~</text>
</assertion>
<assertion id="h">
- <text>The @javax.event.BeforeTransactionCompletion annotation or
<BeforeTransactionCompletion> element specifies that the observer method is
a before completion observer method</text>
+ <text>The |(a)javax.event.BeforeTransactionCompletion| annotation or
|<BeforeTransactionCompletion>| element specifies that the observer method
is a before completion observer method</text>
</assertion>
<assertion id="i">
- <text>The @javax.event.AfterTransactionCompletion annotation or
<AfterTransactionCompletion> element specifies that the observer method is
an after completion observer method</text>
+ <text>The |(a)javax.event.AfterTransactionCompletion| annotation or
|<AfterTransactionCompletion>| element specifies that the observer method is
an after completion observer method</text>
</assertion>
<assertion id="j">
- <text>The @javax.event.AfterTransactionSuccess annotation or
<AfterTransactionSuccess> element specifies that the observer method is an
after success observer method</text>
+ <text>The |(a)javax.event.AfterTransactionSuccess| annotation or
|<AfterTransactionSuccess>| element specifies that the observer method is an
after success observer method</text>
</assertion>
<assertion id="k">
- <text>The @javax.event.AfterTransactionFailure annotation or
<AfterTransactionFailure> element specifies that the observer method is an
after failure observer method</text>
+ <text>The |(a)javax.event.AfterTransactionFailure| annotation or
|<AfterTransactionFailure>| element specifies that the observer method is an
after failure observer method</text>
</assertion>
<assertion id="l">
- <text>A transactional observer method may not specify more than one of the
four types. If a transactional observer method specifies more than one of the four types,
a DefinitionException is thrown by the container at deployment time</text>
+ <text>A transactional observer method may not specify more than one of the
four types. If a transactional observer method specifies more than one of the four types,
a |DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="7.5.7" title="Asynchronous observer methods">
<assertion id="a">
- <text>An asynchronous observer method may be declared by ~annotating the
event parameter of the observer method @javax.event.Asynchronously~ or in XML by a child
<Asynchronously> element of the <Observes>
element</text>
+ <text>An asynchronous observer method may be declared by ~annotating the
event parameter of the observer method |(a)javax.event.Asynchronously|~ or in XML by a child
|<Asynchronously>| element of the |<Observes>|
element</text>
</assertion>
<assertion id="b">
- <text>An asynchronous observer method may be declared by annotating the event
parameter of the observer method @javax.event.Asynchronously or ~in XML by a child
<Asynchronously> element of the <Observes>
element~</text>
+ <text>An asynchronous observer method may be declared by annotating the event
parameter of the observer method |(a)javax.event.Asynchronously| or ~in XML by a child
|<Asynchronously>| element of the |<Observes>|
element~</text>
</assertion>
<assertion id="c">
@@ -4220,11 +4205,11 @@
</assertion>
<assertion id="d">
- <text>If an asynchronous observer method is also a transactional observer
method, it ~may not be a before completion observer method~ or a conditional observer
method. If an asynchronous observer method is specified as a before completion or
conditional observer method, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>If an asynchronous observer method is also a transactional observer
method, it ~may not be a before completion observer method~ or a conditional observer
method. If an asynchronous observer method is specified as a before completion or
conditional observer method, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="e">
- <text>If an asynchronous observer method is also a transactional observer
method, it may not be a before completion observer method or a ~conditional observer
method~. If an asynchronous observer method is specified as a before completion or
conditional observer method, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>If an asynchronous observer method is also a transactional observer
method, it may not be a before completion observer method or a ~conditional observer
method~. If an asynchronous observer method is specified as a before completion or
conditional observer method, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
@@ -4234,15 +4219,15 @@
</assertion>
<assertion id="b">
- <text>The notify() method of the Observer implementation for an observer
method either invokes the observer method ~immediately~, or asynchronously, or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization</text>
+ <text>The |notify()| method of the |Observer| implementation for an observer
method either invokes the observer method ~immediately~, or asynchronously, or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization</text>
</assertion>
<assertion id="c">
- <text>The notify() method of the Observer implementation for an observer
method either invokes the observer method immediately, ~or asynchronously~, or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization</text>
+ <text>The |notify()| method of the |Observer| implementation for an observer
method either invokes the observer method immediately, ~or asynchronously~, or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization</text>
</assertion>
<assertion id="d">
- <text>The notify() method of the Observer implementation for an observer
method either invokes the observer method immediately, or asynchronously, ~or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization~</text>
+ <text>The |notify()| method of the |Observer| implementation for an observer
method either invokes the observer method immediately, or asynchronously, ~or registers
the observer method for later invocation during the transaction completion phase, using a
JTA Synchronization~</text>
</assertion>
<assertion id="e">
@@ -4267,7 +4252,7 @@
</assertion>
<assertion id="j">
- <text>To invoke an observer method, the container must pass the event object
to the event parameter and the object returned by Manager.getInstanceToInject() to each of
the other parameters</text>
+ <text>To invoke an observer method, the container must pass the event object
to the event parameter and the object returned by |Manager.getInstanceToInject()| to each
of the other parameters</text>
</assertion>
<assertion id="k">
@@ -4275,7 +4260,7 @@
</assertion>
<assertion id="l">
- <text>If the observer method is non-static, the container must obtain the
Bean object for the most specialized bean that specializes the bean which declares the
observer method</text>
+ <text>If the observer method is non-static, the container must obtain the
|Bean| object for the most specialized bean that specializes the bean which declares the
observer method</text>
</assertion>
<assertion id="m">
@@ -4295,15 +4280,15 @@
</assertion>
<assertion id="q">
- <text>If the observer isn't a transactional or asynchronous observer
method, the exception is rethrown by the notify() method of the observer
object</text>
+ <text>If the observer isn't a transactional or asynchronous observer
method, the exception is rethrown by the |notify()| method of the observer
object</text>
</assertion>
<assertion id="r">
- <text>If the exception is a checked exception, it is wrapped and rethrown as
an (unchecked) ObserverException</text>
+ <text>If the exception is a checked exception, it is wrapped and rethrown as
an (unchecked) |ObserverException|</text>
</assertion>
<assertion id="s">
- <text>The observer object is registered by calling Manager.addObserver(),
passing the event parameter type as the observed event type, and the bindings of the event
parameter as the observed event bindings</text>
+ <text>The observer object is registered by calling |Manager.addObserver()|,
passing the event parameter type as the observed event type, and the bindings of the event
parameter as the observed event bindings</text>
</assertion>
</section>
@@ -4313,7 +4298,7 @@
</assertion>
<assertion id="b">
- <text>If the observer method is a @BeforeTransactionCompletion transactional
observer method, it is called within the context of the transaction that is about to
complete and with the same client security context and lifecycle contexts</text>
+ <text>If the observer method is a |@BeforeTransactionCompletion|
transactional observer method, it is called within the context of the transaction that is
about to complete and with the same client security context and lifecycle
contexts</text>
</assertion>
<assertion id="c">
@@ -4321,124 +4306,123 @@
</assertion>
<assertion id="d">
- <text>If an observer method is not an asynchronous observer method, and not a
@BeforeTransactionCompletion transactional method, and not any other kind of transactional
observer method, then the observer method is called in the same transaction context,
client security context and lifecycle contexts as the invocation of
Event.fire()</text>
+ <text>If an observer method is not an asynchronous observer method, and not a
|@BeforeTransactionCompletion| transactional method, and not any other kind of
transactional observer method, then the observer method is called in the same transaction
context, client security context and lifecycle contexts as the invocation of
|Event.fire()|</text>
</assertion>
<assertion id="e">
- <text>The transaction and security contexts for a business method of a
session bean also depend upon the transaction attribute and @RunAs descriptor, if
any</text>
+ <text>The transaction and security contexts for a business method of a
session bean also depend upon the transaction attribute and |@RunAs| descriptor, if
any</text>
</assertion>
</section>
<section id="7.6" title="The Event interface">
<assertion id="a">
- <text>An instance of the javax.event.Event interface may be injected via use
of the @javax.event.Fires binding</text>
+ <text>An instance of the |javax.event.Event| interface may be injected via
use of the |(a)javax.event.Fires| binding</text>
</assertion>
<assertion id="b">
- <text>Additional bindings may be specified at the injection point for
javax.event.Event</text>
+ <text>Additional bindings may be specified at the injection point for
|javax.event.Event|</text>
</assertion>
<assertion id="c">
- <text>The Event interface provides a method for firing events of a specific
type</text>
+ <text>The |Event| interface provides a method for firing events of a specific
type</text>
</assertion>
<assertion id="d">
- <text>The Event interface provides a method for registering observers for
-events of the same type</text>
+ <text>The |Event| interface provides a method for registering observers for
events of the same type</text>
</assertion>
<assertion id="e">
- <text>The first parameter of the fire() method is the event object. The
remaining parameters are event bindings</text>
+ <text>The first parameter of the |fire()| method is the event object. The
remaining parameters are event bindings</text>
</assertion>
<assertion id="f">
- <text>The first parameter of the observe() method is the observer object. The
remaining parameters are the observed event bindings</text>
+ <text>The first parameter of the |observe()| method is the observer object.
The remaining parameters are the observed event bindings</text>
</assertion>
<assertion id="g">
- <text>If two instances of the same binding type are passed to fire() or
observes(), a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to |fire()| or
|observes()|, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="h">
- <text>If an instance of an annotation that is not a binding type is passed to
fire() or observes(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|fire()| or |observes()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="i">
- <text>The @Fires annotation or <Fires> element may be applied
to any injection point of type Event, where an actual type parameter is
specified</text>
+ <text>The |@Fires| annotation or |<Fires>| element may be
applied to any injection point of type |Event|, where an actual type parameter is
specified</text>
</assertion>
<assertion id="j">
- <text>If the type of the injection point is not of type Event a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the type of the injection point is not of type |Event| a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="k">
- <text>If the type of the injection point has no actual type parameter
specified a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If the type of the injection point has no actual type parameter
specified a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="l">
- <text>If the type of the injection point parameter contains a type variable a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the type of the injection point parameter contains a type variable a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="m">
- <text>If the type of the injection point parameter contains a wildcard a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the type of the injection point parameter contains a wildcard a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="n">
- <text>Whenever the @Fires annotation appears at an injection point, an
implicit bean exists with exactly the bean type and bindings that appear at the injection
point</text>
+ <text>Whenever the |@Fires| annotation appears at an injection point, an
implicit bean exists with exactly the bean type and bindings that appear at the injection
point</text>
</assertion>
<assertion id="o">
- <text>Whenever the @Fires annotation appears at an injection point, an
implicit bean exists with deployment type @Standard,</text>
+ <text>Whenever the |@Fires| annotation appears at an injection point, an
implicit bean exists with deployment type |@Standard|,</text>
</assertion>
<assertion id="p">
- <text>Whenever the @Fires annotation appears at an injection point, an
implicit bean exists with @Dependent scope</text>
+ <text>Whenever the |@Fires| annotation appears at an injection point, an
implicit bean exists with |@Dependent| scope</text>
</assertion>
<assertion id="q">
- <text>Whenever the @Fires annotation appears at an injection point, an
implicit bean exists with no bean name</text>
+ <text>Whenever the |@Fires| annotation appears at an injection point, an
implicit bean exists with no bean name</text>
</assertion>
<assertion id="r">
- <text>Whenever the @Fires annotation appears at an injection point, an
implicit bean exists with an implementation provided automatically by the
container</text>
+ <text>Whenever the |@Fires| annotation appears at an injection point, an
implicit bean exists with an implementation provided automatically by the
container</text>
</assertion>
<assertion id="s">
- <text>The fire() method of the provided implementation of Event must call
Manager.fireEvent(), passing the event object passed to Event.fire(), all bindings
declared at the injection point (except @Fires), and all bindings passed to
Event.fire()</text>
+ <text>The |fire()| method of the provided implementation of |Event| must call
|Manager.fireEvent()|, passing the event object passed to |Event.fire()|, all bindings
declared at the injection point (except |@Fires|), and all bindings passed to
|Event.fire()|</text>
</assertion>
<assertion id="t">
- <text>The application may fire events by calling the fire()
method</text>
+ <text>The application may fire events by calling the |fire()|
method</text>
</assertion>
<assertion id="u">
- <text>The observe() method of the provided implementation of Event must call
Manager.addObserver(), passing the observer object passed to Event.observe(), all bindings
declared at the injection point (except @Fires), and all bindings passed to
Event.observer()</text>
+ <text>The |observe()| method of the provided implementation of |Event| must
call |Manager.addObserver()|, passing the observer object passed to |Event.observe()|, all
bindings declared at the injection point (except |@Fires|), and all bindings passed to
|Event.observer()|</text>
</assertion>
<assertion id="v">
- <text>The application may register observers by calling the observe()
method</text>
+ <text>The application may register observers by calling the |observe()|
method</text>
</assertion>
</section>
<section id="7.7" title="Observer resolution">
<assertion id="a">
- <text>The method Manager.resolveObservers() resolves observers for an event -
the first parameter of resolveObservers() is the event object. The remaining parameters
are event bindings</text>
+ <text>The method |Manager.resolveObservers()| resolves observers for an event
- the first parameter of |resolveObservers()| is the event object. The remaining
parameters are event bindings</text>
</assertion>
<assertion id="b">
- <text>If the type of the event object passed to resolveObservers() contains
type variables, an IllegalArgumentException is thrown</text>
+ <text>If the type of the event object passed to |resolveObservers()| contains
type variables, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="c">
- <text>If the type of the event object passed to resolveObservers() contains
wildcards, an IllegalArgumentException is thrown</text>
+ <text>If the type of the event object passed to |resolveObservers()| contains
wildcards, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="d">
- <text>If two instances of the same binding type are passed to
resolveObservers(), a DuplicateBindingTypeException is thrown</text>
+ <text>If two instances of the same binding type are passed to
|resolveObservers()|, a |DuplicateBindingTypeException| is thrown</text>
</assertion>
<assertion id="e">
- <text>If an instance of an annotation that is not a binding type is passed to
resolveObservers(), an IllegalArgumentException is thrown</text>
+ <text>If an instance of an annotation that is not a binding type is passed to
|resolveObservers()|, an |IllegalArgumentException| is thrown</text>
</assertion>
<assertion id="f">
@@ -4446,17 +4430,17 @@
</assertion>
<assertion id="g">
- <text>When searching for observers for an event, for each observed event
binding, (a) an instance of the binding type must have been passed to fireEvent() and (b)
any member values of the binding type must match the member values of the instance passed
to fireEvent()</text>
+ <text>When searching for observers for an event, for each observed event
binding, (a) an instance of the binding type must have been passed to |fireEvent()| and
(b) any member values of the binding type must match the member values of the instance
passed to |fireEvent()|</text>
</assertion>
</section>
<section id="7.7.1" title="Event binding types with
members">
<assertion id="a">
- <text>The binding type for an Event binding may have annotation
members</text>
+ <text>The binding type for an |Event| binding may have annotation
members</text>
</assertion>
<assertion id="b" testable="false">
- <text>The container uses equals() to compare event binding type member
values</text>
+ <text>The container uses |equals()| to compare event binding type member
values</text>
<note>Since only primitive types are allowed, the call to equals() cannot be
checked</note>
</assertion>
</section>
@@ -4485,7 +4469,7 @@
</assertion>
<assertion id="c">
- <text>All observers of mapped event types must be asynchronous observer
methods. If an observer for a mapped event type is not an asynchronous observer method, a
DeploymentException is thrown by the container at deployment time</text>
+ <text>All observers of mapped event types must be asynchronous observer
methods. If an observer for a mapped event type is not an asynchronous observer method, a
|DeploymentException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
@@ -4508,39 +4492,39 @@
<section id="8.1" title="The Context interface">
<assertion id="a">
- <text>The get() method of the Context object may return an existing instance
of the given contextual type</text>
+ <text>The |get()| method of the |Context| object may return an existing
instance of the given contextual type</text>
</assertion>
<assertion id="b">
- <text>The get() method of the Context object may return a null value if no
CreationalContext is given</text>
+ <text>The |get()| method of the |Context| object may return a null value if
no |CreationalContext| is given</text>
</assertion>
<assertion id="c">
- <text>The get() method of the Context object may create a new instance of the
given contextual type by calling Contextual.create() and return the new instance, if a
CreationalContext is given</text>
+ <text>The |get()| method of the |Context| object may create a new instance of
the given contextual type by calling |Contextual.create()| and return the new instance, if
a |CreationalContext| is given</text>
</assertion>
<assertion id="d">
- <text>The get() method of a Context object may not return a null value unless
no CreationalContext is given, or Contextual.create() returns a null value</text>
+ <text>The |get()| method of a |Context| object may not return a null value
unless no |CreationalContext| is given, or |Contextual.create()| returns a null
value</text>
</assertion>
<assertion id="e">
- <text>The get() method of a Context object may not create a new instance of
the given contextual type unless a CreationalContext is given</text>
+ <text>The |get()| method of a |Context| object may not create a new instance
of the given contextual type unless a |CreationalContext| is given</text>
</assertion>
<assertion id="f">
- <text>The Context implementation is responsible for destroying any contextual
instance it creates by passing the instance to the destroy() method of the Contextual
object representing the contextual type</text>
+ <text>The |Context| implementation is responsible for destroying any
contextual instance it creates by passing the instance to the |destroy()| method of the
|Contextual| object representing the contextual type</text>
</assertion>
<assertion id="g">
- <text>A destroyed instance must not subsequently be returned by a Context
object's get() method</text>
+ <text>A destroyed instance must not subsequently be returned by a |Context|
object's |get()| method</text>
</assertion>
<assertion id="h">
- <text>When a scope is inactive, any invocation of the get() from the current
thread upon the Context object for that scope results in a
ContextNotActiveException</text>
+ <text>When a scope is inactive, any invocation of the |get()| from the
current thread upon the |Context| object for that scope results in a
|ContextNotActiveException|</text>
</assertion>
<assertion id="i">
- <text>The isActive() method returns false when the scope of the context
object is inactive, and true when it is active</text>
+ <text>The |isActive()| method returns false when the scope of the context
object is inactive, and true when it is active</text>
</assertion>
</section>
@@ -4556,11 +4540,11 @@
</assertion>
<assertion id="c">
- <text>The get() operation of the Context object for an active normal scope
returns the current instance of the given contextual type</text>
+ <text>The |get()| operation of the |Context| object for an active normal
scope returns the current instance of the given contextual type</text>
</assertion>
<assertion id="d">
- <text>When a context is destroyed, all mapped instances of contextual types
with that scope are destroyed by passing them to the Contextual.destroy()
method</text>
+ <text>When a context is destroyed, all mapped instances of contextual types
with that scope are destroyed by passing them to the |Contextual.destroy()|
method</text>
</assertion>
<assertion id="e">
@@ -4568,12 +4552,12 @@
</assertion>
<assertion id="f" testable="false">
- <text>All pseudo-scopes must be explicitly declared @ScopeType(normal=false),
to indicate to the container that no client proxy is required</text>
+ <text>All pseudo-scopes must be explicitly declared
|@ScopeType(normal=false)|, to indicate to the container that no client proxy is
required</text>
<note>A statement of intent</note>
</assertion>
<assertion id="g" testable="false">
- <text>All scopes defined by this specification, except for the @Dependent
pseudo-scope, are normal scopes</text>
+ <text>All scopes defined by this specification, except for the |@Dependent|
pseudo-scope, are normal scopes</text>
<note>A statement of intent</note>
</assertion>
</section>
@@ -4581,72 +4565,72 @@
<section id="8.3" title="Dependent pseudo-scope">
<assertion id="a">
- <text>When a bean is declared to have @Dependent scope, no injected instance
of the bean is ever shared between multiple injection points</text>
+ <text>When a bean is declared to have |@Dependent| scope, no injected
instance of the bean is ever shared between multiple injection points</text>
</assertion>
<assertion id="b">
- <text>When a bean is declared to have @Dependent scope, any injected instance
of the bean is bound to the lifecycle of the bean, servlet or EJB into which it is
injected</text>
+ <text>When a bean is declared to have |@Dependent| scope, any injected
instance of the bean is bound to the lifecycle of the bean, servlet or EJB into which it
is injected</text>
</assertion>
<assertion id="c">
- <text>When a bean is declared to have @Dependent scope, any instance of the
bean that is used to evaluate a Unified EL expression exists to service that evaluation
only</text>
+ <text>When a bean is declared to have |@Dependent| scope, any instance of the
bean that is used to evaluate a Unified EL expression exists to service that evaluation
only</text>
</assertion>
<assertion id="d">
- <text>When a bean is declared to have @Dependent scope, any instance of the
bean that receives a producer method, producer field, disposal method or observer method
invocation exists to service that invocation only</text>
+ <text>When a bean is declared to have |@Dependent| scope, any instance of the
bean that receives a producer method, producer field, disposal method or observer method
invocation exists to service that invocation only</text>
</assertion>
<assertion id="e">
- <text>Every invocation of the get() operation of the Context object for the
@Dependent scope with a CreationalContext returns a new instance of the given
bean</text>
+ <text>Every invocation of the |get()| operation of the |Context| object for
the |@Dependent| scope with a |CreationalContext| returns a new instance of the given
bean</text>
</assertion>
<assertion id="f">
- <text>Every invocation of the get() operation of the Context object for the
@Dependent scope with no CreationalContext returns a null value</text>
+ <text>Every invocation of the |get()| operation of the |Context| object for
the |@Dependent| scope with no |CreationalContext| returns a null value</text>
</assertion>
<assertion id="g">
- <text>The @Dependent scope is inactive except when an instance of a bean with
scope @Dependent is created by the container to receive a producer method, producer field,
disposal method or observer method invocation</text>
+ <text>The |@Dependent| scope is inactive except when an instance of a bean
with scope |@Dependent| is created by the container to receive a producer method, producer
field, disposal method or observer method invocation</text>
<note>Assertions g through k are all related and should be treated as
"or" conditions</note>
</assertion>
<assertion id="h">
- <text>The @Dependent scope is inactive except while a Unified EL expression
is evaluated</text>
+ <text>The |@Dependent| scope is inactive except while a Unified EL expression
is evaluated</text>
</assertion>
<assertion id="i">
- <text>The @Dependent scope is inactive except while an observer method is
invoked</text>
+ <text>The |@Dependent| scope is inactive except while an observer method is
invoked</text>
</assertion>
<assertion id="j">
- <text>The @Dependent scope is inactive except when the container is creating
or destroying a contextual instance of a bean or injecting its dependencies</text>
+ <text>The |@Dependent| scope is inactive except when the container is
creating or destroying a contextual instance of a bean or injecting its
dependencies</text>
</assertion>
<assertion id="k">
- <text>The @Dependent scope is inactive except when the container is injecting
dependencies of an EJB</text>
+ <text>The |@Dependent| scope is inactive except when the container is
injecting dependencies of an EJB</text>
</assertion>
<assertion id="l">
- <text>The @Dependent scope is inactive except when a @PostConstruct or
@PreDestroy callback is invoked by the EJB container</text>
+ <text>The |@Dependent| scope is inactive except when a |@PostConstruct| or
|@PreDestroy| callback is invoked by the EJB container</text>
</assertion>
<assertion id="m">
- <text>The @Dependent scope is inactive except when the container is injecting
dependencies of a servlet</text>
+ <text>The |@Dependent| scope is inactive except when the container is
injecting dependencies of a servlet</text>
</assertion>
<assertion id="n">
- <text>The @Dependent scope is even active during invocation of interceptors
and decorators of observer methods and interceptors and decorators of @PostConstruct and
@PreDestroy callbacks</text>
+ <text>The |@Dependent| scope is even active during invocation of interceptors
and decorators of observer methods and interceptors and decorators of |@PostConstruct| and
|@PreDestroy| callbacks</text>
</assertion>
</section>
<section id="8.3.1" title="Dependent objects">
<assertion id="a" testable="false">
- <text>A bean, EJB or servlet may obtain an instance of a bean with scope
@Dependent via dependency injection or by calling Manager.getInstance(),
Manager.getInstanceByType() or Instance.get() when the @Dependent scope is
active</text>
+ <text>A bean, EJB or servlet may obtain an instance of a bean with scope
|@Dependent| via dependency injection or by calling |Manager.getInstance()|,
|Manager.getInstanceByType()| or |Instance.get()| when the |@Dependent| scope is
active</text>
<note>A statement of intent</note>
</assertion>
<assertion id="b">
- <text>Instances of interceptors or decorators with scope @Dependent are also
dependent objects of the bean they intercept or decorate</text>
+ <text>Instances of interceptors or decorators with scope |@Dependent| are
also dependent objects of the bean they intercept or decorate</text>
</assertion>
</section>
@@ -4665,27 +4649,27 @@
</assertion>
<assertion id="c">
- <text>The container must destroy all @Dependent scoped contextual instances
created during an EL expression evaluation when the evaluation completes</text>
+ <text>The container must destroy all |@Dependent| scoped contextual instances
created during an EL expression evaluation when the evaluation completes</text>
</assertion>
<assertion id="da">
- <text>The container must destroy any @Dependent scoped contextual instance
created to receive a producer method~, producer field, disposal method or observer method~
invocation when the invocation completes</text>
+ <text>The container must destroy any |@Dependent| scoped contextual instance
created to receive a producer method~, producer field, disposal method or observer method~
invocation when the invocation completes</text>
</assertion>
<assertion id="db">
- <text>The container must destroy any @Dependent scoped contextual instance
created to receive a ~producer method,~ producer field~, disposal method or observer
method~ invocation when the invocation completes</text>
+ <text>The container must destroy any |@Dependent| scoped contextual instance
created to receive a ~producer method,~ producer field~, disposal method or observer
method~ invocation when the invocation completes</text>
</assertion>
<assertion id="dc">
- <text>The container must destroy any @Dependent scoped contextual instance
created to receive a ~producer method, producer field,~ disposal method ~or observer
method~ invocation when the invocation completes</text>
+ <text>The container must destroy any |@Dependent| scoped contextual instance
created to receive a ~producer method, producer field,~ disposal method ~or observer
method~ invocation when the invocation completes</text>
</assertion>
<assertion id="dd">
- <text>The container must destroy any @Dependent scoped contextual instance
created to receive a ~producer method, producer field, disposal method or~ observer method
invocation when the invocation completes</text>
+ <text>The container must destroy any |@Dependent| scoped contextual instance
created to receive a ~producer method, producer field, disposal method or~ observer method
invocation when the invocation completes</text>
</assertion>
<assertion id="e" testable="false">
- <text>The container is permitted to destroy any @Dependent scoped contextual
instance at any time if the instance is no Scopes and contexts longer referenced by the
application (excluding weak, soft and phantom references)</text>
+ <text>The container is permitted to destroy any |@Dependent| scoped
contextual instance at any time if the instance is no Scopes and contexts longer
referenced by the application (excluding weak, soft and phantom references)</text>
<note>In other words this is unspecified</note>
</assertion>
</section>
@@ -4696,15 +4680,15 @@
</assertion>
<assertion id="b">
- <text>Simple beans are not required to be serializable. If a simple bean
declares a passivating scope, and the bean class is not serializable, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>Simple beans are not required to be serializable. If a simple bean
declares a passivating scope, and the bean class is not serializable, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="cc">
- <text>If a ~producer method or ~field declares a passivating scope and
returns a non-serializable object at runtime, an IllegalProductException is thrown by the
container</text>
+ <text>If a ~producer method or ~field declares a passivating scope and
returns a non-serializable object at runtime, an |IllegalProductException| is thrown by
the container</text>
</assertion>
<assertion id="cd">
- <text>If a producer method~ or field~ declares a passivating scope and
returns a non-serializable object at runtime, an IllegalProductException is thrown by the
container</text>
+ <text>If a producer method~ or field~ declares a passivating scope and
returns a non-serializable object at runtime, an |IllegalProductException| is thrown by
the container</text>
</assertion>
<assertion id="ca">
@@ -4745,47 +4729,47 @@
</assertion>
<assertion id="j">
- <text>EJB local objects are serializable, therefore, any reference to a
session bean of scope @Dependent is serializable</text>
+ <text>EJB local objects are serializable, therefore, any reference to a
session bean of scope |@Dependent| is serializable</text>
</assertion>
<assertion id="k">
- <text>If a simple bean of scope @Dependent and a nonserializable bean class
is injected into a stateful session bean an UnserializableDependencyException must be
thrown by the container at deployment time</text>
+ <text>If a simple bean of scope |@Dependent| and a nonserializable bean class
is injected into a stateful session bean an |UnserializableDependencyException| must be
thrown by the container at deployment time</text>
</assertion>
<assertion id="l">
- <text>If a simple bean of scope @Dependent and a nonserializable bean class
is injected into a non-transient field an UnserializableDependencyException must be thrown
by the container at deployment time</text>
+ <text>If a simple bean of scope |@Dependent| and a nonserializable bean class
is injected into a non-transient field an |UnserializableDependencyException| must be
thrown by the container at deployment time</text>
</assertion>
<assertion id="m">
- <text>If a simple bean of scope @Dependent and a nonserializable bean class
is injected into a bean constructor parameter of a bean which declares a passivating
scope, an UnserializableDependencyException must be thrown by the container at deployment
time</text>
+ <text>If a simple bean of scope |@Dependent| and a nonserializable bean class
is injected into a bean constructor parameter of a bean which declares a passivating
scope, an |UnserializableDependencyException| must be thrown by the container at
deployment time</text>
</assertion>
<assertion id="n">
- <text>If a simple bean of scope @Dependent and a nonserializable bean class
is injected into an initializer method parameter of a bean which declares a passivating
scope, an UnserializableDependencyException must be thrown by the container at deployment
time</text>
+ <text>If a simple bean of scope |@Dependent| and a nonserializable bean class
is injected into an initializer method parameter of a bean which declares a passivating
scope, an |UnserializableDependencyException| must be thrown by the container at
deployment time</text>
</assertion>
<assertion id="o">
- <text>If a simple bean of scope @Dependent and a nonserializable bean class
is injected into a parameter of a producer method which declares a passivating scope, an
UnserializableDependencyException must be thrown by the container at deployment
time</text>
+ <text>If a simple bean of scope |@Dependent| and a nonserializable bean class
is injected into a parameter of a producer method which declares a passivating scope, an
|UnserializableDependencyException| must be thrown by the container at deployment
time</text>
</assertion>
<assertion id="p">
- <text>If a producer method or field of scope @Dependent returns a
non-serializable object for injection into a stateful session bean, an
IllegalProductException is thrown by the container</text>
+ <text>If a producer method or field of scope |@Dependent| returns a
non-serializable object for injection into a stateful session bean, an
|IllegalProductException| is thrown by the container</text>
</assertion>
<assertion id="q">
- <text>If a producer method or field of scope @Dependent returns a
non-serializable object for injection into a non-transient field an
IllegalProductException is thrown by the container</text>
+ <text>If a producer method or field of scope |@Dependent| returns a
non-serializable object for injection into a non-transient field an
|IllegalProductException| is thrown by the container</text>
</assertion>
<assertion id="r">
- <text>If a producer method or field of scope @Dependent returns a
non-serializable object for injection into a bean constructor parameter of a bean which
declares a passivating scope, an IllegalProductException is thrown by the
container</text>
+ <text>If a producer method or field of scope |@Dependent| returns a
non-serializable object for injection into a bean constructor parameter of a bean which
declares a passivating scope, an |IllegalProductException| is thrown by the
container</text>
</assertion>
<assertion id="s">
- <text>If a producer method or field of scope @Dependent returns a
non-serializable object for injection into an initializer method parameter of a bean which
declares a passivating scope, an IllegalProductException is thrown by the
container</text>
+ <text>If a producer method or field of scope |@Dependent| returns a
non-serializable object for injection into an initializer method parameter of a bean which
declares a passivating scope, an |IllegalProductException| is thrown by the
container</text>
</assertion>
<assertion id="t">
- <text>If a producer method or field of scope @Dependent returns a
non-serializable object for injection into a parameter of a producer method which declares
a passivating scope, an IllegalProductException is thrown by the container</text>
+ <text>If a producer method or field of scope |@Dependent| returns a
non-serializable object for injection into a parameter of a producer method which declares
a passivating scope, an |IllegalProductException| is thrown by the container</text>
</assertion>
<assertion id="u">
@@ -4793,14 +4777,14 @@
</assertion>
<assertion id="v">
- <text>The method Bean.isSerializable() may be used to detect if a bean is
serializable</text>
+ <text>The method |Bean.isSerializable()| may be used to detect if a bean is
serializable</text>
</assertion>
</section>
<section id="8.5" title="Context management for built-in
scopes">
<assertion id="a">
- <text>The container provides an implementation of the Context interface for
each of the built-in scopes</text>
+ <text>The container provides an implementation of the |Context| interface for
each of the built-in scopes</text>
</assertion>
<assertion id="b">
@@ -4816,15 +4800,15 @@
<section id="8.5.1" title="Request context lifecycle">
<assertion id="a">
- <text>The request scope is active during the service() method of any servlet
in the web application</text>
+ <text>The request scope is active during the |service()| method of any
servlet in the web application</text>
</assertion>
<assertion id="b">
- <text>The request scope is active during the doFilter() method of any servlet
filter</text>
+ <text>The request scope is active during the |doFilter()| method of any
servlet filter</text>
</assertion>
<assertion id="c">
- <text>The request context is destroyed at the end of the servlet request,
after the service() method and all doFilter() methods return</text>
+ <text>The request context is destroyed at the end of the servlet request,
after the |service()| method and all |doFilter()| methods return</text>
</assertion>
<assertion id="d">
@@ -4871,11 +4855,11 @@
<section id="8.5.2" title="Session context lifecycle">
<assertion id="a">
- <text>The session scope is active during the service() method of any servlet
in the web application</text>
+ <text>The session scope is active during the |service()| method of any
servlet in the web application</text>
</assertion>
<assertion id="b">
- <text>The session scope is active during the doFilter() method of any servlet
filter</text>
+ <text>The session scope is active during the |doFilter()| method of any
servlet filter</text>
</assertion>
<assertion id="c">
@@ -4894,11 +4878,11 @@
<section id="8.5.3" title="Application context lifecycle">
<assertion id="a">
- <text>The application scope is active during the service() method of any
servlet in the web application</text>
+ <text>The application scope is active during the |service()| method of any
servlet in the web application</text>
</assertion>
<assertion id="b">
- <text>The application scope is active during the doFilter() method of any
servlet filter</text>
+ <text>The application scope is active during the |doFilter()| method of any
servlet filter</text>
</assertion>
<assertion id="c">
@@ -4938,8 +4922,7 @@
</assertion>
<assertion id="l">
- <text>The application context is shared between all EJB timeouts that
execute
-within the same application</text>
+ <text>The application context is shared between all EJB timeouts that execute
within the same application</text>
</assertion>
<assertion id="m">
@@ -4974,11 +4957,11 @@
</assertion>
<assertion id="f">
- <text>A transient conversation may be marked long-running by calling
Conversation.begin()</text>
+ <text>A transient conversation may be marked long-running by calling
|Conversation.begin()|</text>
</assertion>
<assertion id="g">
- <text>A long-running conversation may be marked transient by calling
Conversation.end()</text>
+ <text>A long-running conversation may be marked transient by calling
|Conversation.end()|</text>
</assertion>
<assertion id="ha">
@@ -4990,23 +4973,23 @@
</assertion>
<assertion id="ia">
- <text>The container provides a built-in bean with bean type
javax.context.Conversation~, scope @RequestScoped, deployment type @Standard and binding
@Current, named javax.context.conversation~</text>
+ <text>The container provides a built-in bean with bean type
|javax.context.Conversation|~, scope |@RequestScoped|, deployment type |@Standard| and
binding |@Current|, named |javax.context.conversation|~</text>
</assertion>
<assertion id="ib">
- <text>The container provides a built-in bean with ~bean type
javax.context.Conversation~, scope @RequestScoped~, deployment type @Standard and binding
@Current, named javax.context.conversation~</text>
+ <text>The container provides a built-in bean with ~bean type
|javax.context.Conversation|~, scope |@RequestScoped|~, deployment type |@Standard| and
binding |@Current|, named |javax.context.conversation|~</text>
</assertion>
<assertion id="ic">
- <text>The container provides a built-in bean with~ bean type
javax.context.Conversation, scope @RequestScoped,~ deployment type @Standard~ and binding
@Current, named javax.context.conversation~</text>
+ <text>The container provides a built-in bean with~ bean type
|javax.context.Conversation|, scope |@RequestScoped|,~ deployment type |@Standard|~ and
binding |@Current|, named |javax.context.conversation|~</text>
</assertion>
<assertion id="id">
- <text>The container provides a built-in bean with bean type
~javax.context.Conversation, scope @RequestScoped, deployment type @Standard and~ binding
@Current~, named javax.context.conversation~</text>
+ <text>The container provides a built-in bean with bean type
~|javax.context.Conversation|, scope |@RequestScoped|, deployment type |@Standard| and~
binding |@Current|~, named |javax.context.conversation|~</text>
</assertion>
<assertion id="ie">
- <text>The container provides a built-in bean with bean type
~javax.context.Conversation, scope @RequestScoped, deployment type @Standard and binding
@Current,~ named javax.context.conversation</text>
+ <text>The container provides a built-in bean with bean type
~|javax.context.Conversation|, scope |@RequestScoped|, deployment type |@Standard| and
binding |@Current|,~ named |javax.context.conversation|</text>
</assertion>
<assertion id="j">
@@ -5051,7 +5034,7 @@
</assertion>
<assertion id="t" testable="false">
- <text>The method Conversation.setTimeout() is a hint to the container that a
conversation should not be destroyed if it has been active within the last given interval
in milliseconds</text>
+ <text>The method |Conversation.setTimeout()| is a hint to the container that
a conversation should not be destroyed if it has been active within the last given
interval in milliseconds</text>
<note>Not required</note>
</assertion>
@@ -5064,20 +5047,19 @@
<section id="8.6" title="Context management for custom
scopes">
<assertion id="a">
- <text>A custom implementation of Context may be associated with any scope
type at any point in the execution of the application, by calling
Manager.addContext()</text>
+ <text>A custom implementation of |Context| may be associated with any scope
type at any point in the execution of the application, by calling
|Manager.addContext()|</text>
</assertion>
<assertion id="b">
- <text>Every time Manager.getInstance() is called, for example, during
instance or EL name resolution, the container must call Manager.getContext() to retrieve
an active context object associated with the bean scope</text>
+ <text>Every time |Manager.getInstance()| is called, for example, during
instance or EL name resolution, the container must call |Manager.getContext()| to retrieve
an active context object associated with the bean scope</text>
</assertion>
<assertion id="c">
- <text>If no active context object exists for the given scope type,
Manager.getContext() must throw a ContextNotActiveException</text>
+ <text>If no active context object exists for the given scope type,
|Manager.getContext()| must throw a |ContextNotActiveException|</text>
</assertion>
<assertion id="d">
- <text>If more than one active context object exists for the given
-scope type, Manager.getContext() must throw an IllegalStateException</text>
+ <text>If more than one active context object exists for the given scope type,
|Manager.getContext()| must throw an |IllegalStateException|</text>
</assertion>
</section>
@@ -5099,14 +5081,14 @@
</assertion>
<assertion id="e">
- <text>If a beans.xml file contains any XML element without a declared
namespace, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If a |beans.xml| file contains any XML element without a declared
namespace, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
</section>
<section id="9.1" title="XML namespace for a Java package">
<assertion id="a">
- <text>Every Java package has a corresponding XML namespace. The namespace URN
consists of the package name, with the prefix urn:java:</text>
+ <text>Every Java package has a corresponding XML namespace. The namespace URN
consists of the package name, with the prefix |urn:java:|</text>
</assertion>
<assertion id="b">
@@ -5133,7 +5115,7 @@
<section id="9.2" title="XML namespace aggregating multiple
packages">
<assertion id="a">
- <text>Alternatively, a namespace may represent several Java packages. Such a
namespace must have a URN consisting of the prefix urn:java: followed by a
period-separated list of valid Java identifiers</text>
+ <text>Alternatively, a namespace may represent several Java packages. Such a
namespace must have a URN consisting of the prefix |urn:java:| followed by a
period-separated list of valid Java identifiers</text>
</assertion>
<assertion id="b">
@@ -5149,7 +5131,7 @@
</assertion>
<assertion id="e">
- <text>If there are multiple packages containing a Java type with the same
name as the XML element, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If there are multiple packages containing a Java type with the same
name as the XML element, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="f">
@@ -5159,23 +5141,23 @@
<section id="9.2.1" title="The Java EE namespace">
<assertion id="a">
- <text>The Java EE namespace urn:java:ee represents the following packages:
java.lang, java.util, javax.annotation, javax.inject, javax.context, javax.interceptor,
javax.decorator, javax.event, javax.ejb, javax.persistence, javax.xml.ws, javax.jms, and
javax.sql</text>
+ <text>The Java EE namespace |urn:java:ee| represents the following packages:
|java.lang|, |java.util|, |javax.annotation|, |javax.inject|, |javax.context|,
|javax.interceptor|, |javax.decorator|, |javax.event|, |javax.ejb|, |javax.persistence|,
|javax.xml.ws|, |javax.jms|, and |javax.sql|</text>
</assertion>
<assertion id="b">
- <text>Several elements in the urn:java:ee namespace do not represent Java
types</text>
+ <text>Several elements in the |urn:java:ee| namespace do not represent Java
types</text>
</assertion>
<assertion id="c">
- <text>The root <Beans> element, together with the
<Deploy>, <Interceptors> and <Decorators>
elements belong to the namespace urn:java:ee and do not represent Java types nor members
of Java types</text>
+ <text>The root |<Beans>| element, together with the
|<Deploy>|, |<Interceptors>| and |<Decorators>|
elements belong to the namespace |urn:java:ee| and do not represent Java types nor members
of Java types</text>
</assertion>
<assertion id="d">
- <text>Java array types may be represented by an <Array> element
in the namespace urn:java:ee, with a child element representing the element
type</text>
+ <text>Java array types may be represented by an |<Array>|
element in the namespace |urn:java:ee|, with a child element representing the element
type</text>
</assertion>
<assertion id="e">
- <text>Primitive types may be represented by the XML element that represents
the corresponding wrapper type in java.lang, since primitive and wrapper types are
considered identical for the purposes of typesafe resolution, and assignable for the
purposes of injection</text>
+ <text>Primitive types may be represented by the XML element that represents
the corresponding wrapper type in |java.lang|, since primitive and wrapper types are
considered identical for the purposes of typesafe resolution, and assignable for the
purposes of injection</text>
</assertion>
</section>
@@ -5195,19 +5177,19 @@
<section id="9.4" title="Stereotype, binding type and interceptor
binding type declarations">
<assertion id="a">
- <text>An XML element that appears as a direct child of the root
<Beans> element is interpreted as a binding type declaration if it has a
direct child <BindingType> element in the Java EE namespace, as defined in
Section 2.3.2, "Defining new binding types"</text>
+ <text>An XML element that appears as a direct child of the root
|<Beans>| element is interpreted as a binding type declaration if it has a
direct child |<BindingType>| element in the Java EE namespace, as defined in
Section 2.3.2, "Defining new binding types"</text>
</assertion>
<assertion id="b">
- <text>An XML element that appears as a direct child of the root
<Beans> element is interpreted as an interceptor binding type if it has a
direct child <InterceptorBindingType> element in the Java EE namespace, as
defined in Section A.3.4, "Interceptor bindings"</text>
+ <text>An XML element that appears as a direct child of the root
|<Beans>| element is interpreted as an interceptor binding type if it has a
direct child |<InterceptorBindingType>| element in the Java EE namespace, as
defined in Section A.3.4, "Interceptor bindings"</text>
</assertion>
<assertion id="c">
- <text>An XML element that appears as a direct child of the root
<Beans> element is interpreted as a stereotype declaration if it has a
direct child <Stereotype> element in the Java EE namespace, as defined in
Section 2.7.1, "Defining new stereotypes"</text>
+ <text>An XML element that appears as a direct child of the root
|<Beans>| element is interpreted as a stereotype declaration if it has a
direct child |<Stereotype>| element in the Java EE namespace, as defined in
Section 2.7.1, "Defining new stereotypes"</text>
</assertion>
<assertion id="d">
- <text>The XML element is interpreted as a Java type. If no such Java type
exists in the classpath, a DefinitionException is thrown by the container at deployment
time. If the type is not an annotation type, a DefinitionException is thrown by the
container at deployment time</text>
+ <text>The XML element is interpreted as a Java type. If no such Java type
exists in the classpath, a |DefinitionException| is thrown by the container at deployment
time. If the type is not an annotation type, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
<assertion id="e">
@@ -5223,7 +5205,7 @@
</assertion>
<assertion id="h">
- <text>If a certain annotation type is declared more than once as a binding
type, interceptor binding type or stereotype using XML, a DeploymentException is thrown by
the container at deployment time</text>
+ <text>If a certain annotation type is declared more than once as a binding
type, interceptor binding type or stereotype using XML, a |DeploymentException| is thrown
by the container at deployment time</text>
</assertion>
</section>
@@ -5233,11 +5215,11 @@
</assertion>
<assertion id="b">
- <text>If no such Java type exists in the classpath, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If no such Java type exists in the classpath, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If the type is not an annotation type, a DefinitionException is thrown
by the container at deployment time</text>
+ <text>If the type is not an annotation type, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
@@ -5253,11 +5235,11 @@
</assertion>
<assertion id="g">
- <text>If the annotation type is javax.annotation.Named, a stereotype with
name defaulting was declared</text>
+ <text>If the annotation type is |javax.annotation.Named|, a stereotype with
name defaulting was declared</text>
</assertion>
<assertion id="h">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
@@ -5267,11 +5249,11 @@
</assertion>
<assertion id="b">
- <text>If no such Java type exists in the classpath, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>If no such Java type exists in the classpath, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If the type is not an annotation type, a DefinitionException is thrown
by the container at deployment time</text>
+ <text>If the type is not an annotation type, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
@@ -5279,7 +5261,7 @@
</assertion>
<assertion id="e">
- <text>If the annotation type is not an interceptor binding type, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the annotation type is not an interceptor binding type, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
@@ -5287,19 +5269,19 @@
<section id="9.5" title="Bean declarations">
<assertion id="a">
- <text>An XML element that appears as a direct child of the root
<Beans> element is interpreted as a bean declaration if it is not a
<Deploy>, <Interceptors> or <Decorators> element
in the Java EE namespace, and does not have a direct child
<BindingType>,<InterceptorBindingType> or
<Stereotype> element in the Java EE namespace</text>
+ <text>An XML element that appears as a direct child of the root
|<Beans>| element is interpreted as a bean declaration if it is not a
|<Deploy>|, |<Interceptors>| or |<Decorators>|
element in the Java EE namespace, and does not have a direct child
|<BindingType>|,|<InterceptorBindingType>| or
|<Stereotype>| element in the Java EE namespace</text>
</assertion>
<assertion id="b">
- <text>The name of the XML element is interpreted as a Java type. The
container inspects the Java type and other metadata to determine what kind of bean is
being declared. If no such Java type exists in the classpath, a DefinitionException is
thrown by the container at deployment time</text>
+ <text>The name of the XML element is interpreted as a Java type. The
container inspects the Java type and other metadata to determine what kind of bean is
being declared. If no such Java type exists in the classpath, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>If the type is javax.jms.Queue or javax.jms.Topic, it declares a JMS
resource, as defined in Section 3.7.2, "Declaring a JMS resource using
XML"</text>
+ <text>If the type is |javax.jms.Queue| or |javax.jms.Topic|, it declares a
JMS resource, as defined in Section 3.7.2, "Declaring a JMS resource using
XML"</text>
</assertion>
<assertion id="d">
- <text>If the element has a child <Resource>,
<PersistenceContext>, <PersistenceUnit>, <EJB>
or <WebServiceRef> element, it declares a resource, as defined in Section
3.6.1, "Declaring a resource using XML"</text>
+ <text>If the element has a child |<Resource>|,
|<PersistenceContext>|, |<PersistenceUnit>|,
|<EJB>| or |<WebServiceRef>| element, it declares a resource,
as defined in Section 3.6.1, "Declaring a resource using XML"</text>
</assertion>
<assertion id="e">
@@ -5311,7 +5293,7 @@
</assertion>
<assertion id="g">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="h">
@@ -5334,7 +5316,7 @@
</assertion>
<assertion id="d">
- <text>If the name of the child element matches the name of both a method and
a field of the bean class, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If the name of the child element matches the name of both a method and
a field of the bean class, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="e">
@@ -5346,7 +5328,7 @@
</assertion>
<assertion id="g">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
@@ -5380,27 +5362,27 @@
</assertion>
<assertion id="h">
- <text>If the annotation type is javax.annotation.Name, the name of the bean
was declared, as defined in Section 2.6.2, "Declaring the bean name using
XML"</text>
+ <text>If the annotation type is |javax.annotation.Name|, the name of the bean
was declared, as defined in Section 2.6.2, "Declaring the bean name using
XML"</text>
</assertion>
<assertion id="i">
- <text>If the annotation type is javax.inject.Specializes, the bean was
declared to directly specialize the bean with the same bean class that was defined using
annotations, as specified in Section 3.2.7, "Specializing a simple bean" and
Section 3.3.7, "Specializing a session bean"</text>
+ <text>If the annotation type is |javax.inject.Specializes|, the bean was
declared to directly specialize the bean with the same bean class that was defined using
annotations, as specified in Section 3.2.7, "Specializing a simple bean" and
Section 3.3.7, "Specializing a session bean"</text>
</assertion>
<assertion id="j">
- <text>If the annotation type is javax.inject.Realizes, the bean was declared
to realize the bean with the same bean class that was defined using
annotations</text>
+ <text>If the annotation type is |javax.inject.Realizes|, the bean was
declared to realize the bean with the same bean class that was defined using
annotations</text>
</assertion>
<assertion id="k">
- <text>If the annotation type is javax.interceptor.Interceptor, or
javax.decorator.Decorator the bean is an interceptor or decorator, as defined in Section
9.7, "Interceptor and decorator declarations"</text>
+ <text>If the annotation type is |javax.interceptor.Interceptor|, or
|javax.decorator.Decorator| the bean is an interceptor or decorator, as defined in Section
9.7, "Interceptor and decorator declarations"</text>
</assertion>
<assertion id="l">
- <text>If the annotation type is javax.annotation.Resource, javax.ejb.EJB,
javax.xml.ws.WebServiceRef, javax.persistence.PersistenceContext or
javax.persistence.PersistenceUnit, the metadata for a resource or JMS resource was
declared, as defined in Section 3.6.1, "Declaring a resource using XML" and
Section 3.7.2, "Declaring a JMS resource using XML"</text>
+ <text>If the annotation type is |javax.annotation.Resource|, |javax.ejb.EJB|,
|javax.xml.ws.WebServiceRef|, |javax.persistence.PersistenceContext| or
|javax.persistence.PersistenceUnit|, the metadata for a resource or JMS resource was
declared, as defined in Section 3.6.1, "Declaring a resource using XML" and
Section 3.7.2, "Declaring a JMS resource using XML"</text>
</assertion>
<assertion id="m">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
</section>
@@ -5422,11 +5404,11 @@
</assertion>
<assertion id="e">
- <text>If more than one constructor exists which satisfies these conditions, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If more than one constructor exists which satisfies these conditions, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="f">
- <text>If no constructor of the simple bean class satisfies these conditions,
a DefinitionException is thrown by the container at deployment time</text>
+ <text>If no constructor of the simple bean class satisfies these conditions,
a |DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="g">
@@ -5444,11 +5426,11 @@
</assertion>
<assertion id="c">
- <text>If the bean class does not have exactly one field with the specified
name, a DefinitionException is thrown by the container at deployment time</text>
+ <text>If the bean class does not have exactly one field with the specified
name, a |DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="d">
- <text>If more than one child element of a bean declaration represents the
same field of the bean class, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>If more than one child element of a bean declaration represents the
same field of the bean class, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="e">
@@ -5457,7 +5439,7 @@
<assertion id="f">
<text>If a field declaration has more than one direct child element, and at
least
-one of these elements is something other than a <value> element in the Java
EE namespace, a DefinitionException is thrown by the container at deployment
time</text>
+one of these elements is something other than a |<value>| element in the
Java EE namespace, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="g">
@@ -5465,11 +5447,11 @@
</assertion>
<assertion id="h">
- <text>If the element contains a child <Produces> element in the
Java EE namespace, a producer field was declared, as defined in Section 3.5.3,
"Declaring a producer field using XML"</text>
+ <text>If the element contains a child |<Produces>| element in
the Java EE namespace, a producer field was declared, as defined in Section 3.5.3,
"Declaring a producer field using XML"</text>
</assertion>
<assertion id="i">
- <text>If the element contains a child <value> element in the
Java EE namespace, a field with an initial value of type Set or List was declared, as
defined in Section 9.5.5, "Field initial value declarations"</text>
+ <text>If the element contains a child |<value>| element in the
Java EE namespace, a field with an initial value of type Set or List was declared, as
defined in Section 9.5.5, "Field initial value declarations"</text>
</assertion>
<assertion id="j">
@@ -5481,7 +5463,7 @@
</assertion>
<assertion id="l">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="m">
@@ -5489,7 +5471,7 @@
</assertion>
<assertion id="n">
- <text>If the declared type is not assignable to the Java type of the field, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If the declared type is not assignable to the Java type of the field, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="o">
@@ -5500,7 +5482,7 @@
<section id="9.5.5" title="Field initial value
declarations">
<assertion id="a">
- <text>The initial value of a field of a simple bean or session bean with any
one of the following types may be specified in XML: any primitive type, or java.lang
wrapper type, any enumerated type, java.lang.String, java.util.Date, java.sql.Date,
java.sql.Time or java.sql.Timestamp, java.util.Calendar, java.math.BigDecimal or
java.math.BigInteger, java.lang.Class, java.util.List<java.lang.String> or
java.util.Set<java.lang.String>,
java.util.List<java.lang.Class> or
java.util.Set<java.lang.Class>, java.util.List<X> or
java.util.Set<X> where X is an enumerated type</text>
+ <text>The initial value of a field of a simple bean or session bean with any
one of the following types may be specified in XML: any primitive type, or |java.lang|
wrapper type, any enumerated type, |java.lang.String|, |java.util.Date|, |java.sql.Date|,
|java.sql.Time| or |java.sql.Timestamp|, |java.util.Calendar|, |java.math.BigDecimal| or
|java.math.BigInteger|, |java.lang.Class|,
|java.util.List<java.lang.String>| or
|java.util.Set<java.lang.String>|,
|java.util.List<java.lang.Class>| or
|java.util.Set<java.lang.Class>|, |java.util.List<X>| or
|java.util.Set<X>| where X is an enumerated type</text>
</assertion>
<assertion id="b">
@@ -5508,11 +5490,11 @@
</assertion>
<assertion id="c">
- <text>The initial value of a field of primitive type or java.lang wrapper
type is specified using the Java literal syntax for that type</text>
+ <text>The initial value of a field of primitive type or |java.lang| wrapper
type is specified using the Java literal syntax for that type</text>
</assertion>
<assertion id="d">
- <text>The initial value of a field of type java.lang.String is specified
using the string value</text>
+ <text>The initial value of a field of type |java.lang.String| is specified
using the string value</text>
</assertion>
<assertion id="e">
@@ -5520,28 +5502,28 @@
</assertion>
<assertion id="f">
- <text>The initial value of a field of type java.util.Date, java.sql.Date,
java.sql.Time, java.sql.Timestamp or java.util.Calendar is specified using a format that
can be parsed by calling
-java.text.DateFormat.getDateTimeInstance().parse()</text>
+ <text>The initial value of a field of type |java.util.Date|, |java.sql.Date|,
|java.sql.Time|, |java.sql.Timestamp| or |java.util.Calendar| is specified using a format
that can be parsed by calling
+|java.text.DateFormat.getDateTimeInstance().parse()|</text>
</assertion>
<assertion id="g">
- <text>The initial value of a field of type java.math.BigDecimal or
java.math.BigInteger is specified using a format that can be parsed by the constructor
that accepts a string</text>
+ <text>The initial value of a field of type |java.math.BigDecimal| or
|java.math.BigInteger| is specified using a format that can be parsed by the constructor
that accepts a string</text>
</assertion>
<assertion id="h">
- <text>The initial value of a field of type java.lang.Class is specified using
the fully qualified Java class name</text>
+ <text>The initial value of a field of type |java.lang.Class| is specified
using the fully qualified Java class name</text>
</assertion>
<assertion id="i">
- <text>The initial value of a field of type java.util.List or java.util.Set is
specified by a list of <value> elements. The body of the value element is
specified using the string value, fully qualified Java class name or unqualified name of
the enumeration value</text>
+ <text>The initial value of a field of type |java.util.List| or
|java.util.Set| is specified by a list of |<value>| elements. The body of
the value element is specified using the string value, fully qualified Java class name or
unqualified name of the enumeration value</text>
</assertion>
<assertion id="j">
- <text>If a field with an initial value specified in XML is not of one of the
listed types, or if the initial value is not specified in the correct format for the type
of the field, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If a field with an initial value specified in XML is not of one of the
listed types, or if the initial value is not specified in the correct format for the type
of the field, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="k">
- <text>If an element representing a field specifies both an initial value and
a type declaration, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If an element representing a field specifies both an initial value and
a type declaration, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
</section>
@@ -5555,15 +5537,15 @@
</assertion>
<assertion id="c">
- <text>The container inspects the direct child elements of the method
declaration. For each child element, the element is interpreted as a Java type. If no such
Java type exists in the classpath, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>The container inspects the direct child elements of the method
declaration. For each child element, the element is interpreted as a Java type. If no such
Java type exists in the classpath, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="d">
- <text>If the type is javax.inject.Disposes, the container searches for a
direct child element of the child element and interprets that element as declaring a
disposed parameter of the disposal method</text>
+ <text>If the type is |javax.inject.Disposes|, the container searches for a
direct child element of the child element and interprets that element as declaring a
disposed parameter of the disposal method</text>
</assertion>
<assertion id="e">
- <text>If the type is javax.event.Observes, the container searches for a
direct child element of the child element that is not an <IfExists>,
<Asynchronously>, <AfterTransactionCompletion>,
<AfterTransactionSuccess>, <AfterTransactionFailure> or
<BeforeTransactionCompletion> element in the Java EE namespace, and
interprets that element as declaring an event parameter of the observer
method</text>
+ <text>If the type is |javax.event.Observes|, the container searches for a
direct child element of the child element that is not an |<IfExists>|,
|<Asynchronously>|, |<AfterTransactionCompletion>|,
|<AfterTransactionSuccess>|, |<AfterTransactionFailure>| or
|<BeforeTransactionCompletion>| element in the Java EE namespace, and
interprets that element as declaring an event parameter of the observer
method</text>
</assertion>
<assertion id="f">
@@ -5575,19 +5557,19 @@
</assertion>
<assertion id="h">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="i">
- <text>If a method declaration has more than one direct child element which is
an <Initializer>, <Produces>, <Disposes> or
<Observes> element in the Java EE namespace, a DefinitionException is thrown
by the container at deployment time</text>
+ <text>If a method declaration has more than one direct child element which is
an |<Initializer>|, |<Produces>|, |<Disposes>|
or |<Observes>| element in the Java EE namespace, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="j">
- <text>If a <Disposes> element does not contain exactly one
direct child element, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If a |<Disposes>| element does not contain exactly one
direct child element, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="k">
- <text>If an <Observes> element does not contain exactly one
direct child element that is not an <IfExists>,
<Asynchronously>, <AfterTransactionCompletion>,
<AfterTransactionSuccess>, <AfterTransactionFailure> or
<BeforeTransactionCompletion> element in the Java EE namespace, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If an |<Observes>| element does not contain exactly one
direct child element that is not an |<IfExists>|,
|<Asynchronously>|, |<AfterTransactionCompletion>|,
|<AfterTransactionSuccess>|, |<AfterTransactionFailure>| or
|<BeforeTransactionCompletion>| element in the Java EE namespace, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="l">
@@ -5599,11 +5581,11 @@
</assertion>
<assertion id="n">
- <text>If more than one method exists which satisfies these conditions, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If more than one method exists which satisfies these conditions, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="o">
- <text>If no method of the bean class satisfies these conditions, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If no method of the bean class satisfies these conditions, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="p">
@@ -5611,7 +5593,7 @@
</assertion>
<assertion id="q">
- <text>If more than one child element of a bean declaration represents the
same method of the bean class, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>If more than one child element of a bean declaration represents the
same method of the bean class, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="r">
@@ -5619,19 +5601,19 @@
</assertion>
<assertion id="s">
- <text>If the element contains a child <Initializes> element in
the Java EE namespace, an initializer method was declared, as defined in Section 3.9.2,
"Declaring an initializer method using XML"</text>
+ <text>If the element contains a child |<Initializes>| element
in the Java EE namespace, an initializer method was declared, as defined in Section 3.9.2,
"Declaring an initializer method using XML"</text>
</assertion>
<assertion id="t">
- <text>If the element contains a child <Produces> element in the
Java EE namespace, a producer method was declared, as defined in Section 3.4.3,
"Declaring a producer method using XML"</text>
+ <text>If the element contains a child |<Produces>| element in
the Java EE namespace, a producer method was declared, as defined in Section 3.4.3,
"Declaring a producer method using XML"</text>
</assertion>
<assertion id="u">
- <text>If the element contains a child <Disposes> element in the
Java EE namespace, a disposal method was declared, as defined in Section 3.4.9,
"Declaring a disposal method using XML"</text>
+ <text>If the element contains a child |<Disposes>| element in
the Java EE namespace, a disposal method was declared, as defined in Section 3.4.9,
"Declaring a disposal method using XML"</text>
</assertion>
<assertion id="v">
- <text>If the element contains a child <Observes> element in the
Java EE namespace, an observer method was declared, as defined in Section 7.5.3,
"Declaring an observer method using XML"</text>
+ <text>If the element contains a child |<Observes>| element in
the Java EE namespace, an observer method was declared, as defined in Section 7.5.3,
"Declaring an observer method using XML"</text>
</assertion>
<assertion id="w">
@@ -5641,7 +5623,7 @@
<section id="9.6" title="Producer method and field
declarations">
<assertion id="a">
- <text>A producer method or field declaration is formed by adding a direct
child <Produces> element to an element that represents the method or field,
as defined in Section 3.4.3, "Declaring a producer method using XML" and Section
3.5.3, "Declaring a producer field using XML"</text>
+ <text>A producer method or field declaration is formed by adding a direct
child |<Produces>| element to an element that represents the method or
field, as defined in Section 3.4.3, "Declaring a producer method using XML" and
Section 3.5.3, "Declaring a producer field using XML"</text>
</assertion>
</section>
@@ -5652,15 +5634,15 @@
</assertion>
<assertion id="b">
- <text>If there is more than one direct child element, a DefinitionException
is thrown by the container at deployment time</text>
+ <text>If there is more than one direct child element, a |DefinitionException|
is thrown by the container at deployment time</text>
</assertion>
<assertion id="c">
- <text>Otherwise, the direct child element is a <Produces>
element in the Java EE namespace, and declares the return type, bindings and member-level
metadata of the producer field</text>
+ <text>Otherwise, the direct child element is a |<Produces>|
element in the Java EE namespace, and declares the return type, bindings and member-level
metadata of the producer field</text>
</assertion>
<assertion id="d">
- <text>The container inspects the direct child elements of the
<Produces> element. For each child element, the element is interpreted as a
Java type. If no such Java type exists in the classpath, a DefinitionException is thrown
by the container at deployment time</text>
+ <text>The container inspects the direct child elements of the
|<Produces>| element. For each child element, the element is interpreted as
a Java type. If no such Java type exists in the classpath, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="e">
@@ -5672,17 +5654,17 @@
</assertion>
<assertion id="g">
- <text>Otherwise, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Otherwise, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="h">
- <text>If more than one child element represents a Java class or interface
type, or if no child element represents a Java class or interface type, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If more than one child element represents a Java class or interface
type, or if no child element represents a Java class or interface type, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="9.6.2" title="Child elements of a producer method
declaration">
<assertion id="a">
- <text>If a child element of a producer method declaration is the
<Produces> element in the Java EE namespace, it declares the return type,
bindings and member-level metadata of the producer method</text>
+ <text>If a child element of a producer method declaration is the
|<Produces>| element in the Java EE namespace, it declares the return type,
bindings and member-level metadata of the producer method</text>
</assertion>
<assertion id="b">
@@ -5690,41 +5672,41 @@
</assertion>
<assertion id="c">
- <text>The container interprets the child element of a producer method
declaration as declaring a parameter of the producer method, if it is not a
<Produces> element and cannot be interpreted as an interceptor binding
type</text>
+ <text>The container interprets the child element of a producer method
declaration as declaring a parameter of the producer method, if it is not a
|<Produces>| element and cannot be interpreted as an interceptor binding
type</text>
</assertion>
<assertion id="d">
- <text>If there is more than one child <Produces> element of a
producer method declaration in the Java EE namespace, a DefinitionException is thrown by
the container at deployment time.</text>
+ <text>If there is more than one child |<Produces>| element of a
producer method declaration in the Java EE namespace, a |DefinitionException| is thrown by
the container at deployment time.</text>
</assertion>
<assertion id="e">
- <text>The container inspects the direct child elements of the
<Produces> element. For each child element, the element is interpreted as a
Java type. If no such Java type exists in the classpath, a DefinitionException is thrown
by the container at deployment time</text>
+ <text>The container inspects the direct child elements of the
|<Produces>| element. For each child element, the element is interpreted as
a Java type. If no such Java type exists in the classpath, a |DefinitionException| is
thrown by the container at deployment time</text>
</assertion>
<assertion id="f">
- <text>If the type of the direct child element of a <Produces>
element is a Java class or interface type, the return type of the producer method was
declared</text>
+ <text>If the type of the direct child element of a |<Produces>|
element is a Java class or interface type, the return type of the producer method was
declared</text>
</assertion>
<assertion id="g">
- <text>If the type of the direct child element of a <Produces>
element is a Java annotation type, it declares member-level metadata of the producer
method</text>
+ <text>If the type of the direct child element of a |<Produces>|
element is a Java annotation type, it declares member-level metadata of the producer
method</text>
</assertion>
<assertion id="h">
- <text>If the type of the direct child element of a <Produces>
element is not a Java class or Java annotation, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>If the type of the direct child element of a |<Produces>|
element is not a Java class or Java annotation, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="i">
- <text>If more than one child element represents a Java class or interface
type, or if no child element represents a Java class or interface type, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>If more than one child element represents a Java class or interface
type, or if no child element represents a Java class or interface type, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
</section>
<section id="9.6.3" title="Return type and bindings of a producer
method or field">
<assertion id="a">
- <text>Every XML producer method or field declaration has a direct child
<Produces> element</text>
+ <text>Every XML producer method or field declaration has a direct child
|<Produces>| element</text>
</assertion>
<assertion id="b">
- <text>This <Produces> element must, in turn, have a direct
child element which declares the return type of the producer method or the type of the
producer field and which is interpreted by the container as a type declaration, as defined
in Section 9.10, "Specifying bean types and bindings"</text>
+ <text>This |<Produces>| element must, in turn, have a direct
child element which declares the return type of the producer method or the type of the
producer field and which is interpreted by the container as a type declaration, as defined
in Section 9.10, "Specifying bean types and bindings"</text>
</assertion>
<assertion id="c">
@@ -5736,18 +5718,18 @@
</assertion>
<assertion id="e">
- <text>The type declared in XML must be a supertype or subtype of the Java
method or field type. If the declared type is not a supertype or subtype of the Java
method or field type, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>The type declared in XML must be a supertype or subtype of the Java
method or field type. If the declared type is not a supertype or subtype of the Java
method or field type, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
</section>
<section id="9.6.4" title="Member-level metadata for a producer
method or field">
<assertion id="a">
- <text>Member-level metadata for a producer method or field declaration is
specified via direct child elements of the <Produces> element that represent
Java annotation types.</text>
+ <text>Member-level metadata for a producer method or field declaration is
specified via direct child elements of the |<Produces>| element that
represent Java annotation types.</text>
</assertion>
<assertion id="b">
- <text>Each child element is interpreted as a Java annotation type. If the
type is not a Java annotation type, a DefinitionException is thrown by the container at
deployment time</text>
+ <text>Each child element is interpreted as a Java annotation type. If the
type is not a Java annotation type, a |DefinitionException| is thrown by the container at
deployment time</text>
</assertion>
<assertion id="c">
@@ -5763,45 +5745,45 @@
</assertion>
<assertion id="f">
- <text>If the annotation type is javax.annotation.Name, the name of the
producer method or field was declared, as defined in Section 2.6.2, "Declaring the
bean name using XML".</text>
+ <text>If the annotation type is |javax.annotation.Name|, the name of the
producer method or field was declared, as defined in Section 2.6.2, "Declaring the
bean name using XML".</text>
</assertion>
<assertion id="g">
- <text>If the annotation type is not a deployment type, or a scope type, or a
stereotype, or a javax.annotation.Name, a DefinitionException is thrown by the container
at deployment time</text>
+ <text>If the annotation type is not a deployment type, or a scope type, or a
stereotype, or a |javax.annotation.Name|, a |DefinitionException| is thrown by the
container at deployment time</text>
</assertion>
</section>
<section id="9.7" title="Interceptor and decorator
declarations">
<assertion id="a">
- <text>A simple bean declaration is interpreted as an interceptor declaration
if it contains a direct child <Interceptor> element in the Java EE
namespace</text>
+ <text>A simple bean declaration is interpreted as an interceptor declaration
if it contains a direct child |<Interceptor>| element in the Java EE
namespace</text>
</assertion>
<assertion id="b">
- <text>A simple bean declaration is interpreted as a decorator declaration if
it contains a direct child <Decorator> element in the Java EE
namespace</text>
+ <text>A simple bean declaration is interpreted as a decorator declaration if
it contains a direct child |<Decorator>| element in the Java EE
namespace</text>
</assertion>
<assertion id="c">
- <text>If a bean declaration that is not a simple bean declaration contains a
child <Interceptor> element, a DefinitionException is thrown by the
container at deployment time.</text>
+ <text>If a bean declaration that is not a simple bean declaration contains a
child |<Interceptor>| element, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="d">
- <text>If a bean declaration that is not a simple bean declaration contains a
child <Decorator> element, a DefinitionException is thrown by the container
at deployment time.</text>
+ <text>If a bean declaration that is not a simple bean declaration contains a
child |<Decorator>| element, a |DefinitionException| is thrown by the
container at deployment time.</text>
</assertion>
<assertion id="e">
- <text>If an inline bean declaration contains a child
<Interceptor> element, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>If an inline bean declaration contains a child
|<Interceptor>| element, a |DefinitionException| is thrown by the container
at deployment time.</text>
</assertion>
<assertion id="f">
- <text>If an inline bean declaration contains a child
<Decorator> element, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>If an inline bean declaration contains a child
|<Decorator>| element, a |DefinitionException| is thrown by the container at
deployment time.</text>
</assertion>
<assertion id="g">
- <text>If a simple bean declaration contains more than one direct child
<Interceptor> element in the Java EE namespace, a DefinitionException is
thrown by the container at deployment time.</text>
+ <text>If a simple bean declaration contains more than one direct child
|<Interceptor>| element in the Java EE namespace, a |DefinitionException| is
thrown by the container at deployment time.</text>
</assertion>
<assertion id="h">
- <text>If a simple bean declaration contains more than one direct child
<Decorator> element in the Java EE namespace, a DefinitionException is
thrown by the container at deployment time.</text>
+ <text>If a simple bean declaration contains more than one direct child
|<Decorator>| element in the Java EE namespace, a |DefinitionException| is
thrown by the container at deployment time.</text>
</assertion>
</section>
@@ -5819,7 +5801,7 @@
</assertion>
<assertion id="d">
- <text>If a direct child element of a decorator declaration exists in the same
namespace as its parent, and has direct child <Decorates> element in the
Java EE namespace then it is interpreted as a delegate declaration.</text>
+ <text>If a direct child element of a decorator declaration exists in the same
namespace as its parent, and has direct child |<Decorates>| element in the
Java EE namespace then it is interpreted as a delegate declaration.</text>
</assertion>
<assertion id="e">
@@ -5827,19 +5809,19 @@
</assertion>
<assertion id="f">
- <text>If the bean class does not have have a field with the specified name, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the bean class does not have have a field with the specified name, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="g">
- <text>If a delegate declaration has more than one direct child element, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If a delegate declaration has more than one direct child element, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="h">
- <text>The child element of the delegate declaration is a
<Decorates> element in the Java EE namespace. If the
<Decorates> element does not, in turn, have exactly one direct child
element, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>The child element of the delegate declaration is a
|<Decorates>| element in the Java EE namespace. If the
|<Decorates>| element does not, in turn, have exactly one direct child
element, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="i">
- <text>The direct child element of the <Decorates> element is
interpreted as a type declaration as specified by Section 9.10, "Specifying bean
types and bindings". If the declared bean type is not assignable to the type of the
Java field, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>The direct child element of the |<Decorates>| element is
interpreted as a type declaration as specified by Section 9.10, "Specifying bean
types and bindings". If the declared bean type is not assignable to the type of the
Java field, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="j">
@@ -5847,7 +5829,7 @@
</assertion>
<assertion id="k">
- <text>If simple bean declaration that is not a decorator declaration contains
a direct child element that in turn contains a direct child <Decorates>
element, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>If simple bean declaration that is not a decorator declaration contains
a direct child element that in turn contains a direct child |<Decorates>|
element, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
</section>
@@ -5858,7 +5840,7 @@
</assertion>
<assertion id="b">
- <text>When the container encounters an injection point declaration, it
interprets the element as a Java class or interface. If no such Java type exists in the
classpath, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>When the container encounters an injection point declaration, it
interprets the element as a Java class or interface. If no such Java type exists in the
classpath, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="c">
@@ -5888,7 +5870,7 @@
</assertion>
<assertion id="c">
- <text>Inline bean declarations may not explicitly specify a binding type. If
an inline bean declaration explicitly specifies a binding type, a DefinitionException is
thrown by the container at deployment time.</text>
+ <text>Inline bean declarations may not explicitly specify a binding type. If
an inline bean declaration explicitly specifies a binding type, a |DefinitionException| is
thrown by the container at deployment time.</text>
</assertion>
<assertion id="d">
@@ -5918,7 +5900,7 @@
</assertion>
<assertion id="e">
- <text>A type declaration is an element that represents a Java class or
interface, or <Array></text>
+ <text>A type declaration is an element that represents a Java class or
interface, or |<Array>|</text>
</assertion>
<assertion id="f">
@@ -5934,15 +5916,15 @@
</assertion>
<assertion id="i">
- <text>If the element is an <Array> element in the Java EE
namespace, an array type was declared.</text>
+ <text>If the element is an |<Array>| element in the Java EE
namespace, an array type was declared.</text>
</assertion>
<assertion id="j">
- <text>Otherwise, the element is interpreted as a Java class or interface. If
no such Java type exists in the classpath, a DefinitionException is thrown by the
container at deployment time. If the Java type is not a class or interface type, a
DefinitionException is thrown by the container at deployment time</text>
+ <text>Otherwise, the element is interpreted as a Java class or interface. If
no such Java type exists in the classpath, a |DefinitionException| is thrown by the
container at deployment time. If the Java type is not a class or interface type, a
|DefinitionException| is thrown by the container at deployment time</text>
</assertion>
<assertion id="k">
- <text>The container inspects every direct child element of the type
declaration. Each child element is interpreted as a Java type. If no such Java type exists
in the classpath, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>The container inspects every direct child element of the type
declaration. Each child element is interpreted as a Java type. If no such Java type exists
in the classpath, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="l">
@@ -5954,31 +5936,31 @@
</assertion>
<assertion id="n">
- <text>If the type is not a Java annotation type or a Java class or interface
type, a DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the type is not a Java annotation type or a Java class or interface
type, a |DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="o">
- <text>If multiple array element types are declared, a DefinitionException is
thrown by the container at deployment time.</text>
+ <text>If multiple array element types are declared, a |DefinitionException|
is thrown by the container at deployment time.</text>
</assertion>
<assertion id="p">
- <text>If the number of declared actual type parameters is not the same as the
number of parameters of the Java type, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>If the number of declared actual type parameters is not the same as the
number of parameters of the Java type, a |DefinitionException| is thrown by the container
at deployment time.</text>
</assertion>
<assertion id="q">
- <text>If a type parameter of the Java type is bounded, and the corresponding
declared actual type parameter does not satisfy the upper or lower bound, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If a type parameter of the Java type is bounded, and the corresponding
declared actual type parameter does not satisfy the upper or lower bound, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="r">
- <text>If a binding declaration declares a Java annotation type that is not a
binding type, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>If a binding declaration declares a Java annotation type that is not a
binding type, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="s">
- <text>If no binding is declared, the default binding @Current is
assumed</text>
+ <text>If no binding is declared, the default binding |@Current| is
assumed</text>
</assertion>
<assertion id="t">
- <text>If the same binding type occurs more than once, a
DuplicateBindingTypeException is thrown by the container at deployment time.</text>
+ <text>If the same binding type occurs more than once, a
|DuplicateBindingTypeException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="u">
@@ -6020,7 +6002,7 @@
</assertion>
<assertion id="f">
- <text>If there is no annotation member with the same name as the attribute, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If there is no annotation member with the same name as the attribute, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="g">
@@ -6029,11 +6011,11 @@
<assertion id="h">
<text>If the XML element has a non-empty body and also specifies an attribute
named value, a
-DefinitionException is thrown by the container at deployment time.</text>
+|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
<assertion id="i">
- <text>If the XML element has a non-empty body, and there is no annotation
member named value, a DefinitionException is thrown by the container at deployment
time</text>
+ <text>If the XML element has a non-empty body, and there is no annotation
member named value, a |DefinitionException| is thrown by the container at deployment
time</text>
</assertion>
<assertion id="j">
@@ -6041,7 +6023,7 @@
</assertion>
<assertion id="k">
- <text>The value of a member of type java.lang.String is specified using the
string value</text>
+ <text>The value of a member of type |java.lang.String| is specified using the
string value</text>
</assertion>
<assertion id="l">
@@ -6049,64 +6031,64 @@
</assertion>
<assertion id="m">
- <text>The value of a member of type java.lang.Class is specified using the
fully qualified Java class name.</text>
+ <text>The value of a member of type |java.lang.Class| is specified using the
fully qualified Java class name.</text>
</assertion>
<assertion id="n">
- <text>If the member value is not specified in the correct format for the type
of the member, a DefinitionException is thrown by the container at deployment
time.</text>
+ <text>If the member value is not specified in the correct format for the type
of the member, a |DefinitionException| is thrown by the container at deployment
time.</text>
</assertion>
<assertion id="o">
- <text>If an XML element that refers to a Java annotation with a member with
no default value does not declare a value for that member, a DefinitionException is thrown
by the container at deployment time.</text>
+ <text>If an XML element that refers to a Java annotation with a member with
no default value does not declare a value for that member, a |DefinitionException| is
thrown by the container at deployment time.</text>
</assertion>
</section>
<section id="9.12" title="Deployment declarations">
<assertion id="a">
- <text>The <Deploy>, <Interceptors> and
<Decorators> elements in the Java EE namespace determine which beans,
interceptors and decorators are enabled in a particular deployment</text>
+ <text>The |<Deploy>|, |<Interceptors>| and
|<Decorators>| elements in the Java EE namespace determine which beans,
interceptors and decorators are enabled in a particular deployment</text>
</assertion>
</section>
<section id="9.12.1" title="The <Deploy>
declaration">
<assertion id="a">
- <text>Each direct child element of a <Deploy> element is
interpreted as the declaring an enabled deployment type, as specified in Section 2.5.6,
"Enabled deployment types"</text>
+ <text>Each direct child element of a |<Deploy>| element is
interpreted as the declaring an enabled deployment type, as specified in Section 2.5.6,
"Enabled deployment types"</text>
</assertion>
<assertion id="b">
- <text>Each child element is interpreted as a Java annotation type. If no such
Java type exists in the classpath, a DefinitionException is thrown by the container at
deployment time. If the type is not a deployment type, a DefinitionException is thrown by
the container at deployment time.</text>
+ <text>Each child element is interpreted as a Java annotation type. If no such
Java type exists in the classpath, a |DefinitionException| is thrown by the container at
deployment time. If the type is not a deployment type, a |DefinitionException| is thrown
by the container at deployment time.</text>
</assertion>
<assertion id="c">
- <text>If the same deployment type is declared more than once, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the same deployment type is declared more than once, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
</section>
<section id="9.12.2" title="The <Interceptors>
declaration">
<assertion id="a">
- <text>Each direct child element of an <Interceptors> element is
interpreted as the declaring an enabled interceptor, as specified in Section A.3.7,
"Interceptor enablement and ordering".</text>
+ <text>Each direct child element of an |<Interceptors>| element
is interpreted as the declaring an enabled interceptor, as specified in Section A.3.7,
"Interceptor enablement and ordering".</text>
</assertion>
<assertion id="b">
- <text>Each child element is interpreted as a Java class. If no such Java
class exists in the classpath, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>Each child element is interpreted as a Java class. If no such Java
class exists in the classpath, a |DefinitionException| is thrown by the container at
deployment time.</text>
</assertion>
<assertion id="c">
- <text>If the same interceptor is declared more than once, a
DefinitionException is thrown by the container at deployment time.</text>
+ <text>If the same interceptor is declared more than once, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
</section>
<section id="9.12.3" title="The <Decorators>
declaration">
<assertion id="a">
- <text>Each direct child element of a <Decorators> element is
interpreted as the declaring an enabled decorator, as specified in Section A.5.5,
"Decorator enablement and ordering".</text>
+ <text>Each direct child element of a |<Decorators>| element is
interpreted as the declaring an enabled decorator, as specified in Section A.5.5,
"Decorator enablement and ordering".</text>
</assertion>
<assertion id="b">
- <text>Each child element is interpreted as a Java class. If no such Java
class exists in the classpath, a DefinitionException is thrown by the container at
deployment time.</text>
+ <text>Each child element is interpreted as a Java class. If no such Java
class exists in the classpath, a |DefinitionException| is thrown by the container at
deployment time.</text>
</assertion>
<assertion id="c">
- <text>If the same decorator is declared more than once, a DefinitionException
is thrown by the container at deployment time.</text>
+ <text>If the same decorator is declared more than once, a
|DefinitionException| is thrown by the container at deployment time.</text>
</assertion>
</section>