4:44 a.m.
Author: shane.bryzak(a)jboss.com
Date: 2009-02-11 05:44:19 -0500 (Wed, 11 Feb 2009)
New Revision: 1481
Modified:
tck/trunk/impl/src/main/java/org/jboss/jsr299/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java
tck/trunk/impl/tck-audit.xml
Log:
more assertion mappings
Modified:
tck/trunk/impl/src/main/java/org/jboss/jsr299/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java
===================================================================
---
tck/trunk/impl/src/main/java/org/jboss/jsr299/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java 2009-02-11
01:57:42 UTC (rev 1480)
+++
tck/trunk/impl/src/main/java/org/jboss/jsr299/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java 2009-02-11
10:44:19 UTC (rev 1481)
@@ -34,65 +34,48 @@
return deploymentTypes;
}
- /**
- * No bean may be declared with the (@Standard-bean) deployment type unless
- * explicitly required by this specification.
- */
@Test(groups = { "deploymentType" }, expectedExceptions =
DefinitionException.class)
- @SpecAssertion(section = "2.5.1", id = "unknown")
+ @SpecAssertion(section = "2.5.1", id = "b")
public void testNonBuiltInComponentUsesStandard()
{
deployBeans(Gazelle_Broken.class);
}
/**
- * A deployment type is a Java annotation defined as @Target({TYPE, METHOD,
- * FIELD}) and @Retention(RUNTIME).
*
* TODO This text is not really a testable assertion
*/
@Test(groups = { "underInvestigation", "annotationDefinition",
"deploymentType" })
- @SpecAssertion(section = "2.5.2", id = "unknown")
+ @SpecAssertion(section = "2.5.2", id = "a")
public void testDeploymentTypeHasCorrectTarget()
{
assert false;
}
/**
- * A deployment type is a Java annotation defined as @Target({TYPE, METHOD,
- * FIELD}) and @Retention(RUNTIME).
*
* TODO This text is not really a testable assertion
*/
@Test(groups = { "underInvestigation", "annotationDefinition",
"deploymentType" })
- @SpecAssertion(section = "2.5.2", id = "unknown")
+ @SpecAssertion(section = "2.5.2", id = "b")
public void testDeploymentTypeHasCorrectRetention()
{
assert false;
}
/**
- * All de- ployment types must also specify the @javax.inject.DeploymentType
- * meta-annotation.
*
* TODO This text is not really a testable assertion
*/
@Test(groups = { "underInvestigation", "annotationDefinition",
"deploymentType" })
- @SpecAssertion(section = "2.5.2", id = "unknown")
+ @SpecAssertion(section = "2.5.2", id = "c")
public void testDeploymentTypeDeclaresDeploymentTypeAnnotation()
{
assert false;
}
- /**
- * By default, if no deployment type annotation is explicitly specified, a
- * producer method or field inherits the deployment type of the bean in which
- * it is defined.
- *
- * @throws Exception
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "2.5.3", id = "unknown")
+ @SpecAssertion(section = "2.5.3", id = "c")
public void testDeploymentTypeInhertitedFromDeclaringBean() throws Exception
{
deployBeans(SpiderProducer.class);
@@ -101,14 +84,12 @@
}
/**
- * When a bean is declared in beans.xml, the deployment type may be specified
- * using a tag with the annotation type name:
*
* TODO Section 2.5.4 does not claim that XML overrides Java for deployment
* types
*/
@Test(groups = { "stub", "webbeansxml", "deploymentType"
})
- @SpecAssertion(section = "2.5.4", id = "unknown")
+ @SpecAssertion(section = "2.5.4", id = "a")
public void testXmlDeploymentTypeElement()
{
// Map<Class<? extends Annotation>, Annotation>
@@ -128,16 +109,8 @@
assert false;
}
- /**
- * 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-bean).
- *
- */
@Test(groups = { "webbeansxml", "deploymentType" })
- @SpecAssertion(section = "2.5.5", id = "unknown")
+ @SpecAssertion(section = "2.5.5", id = "a")
public void testDefaultDeploymentType()
{
deployBeans(BlackWidow.class);
@@ -145,13 +118,8 @@
assert bean.getDeploymentType().equals(Production.class);
}
- /**
- * • Otherwise, the default deployment type for the bean is the
- * highest-precedence default deployment type declared by any stereotype
- * declared by the bean.
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "2.5.5", id = "unknown")
+ @SpecAssertion(section = "2.5.5", id = "b")
public void testHighestPrecedenceDeploymentTypeFromStereotype()
{
deployBeans(Rhinoceros.class);
@@ -159,25 +127,16 @@
assert bean.getDeploymentType().equals(HornedAnimalDeploymentType.class);
}
- /**
- * If the deployment type is enabled, an instance of the bean may be obtained
- * by lookup, injection or EL resolution. Otherwise, the bean is never
- * instantiated by the container.
- */
@Test(groups = { "beanLifecycle", "deploymentType" },
expectedExceptions = UnsatisfiedDependencyException.class)
- @SpecAssertion(section = "2.5.6", id = "unknown")
+ @SpecAssertion(section = "2.5.6", id = "a")
public void testBeanWithDisabledDeploymentTypeNotInstantiated()
{
deployBeans(RedSnapper.class);
manager.getInstanceByType(RedSnapper.class);
}
- /**
- * If more than one deployment type is specified in XML, a
- * DefinitionException is thrown by the container at deployment time.
- */
@Test(groups = { "stub", "webbeansxml", "deploymentType"
}, expectedExceptions = DeploymentException.class)
- @SpecAssertion(section = "2.5.4", id = "unknown")
+ @SpecAssertion(section = "2.5.4", id = "b")
public void testMultipleDeployElementsCannotBeDefined()
{
@@ -188,7 +147,9 @@
* type declared by stereotypes are ignored.
*/
@Test(groups = { "deploymentType" })
- @SpecAssertions( { @SpecAssertion(section = "2.5.5", id =
"unknown"), @SpecAssertion(section = "2.7.2", id =
"unknown"), @SpecAssertion(section = "4.1", id = "unknown")
})
+ @SpecAssertions( { @SpecAssertion(section = "2.5.5", id =
"unknown"),
+ @SpecAssertion(section = "2.7.2", id = "unknown"),
+ @SpecAssertion(section = "4.1", id = "d") })
public void testWebBeanDeploymentTypeOverridesStereotype()
{
deployBeans(Reindeer.class);
@@ -196,58 +157,32 @@
assert bean.getDeploymentType().equals(Production.class);
}
- /**
- * 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.
- *
- * @throws Exception
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "4.1", id = "unknown")
+ @SpecAssertion(section = "4.1", id = "c")
public void testDeploymentTypeDeclaredInheritedIsInherited() throws Exception
{
deployBeans(BorderCollie.class);
assert
manager.resolveByType(BorderCollie.class).iterator().next().getDeploymentType().equals(AnotherDeploymentType.class);
}
- /**
- * 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.
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "4.1", id = "unknown")
+ @SpecAssertion(section = "4.1", id = "c")
public void testDeploymentTypeNotDeclaredInheritedIsNotInherited()
{
deployBeans(ShetlandPony.class);
assert
manager.resolveByType(ShetlandPony.class).iterator().next().getDeploymentType().equals(Production.class);
}
- /**
- * 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.
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "4.1", id = "unknown")
+ @SpecAssertion(section = "4.1", id = "c")
public void
testDeploymentTypeDeclaredInheritedIsBlockedByIntermediateDeploymentTypeNotMarkedInherited()
{
deployBeans(GoldenRetriever.class);
assert
manager.resolveByType(GoldenRetriever.class).iterator().next().getDeploymentType().equals(Production.class);
}
- /**
- * 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.
- */
@Test(groups = { "deploymentType" })
- @SpecAssertion(section = "4.1", id = "unknown")
+ @SpecAssertion(section = "4.1", id = "c")
public void
testDeploymentTypeDeclaredInheritedIsBlockedByIntermediateDeploymentTypeMarkedInherited()
{
deployBeans(GoldenLabrador.class);
Modified: tck/trunk/impl/tck-audit.xml
===================================================================
--- tck/trunk/impl/tck-audit.xml 2009-02-11 01:57:42 UTC (rev 1480)
+++ tck/trunk/impl/tck-audit.xml 2009-02-11 10:44:19 UTC (rev 1481)
@@ -165,6 +165,117 @@
<text>When the bindings of a parameter are specified using XML, any binding
annotations of the parameter are ignored</text>
</assertion>
</section>
+
+ <section id="2.4" title="Scopes">
+
+ <assertion id="a">
+ <text>All beans have a scope</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>A scope type is represented by an annotation type.</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>The set of scope types is extensible</text>
+ </assertion>
+
+ </section>
+
+ <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>
+ </assertion>
+
+ <assertion id="b">
+ <text>No bean may be declared with the @Standard deployment type unless
explicitly required by this specification</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>Application beans may be defined using the @Production deployment
type</text>
+ </assertion>
+
+ </section>
+
+ <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>
+ </assertion>
+
+ <assertion id="b">
+ <text>A deployment type is a Java annotation defined with
@Retention(RUNTIME)</text>
+ </assertion>
+
+ <assertion id="c">
+ <text>All deployment types must also specify the @javax.inject.DeploymentType
meta-annotation.</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>Applications and third-party frameworks may define their own deployment
types</text>
+ </assertion>
+
+ </section>
+
+ <section id="2.5.3" title="Declaring the deployment type of a bean
using annotations">
+
+ <assertion id="a">
+ <text>The deployment type of the bean is declared by annotating the bean
class or producer method or field</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>An bean class or producer method or 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="c">
+ <text>By default, if no deployment type annotation is explicitly specified, a
producer method or field inherits the deployment type of the bean in which it is
defined.</text>
+ </assertion>
+
+ <assertion id="d">
+ <text>a deployment type may be specified using a stereotype annotation, as
defined in Section 2.7.2, "Declaring the stereotypes for a bean using
annotations".</text>
+ </assertion>
+
+ </section>
+
+ <section id="2.5.4" title="Declaring the deployment type of a bean
using XML">
+ <assertion id="a">
+ <text>When a bean is declared in beans.xml, the deployment type may be
specified using a tag with the annotation type name</text>
+ </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>
+ </assertion>
+
+ <assertion id="c">
+ <text>A deployment type may be specified using a stereotype declared in XML,
as defined in Section 2.7.3, "Declaring the stereotypes for a bean using
XML".</text>
+ </assertion>
+ </section>
+
+ <section id="2.5.5" title="Default deployment type">
+
+ <assertion id="a">
+ <text>The default deployment type for a bean which does not explicitly
declare a deployment type depends upon its declared stereotypes - if a bean does not
declare any stereotype with a declared default deployment type, then the default
deployment type is
+@Production</text>
+ </assertion>
+
+ <assertion id="b">
+ <text>Otherwise, the default deployment type for the bean is the
highest-precedence default deployment type declared by any stereotype declared by the
bean</text>
+ <note>This assertion relates to assertion 2.5.5.b</note>
+ </assertion>
+
+ <assertion id="c">
+ <text>If a bean explicitly declares a deployment type, any default deployment
type declared by stereotypes are ignored.</text>
+ </assertion>
+ </section>
+
+ <section id="2.5.6" title="Enabled deployment types">
+
+ <assertion id="a">
+ <text>Beans declared with a deployment type that is not enabled are not
available to the resolution algorithms defined in Chapter 5, Lookup, dependency injection
and EL resolution.</text>
+ </assertion>
+
+ </section>
<section id="3" title="Bean Implementation">