[webbeans-commits] Webbeans SVN: r2106 - tck/trunk/impl/src/main/resources.
webbeans-commits at lists.jboss.org
webbeans-commits at lists.jboss.org
Thu Mar 19 05:01:40 EDT 2009
Author: shane.bryzak at 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 |@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 |@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 ~@Retention(RUNTIME).</text>
+ <text>A binding type is a Java annotation defined as ~|@Target({METHOD, FIELD, PARAMETER, TYPE})| and ~|@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 |@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 |@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 |@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 at 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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 _ at 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 _ at 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 _ at 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 _ at 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 _ at 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 _ at 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 _ at 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 _ at 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 |@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 |@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 |@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 |@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 |@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 |@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
- at javax.inject.Obtains binding</text>
+ <text>An instance of the |javax.inject.Instance| interface may be injected via use of the
+|@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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 |@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>
More information about the weld-commits
mailing list