[webbeans-commits] Webbeans SVN: r1397 - in tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit: definition/deployment and 1 other directory.

Author: dallen6 Date: 2009-02-03 17:14:04 -0500 (Tue, 03 Feb 2009) New Revision: 1397 Modified: tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/context/NormalContextTest.java tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java Log: Verified tests are at PRD2 version. Modified: tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/context/NormalContextTest.java =================================================================== --- tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/context/NormalContextTest.java 2009-02-03 15:47:47 UTC (rev 1396) +++ tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/context/NormalContextTest.java 2009-02-03 22:14:04 UTC (rev 1397) @@ -6,6 +6,7 @@ import javax.context.Contextual; import javax.context.CreationalContext; import javax.context.SessionScoped; +import javax.inject.manager.Bean; import org.jboss.webbeans.tck.AbstractTest; import org.jboss.webbeans.tck.impl.SpecAssertion; @@ -43,11 +44,13 @@ public void testGetReturnsExistingInstance() { deployBeans(MySessionBean.class); - MySessionBean beanInstance = manager.getInstanceByType(MySessionBean.class); Contextual<MySessionBean> mySessionBean = manager.resolveByType(MySessionBean.class).iterator().next(); + MyCreationalContext<MySessionBean> myCreationalContext = new MyCreationalContext<MySessionBean>(); + MySessionBean beanInstance = manager.getContext(SessionScoped.class).get(mySessionBean, myCreationalContext); + assert beanInstance != null; MySessionBean beanInstanceFromGet = manager.getContext(SessionScoped.class).get(mySessionBean); - assert beanInstanceFromGet.equals(beanInstance); + assert beanInstanceFromGet == beanInstance; } /** @@ -150,12 +153,28 @@ * A destroyed instance must not subsequently be returned by the get() * method. */ - @Test(groups = { "contexts", "stub", "underInvestigation" }) + @Test(groups = { "contexts", "broken" }) @SpecAssertion(section = "8.1", id = "unknown") public void testDestroyedInstanceMustNotBeReturnedByGet() { - //TODO How is an instance destroyed such that the context is not and could later return the same instance - assert false; + deployBeans(MySessionBean.class, MyApplicationBean.class); + Bean<MySessionBean> mySessionBean = manager.resolveByType(MySessionBean.class).iterator().next(); + MyCreationalContext<MySessionBean> myCreationalContext = new MyCreationalContext<MySessionBean>(); + MySessionBean beanInstance = manager.getContext(SessionScoped.class).get(mySessionBean, myCreationalContext); + assert beanInstance != null; + mySessionBean.destroy(beanInstance); + MySessionBean beanInstanceFromGet = manager.getContext(SessionScoped.class).get(mySessionBean); + assert beanInstanceFromGet != beanInstance; + + Bean<MyApplicationBean> myApplicationBean = manager.resolveByType(MyApplicationBean.class).iterator().next(); + MyCreationalContext<MyApplicationBean> myCreationalContextForApplication = new MyCreationalContext<MyApplicationBean>(); + MyApplicationBean myApplicationBeanInstance = manager.getContext(ApplicationScoped.class).get(myApplicationBean, myCreationalContextForApplication); + assert myApplicationBeanInstance != null; + myApplicationBean.destroy(myApplicationBeanInstance); + + MyApplicationBean mySecondApplicationBeanInstance = manager.getContext(ApplicationScoped.class).get(myApplicationBean); + assert mySecondApplicationBeanInstance != null; + assert myApplicationBeanInstance != mySecondApplicationBeanInstance; } /** Modified: tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java =================================================================== --- tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java 2009-02-03 15:47:47 UTC (rev 1396) +++ tck/trunk/impl/src/main/java/org/jboss/webbeans/tck/unit/definition/deployment/DeploymentTypeDefinitionTest.java 2009-02-03 22:14:04 UTC (rev 1397) @@ -1,7 +1,6 @@ package org.jboss.webbeans.tck.unit.definition.deployment; import java.lang.annotation.Annotation; -import java.lang.reflect.Method; import java.util.List; import javax.inject.DefinitionException; @@ -17,12 +16,12 @@ /** * - * Spec version: PRD2 - * + * Spec version: Public Release Draft 2 + * */ public class DeploymentTypeDefinitionTest extends AbstractTest { - + @Override protected List<Class<? extends Annotation>> getEnabledDeploymentTypes() { @@ -30,151 +29,240 @@ deploymentTypes.add(AnotherDeploymentType.class); deploymentTypes.add(HornedAnimalDeploymentType.class); deploymentTypes.add(NotInheritedDeploymentType.class); + deploymentTypes.add(InheritedDeploymentType.class); return deploymentTypes; } - - @Test(expectedExceptions=DefinitionException.class) - @SpecAssertion(section="2.5.1", id = "unknown") + + /** + * 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") public void testNonBuiltInComponentUsesStandard() { - createSimpleBean(Gazelle_Broken.class); + deployBeans(Gazelle_Broken.class); } - - @Test(groups={"stub", "annotationDefinition"}) - @SpecAssertion(section="2.5.2", id = "unknown") + + /** + * 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 = { "stub", "annotationDefinition", "deploymentType" }) + @SpecAssertion(section = "2.5.2", id = "unknown") public void testDeploymentTypeHasCorrectTarget() { assert false; } - @Test(groups={"stub", "annotationDefinition"}) - @SpecAssertion(section="2.5.2", id = "unknown") + /** + * 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 = { "stub", "annotationDefinition", "deploymentType" }) + @SpecAssertion(section = "2.5.2", id = "unknown") public void testDeploymentTypeHasCorrectRetention() { assert false; } - @Test(groups={"stub", "annotationDefinition"}) - @SpecAssertion(section="2.5.2", id = "unknown") - public void testDeploymentTypeDeclaresScopeTypeAnnotation() + /** + * All de- ployment types must also specify the @javax.inject.DeploymentType + * meta-annotation. + * + * TODO This text is not really a testable assertion + */ + @Test(groups = { "stub", "annotationDefinition", "deploymentType" }) + @SpecAssertion(section = "2.5.2", id = "unknown") + public void testDeploymentTypeDeclaresDeploymentTypeAnnotation() { assert false; } - - @Test(expectedExceptions=DefinitionException.class) - @SpecAssertion(section="2.5.3", id = "unknown") + + /** + * 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. + */ + @Test(groups = { "deploymentType" }, expectedExceptions = DefinitionException.class) + @SpecAssertion(section = "2.5.3", id = "unknown") public void testTooManyDeploymentTypes() { - createSimpleBean(BeanWithTooManyDeploymentTypes_Broken.class); + deployBeans(BeanWithTooManyDeploymentTypes_Broken.class); } - - @SuppressWarnings("unchecked") - @Test @SpecAssertion(section="2.5.3", id = "unknown") + + /** + * 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") public void testDeploymentTypeInhertitedFromDeclaringBean() throws Exception { - Bean<SpiderProducer> bean = createSimpleBean(SpiderProducer.class); - manager.addBean(bean); - Method method = SpiderProducer.class.getMethod("produceBlackWidow"); - Bean<BlackWidow> blackWidowSpiderModel = createProducerMethodBean(method, bean); + deployBeans(SpiderProducer.class); + Bean<BlackWidow> blackWidowSpiderModel = manager.resolveByType(BlackWidow.class).iterator().next(); assert blackWidowSpiderModel.getDeploymentType().equals(AnotherDeploymentType.class); } - - @Test(groups={"stub", "webbeansxml"}) - @SpecAssertion(section="2.5.4", id = "unknown") - public void testXmlDeploymentTypeOverridesJava() + + /** + * 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") + public void testXmlDeploymentTypeElement() { - //Map<Class<? extends Annotation>, Annotation> xmlDefinedDeploymentTypeAnnotations = new HashMap<Class<? extends Annotation>, Annotation>(); - //xmlDefinedDeploymentTypeAnnotations.put(AnotherDeploymentType.class, new AnotherDeploymentTypeAnnotationLiteral()); - //AnnotatedClass<BeanWithTooManyDeploymentTypes> xmlDefinedDeploymentTypeAnnotatedItem = new SimpleAnnotatedClass<BeanWithTooManyDeploymentTypes>(BeanWithTooManyDeploymentTypes.class, xmlDefinedDeploymentTypeAnnotations); - - //SimpleBean<BeanWithTooManyDeploymentTypes> model = createSimpleBean(BeanWithTooManyDeploymentTypes.class, xmlDefinedDeploymentTypeAnnotatedItem, manager); - //assert model.getDeploymentType().equals(AnotherDeploymentType.class); + // Map<Class<? extends Annotation>, Annotation> + // xmlDefinedDeploymentTypeAnnotations = new HashMap<Class<? extends + // Annotation>, Annotation>(); + // xmlDefinedDeploymentTypeAnnotations.put(AnotherDeploymentType.class, + // new AnotherDeploymentTypeAnnotationLiteral()); + // AnnotatedClass<BeanWithTooManyDeploymentTypes> + // xmlDefinedDeploymentTypeAnnotatedItem = new + // SimpleAnnotatedClass<BeanWithTooManyDeploymentTypes>(BeanWithTooManyDeploymentTypes.class, + // xmlDefinedDeploymentTypeAnnotations); + + // SimpleBean<BeanWithTooManyDeploymentTypes> model = + // createSimpleBean(BeanWithTooManyDeploymentTypes.class, + // xmlDefinedDeploymentTypeAnnotatedItem, manager); + // assert model.getDeploymentType().equals(AnotherDeploymentType.class); assert false; } - - - @Test(groups={"stub", "webbeansxml"}) - @SpecAssertion(section="2.5.4", id = "unknown") - public void testXmlRespectsJavaDeploymentType() + /** + * 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") + public void testDefaultDeploymentType() { - //AnnotatedClass<Tuna> annotatedItem = new SimpleAnnotatedClass<Tuna>(Tuna.class, new HashMap<Class<? extends Annotation>, Annotation>()); - //SimpleBean<Tuna> tuna = createSimpleBean(Tuna.class, annotatedItem, manager); - //assert tuna.getDeploymentType().equals(AnotherDeploymentType.class); - assert false; + deployBeans(BlackWidow.class); + Bean<BlackWidow> bean = manager.resolveByType(BlackWidow.class).iterator().next(); + assert bean.getDeploymentType().equals(Production.class); } - - @Test(groups={"stub", "webbeansxml"}) - @SpecAssertion(section="2.5.5", id = "unknown") - public void testXmlDefaultDeploymentType() - { - //AnnotatedClass<Antelope> antelopeAnnotatedItem = new SimpleAnnotatedClass<Antelope>(Antelope.class, new HashMap<Class<? extends Annotation>, Annotation>()); - //SimpleBean<Antelope> antelope = createSimpleBean(Antelope.class, antelopeAnnotatedItem, manager); - // assert antelope.getDeploymentType().equals(Production.class); - assert false; - } - - @Test @SpecAssertion(section="2.5.5", id = "unknown") + + /** + * • 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") public void testHighestPrecedenceDeploymentTypeFromStereotype() { - Bean<?> bean = createSimpleBean(Rhinoceros.class); + deployBeans(Rhinoceros.class); + Bean<?> bean = manager.resolveByType(Rhinoceros.class).iterator().next(); assert bean.getDeploymentType().equals(HornedAnimalDeploymentType.class); } - - @SuppressWarnings("unchecked") - @Test(groups="beanLifecycle", expectedExceptions=UnsatisfiedDependencyException.class) - @SpecAssertion(section="2.5.6", id = "unknown") + + /** + * 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") public void testBeanWithDisabledDeploymentTypeNotInstantiated() - { - Bean<RedSnapper> bean = createSimpleBean(RedSnapper.class); - manager.addBean(bean); + { + deployBeans(RedSnapper.class); manager.getInstanceByType(RedSnapper.class); } - - - - @Test(groups={"stub", "webbeansxml"}, expectedExceptions=DeploymentException.class) - @SpecAssertion(section="2.5.6", id = "unknown") + /** + * 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") public void testMultipleDeployElementsCannotBeDefined() { - + } - - @Test - @SpecAssertions({ - @SpecAssertion(section= "2.5.5", id = "unknown"), - @SpecAssertion(section = "2.7.2", id = "unknown"), - @SpecAssertion(section = "4.1", id = "unknown") - }) + + /** + * If a bean explicitly declares a deployment type, any default deployment + * 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") }) public void testWebBeanDeploymentTypeOverridesStereotype() { - Bean<Reindeer> bean = createSimpleBean(Reindeer.class); + deployBeans(Reindeer.class); + Bean<Reindeer> bean = manager.resolveByType(Reindeer.class).iterator().next(); assert bean.getDeploymentType().equals(Production.class); } - - @Test @SpecAssertion(section="4.1", id = "unknown") + + /** + * 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") public void testDeploymentTypeDeclaredInheritedIsInherited() throws Exception { - assert createSimpleBean(BorderCollie.class).getDeploymentType().equals(AnotherDeploymentType.class); + deployBeans(BorderCollie.class); + assert manager.resolveByType(BorderCollie.class).iterator().next().getDeploymentType().equals(AnotherDeploymentType.class); } - - @Test @SpecAssertion(section="4.1", id = "unknown") + + /** + * 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") public void testDeploymentTypeNotDeclaredInheritedIsNotInherited() { - assert createSimpleBean(ShetlandPony.class).getDeploymentType().equals(Production.class); + deployBeans(ShetlandPony.class); + assert manager.resolveByType(ShetlandPony.class).iterator().next().getDeploymentType().equals(Production.class); } - - @Test @SpecAssertion(section="4.1", id = "unknown") + + /** + * 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") public void testDeploymentTypeDeclaredInheritedIsBlockedByIntermediateDeploymentTypeNotMarkedInherited() { - assert createSimpleBean(GoldenRetriever.class).getDeploymentType().equals(Production.class); + deployBeans(GoldenRetriever.class); + assert manager.resolveByType(GoldenRetriever.class).iterator().next().getDeploymentType().equals(Production.class); } - - @Test @SpecAssertion(section="4.1", id = "unknown") + + /** + * 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") public void testDeploymentTypeDeclaredInheritedIsBlockedByIntermediateDeploymentTypeMarkedInherited() { - assert createSimpleBean(GoldenLabrador.class).getDeploymentType().equals(InheritedDeploymentType.class); + deployBeans(GoldenLabrador.class); + assert manager.resolveByType(GoldenLabrador.class).iterator().next().getDeploymentType().equals(InheritedDeploymentType.class); } - + }