[webbeans-commits] Webbeans SVN: r764 - ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test.
webbeans-commits at lists.jboss.org
webbeans-commits at lists.jboss.org
Mon Jan 5 04:50:09 EST 2009
Author: nickarls
Date: 2009-01-05 04:50:09 -0500 (Mon, 05 Jan 2009)
New Revision: 764
Added:
ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewTest.java
Log:
@New tests
Added: ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewTest.java
===================================================================
--- ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewTest.java (rev 0)
+++ ri/trunk/webbeans-ri/src/test/java/org/jboss/webbeans/test/NewTest.java 2009-01-05 09:50:09 UTC (rev 764)
@@ -0,0 +1,393 @@
+package org.jboss.webbeans.test;
+
+import javax.webbeans.DefinitionException;
+
+import org.testng.annotations.Test;
+
+ at SpecVersion("20081222")
+public class NewTest extends AbstractTest
+{
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanIsDependentScoped()
+ {
+ assert false;
+ }
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanIsOfStandardDeploymentType()
+ {
+ assert false;
+ }
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanIsHasOnlyNewBinding()
+ {
+ assert false;
+ }
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoWebBeanName()
+ {
+ assert false;
+ }
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoStereotypes()
+ {
+ assert false;
+ }
+
+ /**
+ * When the built-in binding type @New is applied to an injection point, a
+ * Web Bean is implicitly defined with: • scope @Dependent, • deployment type
+ *
+ * @Standard, • @New as the only binding annotation, • no Web Bean name, • no
+ * stereotypes, and such that • the implementation class is the
+ * declared type of the injection point.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasImplementationClassOfInjectionPointType()
+ {
+ assert false;
+ }
+
+ /**
+ * If the parameter type satisfies the definition of a simple Web Bean
+ * implementation class, Section 3.2.1, “Which Java classes are simple Web
+ * Beans?”, then the Web Bean is a simple Web Bean. If the parameter type
+ * satisfies the definition of an enterprise Web Bean implementation class,
+ * Section 3.3.2, “Which EJBs are enterprise Web Beans?”, then the Web Bean
+ * is an enterprise Web Bean.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanIsSimpleWebBeanIfParameterTypeIsSimpleWebBean()
+ {
+ // TODO: has to be?
+ assert false;
+ }
+
+ /**
+ * If the parameter type satisfies the definition of a simple Web Bean
+ * implementation class, Section 3.2.1, “Which Java classes are simple Web
+ * Beans?”, then the Web Bean is a simple Web Bean. If the parameter type
+ * satisfies the definition of an enterprise Web Bean implementation class,
+ * Section 3.3.2, “Which EJBs are enterprise Web Beans?”, then the Web Bean
+ * is an enterprise Web Bean.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanIsEnterpriseWebBeanIfParameterTypeIsEnterpriseWebBean()
+ {
+ // TODO: has to be?
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasSameConstructorAsWrappedBean()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasSameInitializerMethodsAsWrappedBean()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasSameInjectedFieldsAsWrappedBean()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoObservers()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoProducerFields()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoProducerMethods()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoDisposalMethods()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasSameInterceptorMethodsAsWrappedBean()
+ {
+ assert false;
+ }
+
+ /**
+ * Furthermore, this Web Bean: • has the same Web Bean constructor,
+ * initializer methods and injected fields as a Web Bean defined using
+ * annotations— that is, it has any Web Bean constructor, initializer method
+ * or injected field declared by annotations that appear on the
+ * implementation class, • has no observer methods, producer methods or
+ * fields or disposal methods, • has the same interceptors as a Web Bean
+ * defined using annotations—that is, it has all the interceptor binding
+ * types declared by annotations that appear on the implementation class, and
+ * • has no decorators.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewBeanHasNoDecorators()
+ {
+ assert false;
+ }
+
+ /**
+ * The @New annotation or <New> element may be applied to any field of a Web
+ * Bean implementation class or to any parameter of a producer method,
+ * initializer method, disposal method or Web Bean constructor where the type
+ * of the field or parameter is a concrete Java type which satisfies the
+ * requirements of a simple Web Bean implementation class or enterprise Web
+ * Bean implementation class.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationMayBeAppliedToField()
+ {
+ assert false;
+ }
+
+ /**
+ * The @New annotation or <New> element may be applied to any field of a Web
+ * Bean implementation class or to any parameter of a producer method,
+ * initializer method, disposal method or Web Bean constructor where the type
+ * of the field or parameter is a concrete Java type which satisfies the
+ * requirements of a simple Web Bean implementation class or enterprise Web
+ * Bean implementation class.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationMayBeAppliedToProducerMethodParameter()
+ {
+ assert false;
+ }
+
+ /**
+ * The @New annotation or <New> element may be applied to any field of a Web
+ * Bean implementation class or to any parameter of a producer method,
+ * initializer method, disposal method or Web Bean constructor where the type
+ * of the field or parameter is a concrete Java type which satisfies the
+ * requirements of a simple Web Bean implementation class or enterprise Web
+ * Bean implementation class.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationMayBeAppliedToInitializerMethodParameter()
+ {
+ assert false;
+ }
+
+ /**
+ * The @New annotation or <New> element may be applied to any field of a Web
+ * Bean implementation class or to any parameter of a producer method,
+ * initializer method, disposal method or Web Bean constructor where the type
+ * of the field or parameter is a concrete Java type which satisfies the
+ * requirements of a simple Web Bean implementation class or enterprise Web
+ * Bean implementation class.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationMayBeAppliedToConstructorMethodParameter()
+ {
+ assert false;
+ }
+
+ /**
+ * If the @New binding type appears in conjunction with some other binding
+ * type, or is specified for a field or parameter of a type which does not
+ * satisfy the definition of a simple Web Bean implementation class or
+ * enterprise Web Bean implementation class, a DefinitionException is thrown
+ * by the container at deployment time.
+ */
+ @Test(groups = { "stub", "new" })
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationCannotAppearInConjunctionWithOtherBindingType()
+ {
+ assert false;
+ }
+
+ /**
+ * If the @New binding type appears in conjunction with some other binding
+ * type, or is specified for a field or parameter of a type which does not
+ * satisfy the definition of a simple Web Bean implementation class or
+ * enterprise Web Bean implementation class, a DefinitionException is thrown
+ * by the container at deployment time.
+ */
+ @Test(groups = { "stub", "new" }, expectedExceptions = DefinitionException.class)
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationCannotBeAppliedToNonWebBeanImplementationClass()
+ {
+ assert false;
+ }
+
+ /**
+ * No Web Bean defined using annotations or XML may explicitly declare @New
+ * as a binding type
+ */
+ @Test(groups = { "stub", "new" }, expectedExceptions = DefinitionException.class)
+ @SpecAssertion(section = "3.9")
+ public void testNewAnnotationCannotBeExplicitlyDeclared()
+ {
+ assert false;
+ }
+}
More information about the weld-commits
mailing list