throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
@Test @SpecAssertions({ @SpecAssertion(section = NEW_EE, id = "j"), @SpecAssertion(section = NEW_EE, id = "k") }) public void testForEachEnterpriseBeanANewBeanExists() { Bean<OrderLocal> orderBean = getBeans(OrderLocal.class).iterator().next(); Set<Bean<OrderLocal>> newOrderBeans = getBeans(OrderLocal.class, New.Literal.of(Order.class)); assert newOrderBeans.size() == 1; Bean<OrderLocal> newOrderBean = newOrderBeans.iterator().next(); assert orderBean.getQualifiers().size() == 2; assert orderBean.getQualifiers().contains(Default.Literal.INSTANCE); assert orderBean.getQualifiers().contains(Any.Literal.INSTANCE); assert orderBean.getTypes().equals(newOrderBean.getTypes()); assert orderBean.getBeanClass().equals(newOrderBean.getBeanClass()); assert newOrderBean.getQualifiers().size() == 1; assert newOrderBean.getQualifiers().iterator().next().annotationType().equals(New.class); Set<Bean<LionLocal>> lionBeans = getBeans(LionLocal.class, TameLiteral.INSTANCE); Set<Bean<LionLocal>> newLionBeans = getBeans(LionLocal.class, New.Literal.of(Lion.class)); assert lionBeans.size() == 1; assert newLionBeans.size() == 1; Bean<LionLocal> lionBean = lionBeans.iterator().next(); Bean<LionLocal> newLionBean = newLionBeans.iterator().next(); assert lionBean.getQualifiers().size() == 2; assert lionBean.getQualifiers().contains(TameLiteral.INSTANCE); assert lionBean.getQualifiers().contains(Any.Literal.INSTANCE); assert newLionBean.getQualifiers().size() == 1; assert newLionBean.getQualifiers().iterator().next().annotationType().equals(New.class); assert lionBean.getTypes().equals(newLionBean.getTypes()); assert lionBean.getBeanClass().equals(newLionBean.getBeanClass()); }
@SuppressWarnings("unchecked") @Test @SpecAssertions({ @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "aa"), @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "ad") }) public void testManagedBeanAttributes() { assertEquals(getCurrentManager().getBeans(Alpha.class, New.Literal.of(Alpha.class)).size(), 1); // No event is fired for any @New qualified bean assertEquals(extension.getAlphaAttributesObserved(), 1); BeanAttributes<Alpha> attributes = extension.getAlphaAttributes(); assertNotNull(attributes); assertEquals(attributes.getScope(), ApplicationScoped.class); verifyName(attributes, "alpha"); assertTrue(attributes.isAlternative()); assertTrue(typeSetMatches(attributes.getTypes(), Object.class, Alpha.class)); assertTrue(typeSetMatches(attributes.getStereotypes(), AlphaStereotype.class)); assertTrue(annotationSetMatches(attributes.getQualifiers(), AlphaQualifier.class, Named.class, Any.class)); // Event is not fired for managed bean that is not enabled assertNull(extension.getMike()); }
/** * Sets up both the bean and the @New bean with different configurations so that the correct producer method used can be * determined. * * @throws Exception */ @Test @SpecAssertion(section = NEW_EE, id = "v") public void testNewBeanHasNoProducerMethods() throws Exception { FoxLocal fox = getContextualReference(FoxLocal.class); FoxLocal newFox = getContextualReference(FoxLocal.class, New.Literal.of(Fox.class)); fox.setNextLitterSize(3); newFox.setNextLitterSize(5); @SuppressWarnings("serial") Litter theOnlyLitter = getContextualReference(Litter.class, new AnnotationLiteral<Tame>() { }); assert theOnlyLitter.getQuantity() == fox.getNextLitterSize(); }
@Test @SpecAssertion(section = NEW_EE, id = "x") public void testNewBeanHasNoDisposalMethods() throws Exception { FoxLocal fox = getContextualReference(FoxLocal.class); FoxLocal newFox = getContextualReference(FoxLocal.class, New.Literal.of(Fox.class)); @SuppressWarnings("serial") Set<Bean<Litter>> beans = getBeans(Litter.class, new AnnotationLiteral<Tame>() { }); assert beans.size() == 1; Bean<Litter> litterBean = beans.iterator().next(); CreationalContext<Litter> creationalContext = getCurrentManager().createCreationalContext(litterBean); Litter litter = litterBean.create(creationalContext); litterBean.destroy(litter, creationalContext); assert fox.isLitterDisposed(); assert !newFox.isLitterDisposed(); }
public static Literal of(Class<?> value) { return new Literal(value); }
public static Literal of(Class<?> value) { return new Literal(value); }
public static Literal of(Class<?> value) { return new Literal(value); }
public static Literal of(Class<?> value) { return new Literal(value); }
private <T> void checkNewQualifiedBean(Bean<T> bean, Type... requiredTypes) { assertTrue(typeSetMatches(bean.getTypes(), requiredTypes)); // Has scope @Dependent, assertEquals(bean.getScope(), Dependent.class); // Has exactly one qualifier... assertTrue(annotationSetMatches(bean.getQualifiers(), New.Literal.of(bean.getBeanClass()))); // Has no bean EL name assertNull(bean.getName()); // Has no stereotypes assertTrue(bean.getStereotypes() == null || bean.getStereotypes().isEmpty()); // Is not an alternative assertFalse(bean.isAlternative()); } }
public static Literal of(Class<?> value) { return new Literal(value); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
public static Literal of(Class<?> value) { return new Literal(value); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
public static Literal of(Class<?> value) { return new Literal(value); }
public static Literal of(Class<?> value) { return new Literal(value); }